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_MD2,
 235         ALC883_MEDION_WIM2160,
 236         ALC883_LAPTOP_EAPD,
 237         ALC883_LENOVO_101E_2ch,
 238         ALC883_LENOVO_NB0763,
 239         ALC888_LENOVO_MS7195_DIG,
 240         ALC888_LENOVO_SKY,
 241         ALC883_HAIER_W66,
 242         ALC888_3ST_HP,
 243         ALC888_6ST_DELL,
 244         ALC883_MITAC,
 245         ALC883_CLEVO_M540R,
 246         ALC883_CLEVO_M720,
 247         ALC883_FUJITSU_PI2515,
 248         ALC888_FUJITSU_XA3530,
 249         ALC883_3ST_6ch_INTEL,
 250         ALC889A_INTEL,
 251         ALC889_INTEL,
 252         ALC888_ASUS_M90V,
 253         ALC888_ASUS_EEE1601,
 254         ALC889A_MB31,
 255         ALC1200_ASUS_P5Q,
 256         ALC883_SONY_VAIO_TT,
 257         ALC882_AUTO,
 258         ALC882_MODEL_LAST,
 259 };
 260
 261 /* ALC680 models */
 262 enum {
 263         ALC680_BASE,
 264         ALC680_AUTO,
 265         ALC680_MODEL_LAST,
 266 };
 267
 268 /* for GPIO Poll */
 269 #define GPIO_MASK       0x03
 270
 271 /* extra amp-initialization sequence types */
 272 enum {
 273         ALC_INIT_NONE,
 274         ALC_INIT_DEFAULT,
 275         ALC_INIT_GPIO1,
 276         ALC_INIT_GPIO2,
 277         ALC_INIT_GPIO3,
 278 };
 279
 280 struct alc_mic_route {
 281         hda_nid_t pin;
 282         unsigned char mux_idx;
 283         unsigned char amix_idx;
 284 };
 285
 286 struct alc_jack {
 287         hda_nid_t nid;
 288         int type;
 289         struct snd_jack *jack;
 290 };
 291
 292 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 293
 294 struct alc_customize_define {
 295         unsigned int  sku_cfg;
 296         unsigned char port_connectivity;
 297         unsigned char check_sum;
 298         unsigned char customization;
 299         unsigned char external_amp;
 300         unsigned int  enable_pcbeep:1;
 301         unsigned int  platform_type:1;
 302         unsigned int  swap:1;
 303         unsigned int  override:1;
 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         err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1091         if (err < 0)
1092                 return err;
1093         alc_report_jack(codec, hp_nid);
1094
1095         err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1096         if (err < 0)
1097                 return err;
1098         alc_report_jack(codec, mic_nid);
1099
1100         return 0;
1101 }
1102 #else
1103 static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1104 {
1105 }
1106
1107 static inline int alc_init_jacks(struct hda_codec *codec)
1108 {
1109         return 0;
1110 }
1111 #endif
1112
1113 static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1114 {
1115         struct alc_spec *spec = codec->spec;
1116         unsigned int mute;
1117         hda_nid_t nid;
1118         int i;
1119
1120         spec->jack_present = 0;
1121         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1122                 nid = spec->autocfg.hp_pins[i];
1123                 if (!nid)
1124                         break;
1125                 if (snd_hda_jack_detect(codec, nid)) {
1126                         spec->jack_present = 1;
1127                         break;
1128                 }
1129                 alc_report_jack(codec, spec->autocfg.hp_pins[i]);
1130         }
1131
1132         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1133         /* Toggle internal speakers muting */
1134         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1135                 nid = spec->autocfg.speaker_pins[i];
1136                 if (!nid)
1137                         break;
1138                 if (pinctl) {
1139                         snd_hda_codec_write(codec, nid, 0,
1140                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1141                                     spec->jack_present ? 0 : PIN_OUT);
1142                 } else {
1143                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1144                                          HDA_AMP_MUTE, mute);
1145                 }
1146         }
1147 }
1148
1149 static void alc_automute_pin(struct hda_codec *codec)
1150 {
1151         alc_automute_speaker(codec, 1);
1152 }
1153
1154 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1155                                 hda_nid_t nid)
1156 {
1157         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1158         int i, nums;
1159
1160         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1161         for (i = 0; i < nums; i++)
1162                 if (conn[i] == nid)
1163                         return i;
1164         return -1;
1165 }
1166
1167 /* switch the current ADC according to the jack state */
1168 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1169 {
1170         struct alc_spec *spec = codec->spec;
1171         unsigned int present;
1172         hda_nid_t new_adc;
1173
1174         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1175         if (present)
1176                 spec->cur_adc_idx = 1;
1177         else
1178                 spec->cur_adc_idx = 0;
1179         new_adc = spec->adc_nids[spec->cur_adc_idx];
1180         if (spec->cur_adc && spec->cur_adc != new_adc) {
1181                 /* stream is running, let's swap the current ADC */
1182                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1183                 spec->cur_adc = new_adc;
1184                 snd_hda_codec_setup_stream(codec, new_adc,
1185                                            spec->cur_adc_stream_tag, 0,
1186                                            spec->cur_adc_format);
1187         }
1188 }
1189
1190 static void alc_mic_automute(struct hda_codec *codec)
1191 {
1192         struct alc_spec *spec = codec->spec;
1193         struct alc_mic_route *dead, *alive;
1194         unsigned int present, type;
1195         hda_nid_t cap_nid;
1196
1197         if (!spec->auto_mic)
1198                 return;
1199         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1200                 return;
1201         if (snd_BUG_ON(!spec->adc_nids))
1202                 return;
1203
1204         if (spec->dual_adc_switch) {
1205                 alc_dual_mic_adc_auto_switch(codec);
1206                 return;
1207         }
1208
1209         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1210
1211         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1212         if (present) {
1213                 alive = &spec->ext_mic;
1214                 dead = &spec->int_mic;
1215         } else {
1216                 alive = &spec->int_mic;
1217                 dead = &spec->ext_mic;
1218         }
1219
1220         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1221         if (type == AC_WID_AUD_MIX) {
1222                 /* Matrix-mixer style (e.g. ALC882) */
1223                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1224                                          alive->mux_idx,
1225                                          HDA_AMP_MUTE, 0);
1226                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1227                                          dead->mux_idx,
1228                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1229         } else {
1230                 /* MUX style (e.g. ALC880) */
1231                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1232                                           AC_VERB_SET_CONNECT_SEL,
1233                                           alive->mux_idx);
1234         }
1235         alc_report_jack(codec, spec->ext_mic.pin);
1236
1237         /* FIXME: analog mixer */
1238 }
1239
1240 /* unsolicited event for HP jack sensing */
1241 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1242 {
1243         if (codec->vendor_id == 0x10ec0880)
1244                 res >>= 28;
1245         else
1246                 res >>= 26;
1247         switch (res) {
1248         case ALC880_HP_EVENT:
1249                 alc_automute_pin(codec);
1250                 break;
1251         case ALC880_MIC_EVENT:
1252                 alc_mic_automute(codec);
1253                 break;
1254         }
1255 }
1256
1257 static void alc_inithook(struct hda_codec *codec)
1258 {
1259         alc_automute_pin(codec);
1260         alc_mic_automute(codec);
1261 }
1262
1263 /* additional initialization for ALC888 variants */
1264 static void alc888_coef_init(struct hda_codec *codec)
1265 {
1266         unsigned int tmp;
1267
1268         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1269         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1270         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1271         if ((tmp & 0xf0) == 0x20)
1272                 /* alc888S-VC */
1273                 snd_hda_codec_read(codec, 0x20, 0,
1274                                    AC_VERB_SET_PROC_COEF, 0x830);
1275          else
1276                  /* alc888-VB */
1277                  snd_hda_codec_read(codec, 0x20, 0,
1278                                     AC_VERB_SET_PROC_COEF, 0x3030);
1279 }
1280
1281 static void alc889_coef_init(struct hda_codec *codec)
1282 {
1283         unsigned int tmp;
1284
1285         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1286         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1287         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1288         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1289 }
1290
1291 /* turn on/off EAPD control (only if available) */
1292 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1293 {
1294         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1295                 return;
1296         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1297                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1298                                     on ? 2 : 0);
1299 }
1300
1301 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1302 {
1303         unsigned int tmp;
1304
1305         switch (type) {
1306         case ALC_INIT_GPIO1:
1307                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1308                 break;
1309         case ALC_INIT_GPIO2:
1310                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1311                 break;
1312         case ALC_INIT_GPIO3:
1313                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1314                 break;
1315         case ALC_INIT_DEFAULT:
1316                 switch (codec->vendor_id) {
1317                 case 0x10ec0260:
1318                         set_eapd(codec, 0x0f, 1);
1319                         set_eapd(codec, 0x10, 1);
1320                         break;
1321                 case 0x10ec0262:
1322                 case 0x10ec0267:
1323                 case 0x10ec0268:
1324                 case 0x10ec0269:
1325                 case 0x10ec0270:
1326                 case 0x10ec0272:
1327                 case 0x10ec0660:
1328                 case 0x10ec0662:
1329                 case 0x10ec0663:
1330                 case 0x10ec0862:
1331                 case 0x10ec0889:
1332                         set_eapd(codec, 0x14, 1);
1333                         set_eapd(codec, 0x15, 1);
1334                         break;
1335                 }
1336                 switch (codec->vendor_id) {
1337                 case 0x10ec0260:
1338                         snd_hda_codec_write(codec, 0x1a, 0,
1339                                             AC_VERB_SET_COEF_INDEX, 7);
1340                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1341                                                  AC_VERB_GET_PROC_COEF, 0);
1342                         snd_hda_codec_write(codec, 0x1a, 0,
1343                                             AC_VERB_SET_COEF_INDEX, 7);
1344                         snd_hda_codec_write(codec, 0x1a, 0,
1345                                             AC_VERB_SET_PROC_COEF,
1346                                             tmp | 0x2010);
1347                         break;
1348                 case 0x10ec0262:
1349                 case 0x10ec0880:
1350                 case 0x10ec0882:
1351                 case 0x10ec0883:
1352                 case 0x10ec0885:
1353                 case 0x10ec0887:
1354                 case 0x10ec0889:
1355                         alc889_coef_init(codec);
1356                         break;
1357                 case 0x10ec0888:
1358                         alc888_coef_init(codec);
1359                         break;
1360 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1361                 case 0x10ec0267:
1362                 case 0x10ec0268:
1363                         snd_hda_codec_write(codec, 0x20, 0,
1364                                             AC_VERB_SET_COEF_INDEX, 7);
1365                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1366                                                  AC_VERB_GET_PROC_COEF, 0);
1367                         snd_hda_codec_write(codec, 0x20, 0,
1368                                             AC_VERB_SET_COEF_INDEX, 7);
1369                         snd_hda_codec_write(codec, 0x20, 0,
1370                                             AC_VERB_SET_PROC_COEF,
1371                                             tmp | 0x3000);
1372                         break;
1373 #endif /* XXX */
1374                 }
1375                 break;
1376         }
1377 }
1378
1379 static void alc_init_auto_hp(struct hda_codec *codec)
1380 {
1381         struct alc_spec *spec = codec->spec;
1382         struct auto_pin_cfg *cfg = &spec->autocfg;
1383         int i;
1384
1385         if (!cfg->hp_pins[0]) {
1386                 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1387                         return;
1388         }
1389
1390         if (!cfg->speaker_pins[0]) {
1391                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1392                         return;
1393                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1394                        sizeof(cfg->speaker_pins));
1395                 cfg->speaker_outs = cfg->line_outs;
1396         }
1397
1398         if (!cfg->hp_pins[0]) {
1399                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1400                        sizeof(cfg->hp_pins));
1401                 cfg->hp_outs = cfg->line_outs;
1402         }
1403
1404         for (i = 0; i < cfg->hp_outs; i++) {
1405                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1406                             cfg->hp_pins[i]);
1407                 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1408                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1409                                   AC_USRSP_EN | ALC880_HP_EVENT);
1410         }
1411         spec->unsol_event = alc_sku_unsol_event;
1412 }
1413
1414 static void alc_init_auto_mic(struct hda_codec *codec)
1415 {
1416         struct alc_spec *spec = codec->spec;
1417         struct auto_pin_cfg *cfg = &spec->autocfg;
1418         hda_nid_t fixed, ext;
1419         int i;
1420
1421         /* there must be only two mic inputs exclusively */
1422         for (i = 0; i < cfg->num_inputs; i++)
1423                 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1424                         return;
1425
1426         fixed = ext = 0;
1427         for (i = 0; i < cfg->num_inputs; i++) {
1428                 hda_nid_t nid = cfg->inputs[i].pin;
1429                 unsigned int defcfg;
1430                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1431                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1432                 case INPUT_PIN_ATTR_INT:
1433                         if (fixed)
1434                                 return; /* already occupied */
1435                         fixed = nid;
1436                         break;
1437                 case INPUT_PIN_ATTR_UNUSED:
1438                         return; /* invalid entry */
1439                 default:
1440                         if (ext)
1441                                 return; /* already occupied */
1442                         ext = nid;
1443                         break;
1444                 }
1445         }
1446         if (!ext || !fixed)
1447                 return;
1448         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1449                 return; /* no unsol support */
1450         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1451                     ext, fixed);
1452         spec->ext_mic.pin = ext;
1453         spec->int_mic.pin = fixed;
1454         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1455         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1456         spec->auto_mic = 1;
1457         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1458                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1459                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1460         spec->unsol_event = alc_sku_unsol_event;
1461 }
1462
1463 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1464 {
1465         unsigned int ass, tmp, i;
1466         unsigned nid = 0;
1467         struct alc_spec *spec = codec->spec;
1468
1469         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1470
1471         ass = codec->subsystem_id & 0xffff;
1472         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1473                 goto do_sku;
1474
1475         nid = 0x1d;
1476         if (codec->vendor_id == 0x10ec0260)
1477                 nid = 0x17;
1478         ass = snd_hda_codec_get_pincfg(codec, nid);
1479
1480         if (!(ass & 1)) {
1481                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1482                        codec->chip_name, ass);
1483                 return -1;
1484         }
1485
1486         /* check sum */
1487         tmp = 0;
1488         for (i = 1; i < 16; i++) {
1489                 if ((ass >> i) & 1)
1490                         tmp++;
1491         }
1492         if (((ass >> 16) & 0xf) != tmp)
1493                 return -1;
1494
1495         spec->cdefine.port_connectivity = ass >> 30;
1496         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1497         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1498         spec->cdefine.customization = ass >> 8;
1499 do_sku:
1500         spec->cdefine.sku_cfg = ass;
1501         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1502         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1503         spec->cdefine.swap = (ass & 0x2) >> 1;
1504         spec->cdefine.override = ass & 0x1;
1505
1506         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1507                    nid, spec->cdefine.sku_cfg);
1508         snd_printd("SKU: port_connectivity=0x%x\n",
1509                    spec->cdefine.port_connectivity);
1510         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1511         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1512         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1513         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1514         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1515         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1516         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1517
1518         return 0;
1519 }
1520
1521 /* check subsystem ID and set up device-specific initialization;
1522  * return 1 if initialized, 0 if invalid SSID
1523  */
1524 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1525  *      31 ~ 16 :       Manufacture ID
1526  *      15 ~ 8  :       SKU ID
1527  *      7  ~ 0  :       Assembly ID
1528  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1529  */
1530 static int alc_subsystem_id(struct hda_codec *codec,
1531                             hda_nid_t porta, hda_nid_t porte,
1532                             hda_nid_t portd, hda_nid_t porti)
1533 {
1534         unsigned int ass, tmp, i;
1535         unsigned nid;
1536         struct alc_spec *spec = codec->spec;
1537
1538         ass = codec->subsystem_id & 0xffff;
1539         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1540                 goto do_sku;
1541
1542         /* invalid SSID, check the special NID pin defcfg instead */
1543         /*
1544          * 31~30        : port connectivity
1545          * 29~21        : reserve
1546          * 20           : PCBEEP input
1547          * 19~16        : Check sum (15:1)
1548          * 15~1         : Custom
1549          * 0            : override
1550         */
1551         nid = 0x1d;
1552         if (codec->vendor_id == 0x10ec0260)
1553                 nid = 0x17;
1554         ass = snd_hda_codec_get_pincfg(codec, nid);
1555         snd_printd("realtek: No valid SSID, "
1556                    "checking pincfg 0x%08x for NID 0x%x\n",
1557                    ass, nid);
1558         if (!(ass & 1))
1559                 return 0;
1560         if ((ass >> 30) != 1)   /* no physical connection */
1561                 return 0;
1562
1563         /* check sum */
1564         tmp = 0;
1565         for (i = 1; i < 16; i++) {
1566                 if ((ass >> i) & 1)
1567                         tmp++;
1568         }
1569         if (((ass >> 16) & 0xf) != tmp)
1570                 return 0;
1571 do_sku:
1572         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1573                    ass & 0xffff, codec->vendor_id);
1574         /*
1575          * 0 : override
1576          * 1 :  Swap Jack
1577          * 2 : 0 --> Desktop, 1 --> Laptop
1578          * 3~5 : External Amplifier control
1579          * 7~6 : Reserved
1580         */
1581         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1582         switch (tmp) {
1583         case 1:
1584                 spec->init_amp = ALC_INIT_GPIO1;
1585                 break;
1586         case 3:
1587                 spec->init_amp = ALC_INIT_GPIO2;
1588                 break;
1589         case 7:
1590                 spec->init_amp = ALC_INIT_GPIO3;
1591                 break;
1592         case 5:
1593                 spec->init_amp = ALC_INIT_DEFAULT;
1594                 break;
1595         }
1596
1597         /* is laptop or Desktop and enable the function "Mute internal speaker
1598          * when the external headphone out jack is plugged"
1599          */
1600         if (!(ass & 0x8000))
1601                 return 1;
1602         /*
1603          * 10~8 : Jack location
1604          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1605          * 14~13: Resvered
1606          * 15   : 1 --> enable the function "Mute internal speaker
1607          *              when the external headphone out jack is plugged"
1608          */
1609         if (!spec->autocfg.hp_pins[0]) {
1610                 hda_nid_t nid;
1611                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1612                 if (tmp == 0)
1613                         nid = porta;
1614                 else if (tmp == 1)
1615                         nid = porte;
1616                 else if (tmp == 2)
1617                         nid = portd;
1618                 else if (tmp == 3)
1619                         nid = porti;
1620                 else
1621                         return 1;
1622                 for (i = 0; i < spec->autocfg.line_outs; i++)
1623                         if (spec->autocfg.line_out_pins[i] == nid)
1624                                 return 1;
1625                 spec->autocfg.hp_pins[0] = nid;
1626         }
1627
1628         alc_init_auto_hp(codec);
1629         alc_init_auto_mic(codec);
1630         return 1;
1631 }
1632
1633 static void alc_ssid_check(struct hda_codec *codec,
1634                            hda_nid_t porta, hda_nid_t porte,
1635                            hda_nid_t portd, hda_nid_t porti)
1636 {
1637         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1638                 struct alc_spec *spec = codec->spec;
1639                 snd_printd("realtek: "
1640                            "Enable default setup for auto mode as fallback\n");
1641                 spec->init_amp = ALC_INIT_DEFAULT;
1642                 alc_init_auto_hp(codec);
1643                 alc_init_auto_mic(codec);
1644         }
1645 }
1646
1647 /*
1648  * Fix-up pin default configurations and add default verbs
1649  */
1650
1651 struct alc_pincfg {
1652         hda_nid_t nid;
1653         u32 val;
1654 };
1655
1656 struct alc_fixup {
1657         const struct alc_pincfg *pins;
1658         const struct hda_verb *verbs;
1659 };
1660
1661 static void alc_pick_fixup(struct hda_codec *codec,
1662                            const struct snd_pci_quirk *quirk,
1663                            const struct alc_fixup *fix,
1664                            int pre_init)
1665 {
1666         const struct alc_pincfg *cfg;
1667
1668         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1669         if (!quirk)
1670                 return;
1671         fix += quirk->value;
1672         cfg = fix->pins;
1673         if (pre_init && cfg) {
1674 #ifdef CONFIG_SND_DEBUG_VERBOSE
1675                 snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
1676                             codec->chip_name, quirk->name);
1677 #endif
1678                 for (; cfg->nid; cfg++)
1679                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1680         }
1681         if (!pre_init && fix->verbs) {
1682 #ifdef CONFIG_SND_DEBUG_VERBOSE
1683                 snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
1684                             codec->chip_name, quirk->name);
1685 #endif
1686                 add_verb(codec->spec, fix->verbs);
1687         }
1688 }
1689
1690 static int alc_read_coef_idx(struct hda_codec *codec,
1691                         unsigned int coef_idx)
1692 {
1693         unsigned int val;
1694         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1695                                 coef_idx);
1696         val = snd_hda_codec_read(codec, 0x20, 0,
1697                                 AC_VERB_GET_PROC_COEF, 0);
1698         return val;
1699 }
1700
1701 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1702                                                         unsigned int coef_val)
1703 {
1704         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1705                             coef_idx);
1706         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1707                             coef_val);
1708 }
1709
1710 /* set right pin controls for digital I/O */
1711 static void alc_auto_init_digital(struct hda_codec *codec)
1712 {
1713         struct alc_spec *spec = codec->spec;
1714         int i;
1715         hda_nid_t pin;
1716
1717         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1718                 pin = spec->autocfg.dig_out_pins[i];
1719                 if (pin) {
1720                         snd_hda_codec_write(codec, pin, 0,
1721                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1722                                             PIN_OUT);
1723                 }
1724         }
1725         pin = spec->autocfg.dig_in_pin;
1726         if (pin)
1727                 snd_hda_codec_write(codec, pin, 0,
1728                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1729                                     PIN_IN);
1730 }
1731
1732 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1733 static void alc_auto_parse_digital(struct hda_codec *codec)
1734 {
1735         struct alc_spec *spec = codec->spec;
1736         int i, err;
1737         hda_nid_t dig_nid;
1738
1739         /* support multiple SPDIFs; the secondary is set up as a slave */
1740         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1741                 err = snd_hda_get_connections(codec,
1742                                               spec->autocfg.dig_out_pins[i],
1743                                               &dig_nid, 1);
1744                 if (err < 0)
1745                         continue;
1746                 if (!i) {
1747                         spec->multiout.dig_out_nid = dig_nid;
1748                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1749                 } else {
1750                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1751                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1752                                 break;
1753                         spec->slave_dig_outs[i - 1] = dig_nid;
1754                 }
1755         }
1756
1757         if (spec->autocfg.dig_in_pin) {
1758                 hda_nid_t dig_nid;
1759                 err = snd_hda_get_connections(codec,
1760                                               spec->autocfg.dig_in_pin,
1761                                               &dig_nid, 1);
1762                 if (err > 0)
1763                         spec->dig_in_nid = dig_nid;
1764         }
1765 }
1766
1767 /*
1768  * ALC888
1769  */
1770
1771 /*
1772  * 2ch mode
1773  */
1774 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1775 /* Mic-in jack as mic in */
1776         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1777         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1778 /* Line-in jack as Line in */
1779         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1780         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1781 /* Line-Out as Front */
1782         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1783         { } /* end */
1784 };
1785
1786 /*
1787  * 4ch mode
1788  */
1789 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1790 /* Mic-in jack as mic in */
1791         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1792         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1793 /* Line-in jack as Surround */
1794         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1795         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1796 /* Line-Out as Front */
1797         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1798         { } /* end */
1799 };
1800
1801 /*
1802  * 6ch mode
1803  */
1804 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1805 /* Mic-in jack as CLFE */
1806         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1807         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1808 /* Line-in jack as Surround */
1809         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1810         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1811 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1812         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1813         { } /* end */
1814 };
1815
1816 /*
1817  * 8ch mode
1818  */
1819 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1820 /* Mic-in jack as CLFE */
1821         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1822         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1823 /* Line-in jack as Surround */
1824         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1825         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1826 /* Line-Out as Side */
1827         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1828         { } /* end */
1829 };
1830
1831 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1832         { 2, alc888_4ST_ch2_intel_init },
1833         { 4, alc888_4ST_ch4_intel_init },
1834         { 6, alc888_4ST_ch6_intel_init },
1835         { 8, alc888_4ST_ch8_intel_init },
1836 };
1837
1838 /*
1839  * ALC888 Fujitsu Siemens Amillo xa3530
1840  */
1841
1842 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1843 /* Front Mic: set to PIN_IN (empty by default) */
1844         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1845 /* Connect Internal HP to Front */
1846         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1847         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1848         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1849 /* Connect Bass HP to Front */
1850         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1851         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1852         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1853 /* Connect Line-Out side jack (SPDIF) to Side */
1854         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1855         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1856         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1857 /* Connect Mic jack to CLFE */
1858         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1859         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1860         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1861 /* Connect Line-in jack to Surround */
1862         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1863         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1864         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1865 /* Connect HP out jack to Front */
1866         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1867         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1868         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1869 /* Enable unsolicited event for HP jack and Line-out jack */
1870         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1871         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1872         {}
1873 };
1874
1875 static void alc_automute_amp(struct hda_codec *codec)
1876 {
1877         alc_automute_speaker(codec, 0);
1878 }
1879
1880 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1881                                          unsigned int res)
1882 {
1883         if (codec->vendor_id == 0x10ec0880)
1884                 res >>= 28;
1885         else
1886                 res >>= 26;
1887         if (res == ALC880_HP_EVENT)
1888                 alc_automute_amp(codec);
1889 }
1890
1891 static void alc889_automute_setup(struct hda_codec *codec)
1892 {
1893         struct alc_spec *spec = codec->spec;
1894
1895         spec->autocfg.hp_pins[0] = 0x15;
1896         spec->autocfg.speaker_pins[0] = 0x14;
1897         spec->autocfg.speaker_pins[1] = 0x16;
1898         spec->autocfg.speaker_pins[2] = 0x17;
1899         spec->autocfg.speaker_pins[3] = 0x19;
1900         spec->autocfg.speaker_pins[4] = 0x1a;
1901 }
1902
1903 static void alc889_intel_init_hook(struct hda_codec *codec)
1904 {
1905         alc889_coef_init(codec);
1906         alc_automute_amp(codec);
1907 }
1908
1909 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1910 {
1911         struct alc_spec *spec = codec->spec;
1912
1913         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1914         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1915         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1916         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1917 }
1918
1919 /*
1920  * ALC888 Acer Aspire 4930G model
1921  */
1922
1923 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1924 /* Front Mic: set to PIN_IN (empty by default) */
1925         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1926 /* Unselect Front Mic by default in input mixer 3 */
1927         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1928 /* Enable unsolicited event for HP jack */
1929         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1930 /* Connect Internal HP to front */
1931         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1932         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1933         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1934 /* Connect HP out to front */
1935         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1936         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1937         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1938         { }
1939 };
1940
1941 /*
1942  * ALC888 Acer Aspire 6530G model
1943  */
1944
1945 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1946 /* Route to built-in subwoofer as well as speakers */
1947         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1948         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1949         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1950         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1951 /* Bias voltage on for external mic port */
1952         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1953 /* Front Mic: set to PIN_IN (empty by default) */
1954         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1955 /* Unselect Front Mic by default in input mixer 3 */
1956         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1957 /* Enable unsolicited event for HP jack */
1958         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1959 /* Enable speaker output */
1960         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1961         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1962         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
1963 /* Enable headphone output */
1964         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1965         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1966         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1967         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
1968         { }
1969 };
1970
1971 /*
1972  * ALC889 Acer Aspire 8930G model
1973  */
1974
1975 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1976 /* Front Mic: set to PIN_IN (empty by default) */
1977         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1978 /* Unselect Front Mic by default in input mixer 3 */
1979         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1980 /* Enable unsolicited event for HP jack */
1981         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1982 /* Connect Internal Front to Front */
1983         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1984         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1985         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1986 /* Connect Internal Rear to Rear */
1987         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1988         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1989         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1990 /* Connect Internal CLFE to CLFE */
1991         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1992         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1993         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1994 /* Connect HP out to Front */
1995         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1996         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1997         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1998 /* Enable all DACs */
1999 /*  DAC DISABLE/MUTE 1? */
2000 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2001         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2002         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2003 /*  DAC DISABLE/MUTE 2? */
2004 /*  some bit here disables the other DACs. Init=0x4900 */
2005         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2006         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2007 /* DMIC fix
2008  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2009  * which makes the stereo useless. However, either the mic or the ALC889
2010  * makes the signal become a difference/sum signal instead of standard
2011  * stereo, which is annoying. So instead we flip this bit which makes the
2012  * codec replicate the sum signal to both channels, turning it into a
2013  * normal mono mic.
2014  */
2015 /*  DMIC_CONTROL? Init value = 0x0001 */
2016         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2017         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2018         { }
2019 };
2020
2021 static struct hda_input_mux alc888_2_capture_sources[2] = {
2022         /* Front mic only available on one ADC */
2023         {
2024                 .num_items = 4,
2025                 .items = {
2026                         { "Mic", 0x0 },
2027                         { "Line", 0x2 },
2028                         { "CD", 0x4 },
2029                         { "Front Mic", 0xb },
2030                 },
2031         },
2032         {
2033                 .num_items = 3,
2034                 .items = {
2035                         { "Mic", 0x0 },
2036                         { "Line", 0x2 },
2037                         { "CD", 0x4 },
2038                 },
2039         }
2040 };
2041
2042 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2043         /* Interal mic only available on one ADC */
2044         {
2045                 .num_items = 5,
2046                 .items = {
2047                         { "Ext Mic", 0x0 },
2048                         { "Line In", 0x2 },
2049                         { "CD", 0x4 },
2050                         { "Input Mix", 0xa },
2051                         { "Int Mic", 0xb },
2052                 },
2053         },
2054         {
2055                 .num_items = 4,
2056                 .items = {
2057                         { "Ext Mic", 0x0 },
2058                         { "Line In", 0x2 },
2059                         { "CD", 0x4 },
2060                         { "Input Mix", 0xa },
2061                 },
2062         }
2063 };
2064
2065 static struct hda_input_mux alc889_capture_sources[3] = {
2066         /* Digital mic only available on first "ADC" */
2067         {
2068                 .num_items = 5,
2069                 .items = {
2070                         { "Mic", 0x0 },
2071                         { "Line", 0x2 },
2072                         { "CD", 0x4 },
2073                         { "Front Mic", 0xb },
2074                         { "Input Mix", 0xa },
2075                 },
2076         },
2077         {
2078                 .num_items = 4,
2079                 .items = {
2080                         { "Mic", 0x0 },
2081                         { "Line", 0x2 },
2082                         { "CD", 0x4 },
2083                         { "Input Mix", 0xa },
2084                 },
2085         },
2086         {
2087                 .num_items = 4,
2088                 .items = {
2089                         { "Mic", 0x0 },
2090                         { "Line", 0x2 },
2091                         { "CD", 0x4 },
2092                         { "Input Mix", 0xa },
2093                 },
2094         }
2095 };
2096
2097 static struct snd_kcontrol_new alc888_base_mixer[] = {
2098         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2099         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2100         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2101         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2102         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2103                 HDA_OUTPUT),
2104         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2105         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2106         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2107         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2108         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2109         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2110         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2111         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2112         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2113         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2114         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2115         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2116         { } /* end */
2117 };
2118
2119 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2120         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2121         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2122         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2123         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2124         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2125                 HDA_OUTPUT),
2126         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2127         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2128         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2129         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2130         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2131         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2132         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2133         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2134         { } /* end */
2135 };
2136
2137
2138 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2139 {
2140         struct alc_spec *spec = codec->spec;
2141
2142         spec->autocfg.hp_pins[0] = 0x15;
2143         spec->autocfg.speaker_pins[0] = 0x14;
2144         spec->autocfg.speaker_pins[1] = 0x16;
2145         spec->autocfg.speaker_pins[2] = 0x17;
2146 }
2147
2148 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2149 {
2150         struct alc_spec *spec = codec->spec;
2151
2152         spec->autocfg.hp_pins[0] = 0x15;
2153         spec->autocfg.speaker_pins[0] = 0x14;
2154         spec->autocfg.speaker_pins[1] = 0x16;
2155         spec->autocfg.speaker_pins[2] = 0x17;
2156 }
2157
2158 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2159 {
2160         struct alc_spec *spec = codec->spec;
2161
2162         spec->autocfg.hp_pins[0] = 0x15;
2163         spec->autocfg.speaker_pins[0] = 0x14;
2164         spec->autocfg.speaker_pins[1] = 0x16;
2165         spec->autocfg.speaker_pins[2] = 0x1b;
2166 }
2167
2168 /*
2169  * ALC880 3-stack model
2170  *
2171  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2172  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2173  *                 F-Mic = 0x1b, HP = 0x19
2174  */
2175
2176 static hda_nid_t alc880_dac_nids[4] = {
2177         /* front, rear, clfe, rear_surr */
2178         0x02, 0x05, 0x04, 0x03
2179 };
2180
2181 static hda_nid_t alc880_adc_nids[3] = {
2182         /* ADC0-2 */
2183         0x07, 0x08, 0x09,
2184 };
2185
2186 /* The datasheet says the node 0x07 is connected from inputs,
2187  * but it shows zero connection in the real implementation on some devices.
2188  * Note: this is a 915GAV bug, fixed on 915GLV
2189  */
2190 static hda_nid_t alc880_adc_nids_alt[2] = {
2191         /* ADC1-2 */
2192         0x08, 0x09,
2193 };
2194
2195 #define ALC880_DIGOUT_NID       0x06
2196 #define ALC880_DIGIN_NID        0x0a
2197
2198 static struct hda_input_mux alc880_capture_source = {
2199         .num_items = 4,
2200         .items = {
2201                 { "Mic", 0x0 },
2202                 { "Front Mic", 0x3 },
2203                 { "Line", 0x2 },
2204                 { "CD", 0x4 },
2205         },
2206 };
2207
2208 /* channel source setting (2/6 channel selection for 3-stack) */
2209 /* 2ch mode */
2210 static struct hda_verb alc880_threestack_ch2_init[] = {
2211         /* set line-in to input, mute it */
2212         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2213         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2214         /* set mic-in to input vref 80%, mute it */
2215         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2216         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2217         { } /* end */
2218 };
2219
2220 /* 6ch mode */
2221 static struct hda_verb alc880_threestack_ch6_init[] = {
2222         /* set line-in to output, unmute it */
2223         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2224         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2225         /* set mic-in to output, unmute it */
2226         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2227         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2228         { } /* end */
2229 };
2230
2231 static struct hda_channel_mode alc880_threestack_modes[2] = {
2232         { 2, alc880_threestack_ch2_init },
2233         { 6, alc880_threestack_ch6_init },
2234 };
2235
2236 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2237         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2238         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2239         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2240         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2241         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2242         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2243         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2244         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2245         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2246         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2247         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2248         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2249         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2250         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2251         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2252         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2253         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2254         {
2255                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2256                 .name = "Channel Mode",
2257                 .info = alc_ch_mode_info,
2258                 .get = alc_ch_mode_get,
2259                 .put = alc_ch_mode_put,
2260         },
2261         { } /* end */
2262 };
2263
2264 /* capture mixer elements */
2265 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2266                             struct snd_ctl_elem_info *uinfo)
2267 {
2268         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2269         struct alc_spec *spec = codec->spec;
2270         int err;
2271
2272         mutex_lock(&codec->control_mutex);
2273         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2274                                                       HDA_INPUT);
2275         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2276         mutex_unlock(&codec->control_mutex);
2277         return err;
2278 }
2279
2280 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2281                            unsigned int size, unsigned int __user *tlv)
2282 {
2283         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2284         struct alc_spec *spec = codec->spec;
2285         int err;
2286
2287         mutex_lock(&codec->control_mutex);
2288         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2289                                                       HDA_INPUT);
2290         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2291         mutex_unlock(&codec->control_mutex);
2292         return err;
2293 }
2294
2295 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2296                              struct snd_ctl_elem_value *ucontrol);
2297
2298 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2299                                  struct snd_ctl_elem_value *ucontrol,
2300                                  getput_call_t func)
2301 {
2302         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2303         struct alc_spec *spec = codec->spec;
2304         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2305         int err;
2306
2307         mutex_lock(&codec->control_mutex);
2308         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2309                                                       3, 0, HDA_INPUT);
2310         err = func(kcontrol, ucontrol);
2311         mutex_unlock(&codec->control_mutex);
2312         return err;
2313 }
2314
2315 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2316                            struct snd_ctl_elem_value *ucontrol)
2317 {
2318         return alc_cap_getput_caller(kcontrol, ucontrol,
2319                                      snd_hda_mixer_amp_volume_get);
2320 }
2321
2322 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2323                            struct snd_ctl_elem_value *ucontrol)
2324 {
2325         return alc_cap_getput_caller(kcontrol, ucontrol,
2326                                      snd_hda_mixer_amp_volume_put);
2327 }
2328
2329 /* capture mixer elements */
2330 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2331
2332 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2333                           struct snd_ctl_elem_value *ucontrol)
2334 {
2335         return alc_cap_getput_caller(kcontrol, ucontrol,
2336                                      snd_hda_mixer_amp_switch_get);
2337 }
2338
2339 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2340                           struct snd_ctl_elem_value *ucontrol)
2341 {
2342         return alc_cap_getput_caller(kcontrol, ucontrol,
2343                                      snd_hda_mixer_amp_switch_put);
2344 }
2345
2346 #define _DEFINE_CAPMIX(num) \
2347         { \
2348                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2349                 .name = "Capture Switch", \
2350                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2351                 .count = num, \
2352                 .info = alc_cap_sw_info, \
2353                 .get = alc_cap_sw_get, \
2354                 .put = alc_cap_sw_put, \
2355         }, \
2356         { \
2357                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2358                 .name = "Capture Volume", \
2359                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2360                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2361                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2362                 .count = num, \
2363                 .info = alc_cap_vol_info, \
2364                 .get = alc_cap_vol_get, \
2365                 .put = alc_cap_vol_put, \
2366                 .tlv = { .c = alc_cap_vol_tlv }, \
2367         }
2368
2369 #define _DEFINE_CAPSRC(num) \
2370         { \
2371                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2372                 /* .name = "Capture Source", */ \
2373                 .name = "Input Source", \
2374                 .count = num, \
2375                 .info = alc_mux_enum_info, \
2376                 .get = alc_mux_enum_get, \
2377                 .put = alc_mux_enum_put, \
2378         }
2379
2380 #define DEFINE_CAPMIX(num) \
2381 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2382         _DEFINE_CAPMIX(num),                                  \
2383         _DEFINE_CAPSRC(num),                                  \
2384         { } /* end */                                         \
2385 }
2386
2387 #define DEFINE_CAPMIX_NOSRC(num) \
2388 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2389         _DEFINE_CAPMIX(num),                                        \
2390         { } /* end */                                               \
2391 }
2392
2393 /* up to three ADCs */
2394 DEFINE_CAPMIX(1);
2395 DEFINE_CAPMIX(2);
2396 DEFINE_CAPMIX(3);
2397 DEFINE_CAPMIX_NOSRC(1);
2398 DEFINE_CAPMIX_NOSRC(2);
2399 DEFINE_CAPMIX_NOSRC(3);
2400
2401 /*
2402  * ALC880 5-stack model
2403  *
2404  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2405  *      Side = 0x02 (0xd)
2406  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2407  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2408  */
2409
2410 /* additional mixers to alc880_three_stack_mixer */
2411 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2412         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2413         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2414         { } /* end */
2415 };
2416
2417 /* channel source setting (6/8 channel selection for 5-stack) */
2418 /* 6ch mode */
2419 static struct hda_verb alc880_fivestack_ch6_init[] = {
2420         /* set line-in to input, mute it */
2421         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2422         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2423         { } /* end */
2424 };
2425
2426 /* 8ch mode */
2427 static struct hda_verb alc880_fivestack_ch8_init[] = {
2428         /* set line-in to output, unmute it */
2429         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2430         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2431         { } /* end */
2432 };
2433
2434 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2435         { 6, alc880_fivestack_ch6_init },
2436         { 8, alc880_fivestack_ch8_init },
2437 };
2438
2439
2440 /*
2441  * ALC880 6-stack model
2442  *
2443  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2444  *      Side = 0x05 (0x0f)
2445  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2446  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2447  */
2448
2449 static hda_nid_t alc880_6st_dac_nids[4] = {
2450         /* front, rear, clfe, rear_surr */
2451         0x02, 0x03, 0x04, 0x05
2452 };
2453
2454 static struct hda_input_mux alc880_6stack_capture_source = {
2455         .num_items = 4,
2456         .items = {
2457                 { "Mic", 0x0 },
2458                 { "Front Mic", 0x1 },
2459                 { "Line", 0x2 },
2460                 { "CD", 0x4 },
2461         },
2462 };
2463
2464 /* fixed 8-channels */
2465 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2466         { 8, NULL },
2467 };
2468
2469 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2470         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2471         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2472         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2473         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2474         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2475         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2476         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2477         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2478         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2479         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2480         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2481         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2482         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2483         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2484         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2485         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2486         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2487         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2488         {
2489                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2490                 .name = "Channel Mode",
2491                 .info = alc_ch_mode_info,
2492                 .get = alc_ch_mode_get,
2493                 .put = alc_ch_mode_put,
2494         },
2495         { } /* end */
2496 };
2497
2498
2499 /*
2500  * ALC880 W810 model
2501  *
2502  * W810 has rear IO for:
2503  * Front (DAC 02)
2504  * Surround (DAC 03)
2505  * Center/LFE (DAC 04)
2506  * Digital out (06)
2507  *
2508  * The system also has a pair of internal speakers, and a headphone jack.
2509  * These are both connected to Line2 on the codec, hence to DAC 02.
2510  *
2511  * There is a variable resistor to control the speaker or headphone
2512  * volume. This is a hardware-only device without a software API.
2513  *
2514  * Plugging headphones in will disable the internal speakers. This is
2515  * implemented in hardware, not via the driver using jack sense. In
2516  * a similar fashion, plugging into the rear socket marked "front" will
2517  * disable both the speakers and headphones.
2518  *
2519  * For input, there's a microphone jack, and an "audio in" jack.
2520  * These may not do anything useful with this driver yet, because I
2521  * haven't setup any initialization verbs for these yet...
2522  */
2523
2524 static hda_nid_t alc880_w810_dac_nids[3] = {
2525         /* front, rear/surround, clfe */
2526         0x02, 0x03, 0x04
2527 };
2528
2529 /* fixed 6 channels */
2530 static struct hda_channel_mode alc880_w810_modes[1] = {
2531         { 6, NULL }
2532 };
2533
2534 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2535 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2536         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2537         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2538         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2539         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2540         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2541         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2542         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2543         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2544         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2545         { } /* end */
2546 };
2547
2548
2549 /*
2550  * Z710V model
2551  *
2552  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2553  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2554  *                 Line = 0x1a
2555  */
2556
2557 static hda_nid_t alc880_z71v_dac_nids[1] = {
2558         0x02
2559 };
2560 #define ALC880_Z71V_HP_DAC      0x03
2561
2562 /* fixed 2 channels */
2563 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2564         { 2, NULL }
2565 };
2566
2567 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2568         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2569         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2570         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2571         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2572         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2573         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2574         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2575         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2576         { } /* end */
2577 };
2578
2579
2580 /*
2581  * ALC880 F1734 model
2582  *
2583  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2584  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2585  */
2586
2587 static hda_nid_t alc880_f1734_dac_nids[1] = {
2588         0x03
2589 };
2590 #define ALC880_F1734_HP_DAC     0x02
2591
2592 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2593         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2594         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2595         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2596         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2597         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2598         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2599         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2600         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2601         { } /* end */
2602 };
2603
2604 static struct hda_input_mux alc880_f1734_capture_source = {
2605         .num_items = 2,
2606         .items = {
2607                 { "Mic", 0x1 },
2608                 { "CD", 0x4 },
2609         },
2610 };
2611
2612
2613 /*
2614  * ALC880 ASUS model
2615  *
2616  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2617  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2618  *  Mic = 0x18, Line = 0x1a
2619  */
2620
2621 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2622 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2623
2624 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2625         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2626         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2627         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2628         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2629         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2630         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2631         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2632         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2633         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2634         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2635         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2636         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2637         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2638         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2639         {
2640                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2641                 .name = "Channel Mode",
2642                 .info = alc_ch_mode_info,
2643                 .get = alc_ch_mode_get,
2644                 .put = alc_ch_mode_put,
2645         },
2646         { } /* end */
2647 };
2648
2649 /*
2650  * ALC880 ASUS W1V model
2651  *
2652  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2653  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2654  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2655  */
2656
2657 /* additional mixers to alc880_asus_mixer */
2658 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2659         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2660         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2661         { } /* end */
2662 };
2663
2664 /* TCL S700 */
2665 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2666         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2667         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2668         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2669         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2670         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2671         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2672         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2673         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2674         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2675         { } /* end */
2676 };
2677
2678 /* Uniwill */
2679 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2680         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2681         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2682         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2683         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2684         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2685         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2686         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2687         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2688         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2689         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2690         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2691         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2692         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2693         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2694         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2695         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2696         {
2697                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2698                 .name = "Channel Mode",
2699                 .info = alc_ch_mode_info,
2700                 .get = alc_ch_mode_get,
2701                 .put = alc_ch_mode_put,
2702         },
2703         { } /* end */
2704 };
2705
2706 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2707         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2708         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2709         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2710         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2711         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2712         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2713         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2714         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2715         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2716         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2717         { } /* end */
2718 };
2719
2720 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2721         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2722         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2723         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2724         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2725         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2726         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2727         { } /* end */
2728 };
2729
2730 /*
2731  * virtual master controls
2732  */
2733
2734 /*
2735  * slave controls for virtual master
2736  */
2737 static const char *alc_slave_vols[] = {
2738         "Front Playback Volume",
2739         "Surround Playback Volume",
2740         "Center Playback Volume",
2741         "LFE Playback Volume",
2742         "Side Playback Volume",
2743         "Headphone Playback Volume",
2744         "Speaker Playback Volume",
2745         "Mono Playback Volume",
2746         "Line-Out Playback Volume",
2747         "PCM Playback Volume",
2748         NULL,
2749 };
2750
2751 static const char *alc_slave_sws[] = {
2752         "Front Playback Switch",
2753         "Surround Playback Switch",
2754         "Center Playback Switch",
2755         "LFE Playback Switch",
2756         "Side Playback Switch",
2757         "Headphone Playback Switch",
2758         "Speaker Playback Switch",
2759         "Mono Playback Switch",
2760         "IEC958 Playback Switch",
2761         "Line-Out Playback Switch",
2762         "PCM Playback Switch",
2763         NULL,
2764 };
2765
2766 /*
2767  * build control elements
2768  */
2769
2770 #define NID_MAPPING             (-1)
2771
2772 #define SUBDEV_SPEAKER_         (0 << 6)
2773 #define SUBDEV_HP_              (1 << 6)
2774 #define SUBDEV_LINE_            (2 << 6)
2775 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2776 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2777 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2778
2779 static void alc_free_kctls(struct hda_codec *codec);
2780
2781 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2782 /* additional beep mixers; the actual parameters are overwritten at build */
2783 static struct snd_kcontrol_new alc_beep_mixer[] = {
2784         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2785         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2786         { } /* end */
2787 };
2788 #endif
2789
2790 static int alc_build_controls(struct hda_codec *codec)
2791 {
2792         struct alc_spec *spec = codec->spec;
2793         struct snd_kcontrol *kctl = NULL;
2794         struct snd_kcontrol_new *knew;
2795         int i, j, err;
2796         unsigned int u;
2797         hda_nid_t nid;
2798
2799         for (i = 0; i < spec->num_mixers; i++) {
2800                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2801                 if (err < 0)
2802                         return err;
2803         }
2804         if (spec->cap_mixer) {
2805                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2806                 if (err < 0)
2807                         return err;
2808         }
2809         if (spec->multiout.dig_out_nid) {
2810                 err = snd_hda_create_spdif_out_ctls(codec,
2811                                                     spec->multiout.dig_out_nid);
2812                 if (err < 0)
2813                         return err;
2814                 if (!spec->no_analog) {
2815                         err = snd_hda_create_spdif_share_sw(codec,
2816                                                             &spec->multiout);
2817                         if (err < 0)
2818                                 return err;
2819                         spec->multiout.share_spdif = 1;
2820                 }
2821         }
2822         if (spec->dig_in_nid) {
2823                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2824                 if (err < 0)
2825                         return err;
2826         }
2827
2828 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2829         /* create beep controls if needed */
2830         if (spec->beep_amp) {
2831                 struct snd_kcontrol_new *knew;
2832                 for (knew = alc_beep_mixer; knew->name; knew++) {
2833                         struct snd_kcontrol *kctl;
2834                         kctl = snd_ctl_new1(knew, codec);
2835                         if (!kctl)
2836                                 return -ENOMEM;
2837                         kctl->private_value = spec->beep_amp;
2838                         err = snd_hda_ctl_add(codec, 0, kctl);
2839                         if (err < 0)
2840                                 return err;
2841                 }
2842         }
2843 #endif
2844
2845         /* if we have no master control, let's create it */
2846         if (!spec->no_analog &&
2847             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2848                 unsigned int vmaster_tlv[4];
2849                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2850                                         HDA_OUTPUT, vmaster_tlv);
2851                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2852                                           vmaster_tlv, alc_slave_vols);
2853                 if (err < 0)
2854                         return err;
2855         }
2856         if (!spec->no_analog &&
2857             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2858                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2859                                           NULL, alc_slave_sws);
2860                 if (err < 0)
2861                         return err;
2862         }
2863
2864         /* assign Capture Source enums to NID */
2865         if (spec->capsrc_nids || spec->adc_nids) {
2866                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2867                 if (!kctl)
2868                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2869                 for (i = 0; kctl && i < kctl->count; i++) {
2870                         hda_nid_t *nids = spec->capsrc_nids;
2871                         if (!nids)
2872                                 nids = spec->adc_nids;
2873                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2874                         if (err < 0)
2875                                 return err;
2876                 }
2877         }
2878         if (spec->cap_mixer) {
2879                 const char *kname = kctl ? kctl->id.name : NULL;
2880                 for (knew = spec->cap_mixer; knew->name; knew++) {
2881                         if (kname && strcmp(knew->name, kname) == 0)
2882                                 continue;
2883                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2884                         for (i = 0; kctl && i < kctl->count; i++) {
2885                                 err = snd_hda_add_nid(codec, kctl, i,
2886                                                       spec->adc_nids[i]);
2887                                 if (err < 0)
2888                                         return err;
2889                         }
2890                 }
2891         }
2892
2893         /* other nid->control mapping */
2894         for (i = 0; i < spec->num_mixers; i++) {
2895                 for (knew = spec->mixers[i]; knew->name; knew++) {
2896                         if (knew->iface != NID_MAPPING)
2897                                 continue;
2898                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2899                         if (kctl == NULL)
2900                                 continue;
2901                         u = knew->subdevice;
2902                         for (j = 0; j < 4; j++, u >>= 8) {
2903                                 nid = u & 0x3f;
2904                                 if (nid == 0)
2905                                         continue;
2906                                 switch (u & 0xc0) {
2907                                 case SUBDEV_SPEAKER_:
2908                                         nid = spec->autocfg.speaker_pins[nid];
2909                                         break;
2910                                 case SUBDEV_LINE_:
2911                                         nid = spec->autocfg.line_out_pins[nid];
2912                                         break;
2913                                 case SUBDEV_HP_:
2914                                         nid = spec->autocfg.hp_pins[nid];
2915                                         break;
2916                                 default:
2917                                         continue;
2918                                 }
2919                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2920                                 if (err < 0)
2921                                         return err;
2922                         }
2923                         u = knew->private_value;
2924                         for (j = 0; j < 4; j++, u >>= 8) {
2925                                 nid = u & 0xff;
2926                                 if (nid == 0)
2927                                         continue;
2928                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2929                                 if (err < 0)
2930                                         return err;
2931                         }
2932                 }
2933         }
2934
2935         alc_free_kctls(codec); /* no longer needed */
2936
2937         return 0;
2938 }
2939
2940
2941 /*
2942  * initialize the codec volumes, etc
2943  */
2944
2945 /*
2946  * generic initialization of ADC, input mixers and output mixers
2947  */
2948 static struct hda_verb alc880_volume_init_verbs[] = {
2949         /*
2950          * Unmute ADC0-2 and set the default input to mic-in
2951          */
2952         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2953         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2954         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2955         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2956         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2957         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2958
2959         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2960          * mixer widget
2961          * Note: PASD motherboards uses the Line In 2 as the input for front
2962          * panel mic (mic 2)
2963          */
2964         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2965         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2966         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2967         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2968         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2969         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2970         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2971         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2972
2973         /*
2974          * Set up output mixers (0x0c - 0x0f)
2975          */
2976         /* set vol=0 to output mixers */
2977         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2978         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2979         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2980         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2981         /* set up input amps for analog loopback */
2982         /* Amp Indices: DAC = 0, mixer = 1 */
2983         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2984         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2985         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2986         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2987         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2988         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2989         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2990         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2991
2992         { }
2993 };
2994
2995 /*
2996  * 3-stack pin configuration:
2997  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2998  */
2999 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3000         /*
3001          * preset connection lists of input pins
3002          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3003          */
3004         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3005         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3006         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3007
3008         /*
3009          * Set pin mode and muting
3010          */
3011         /* set front pin widgets 0x14 for output */
3012         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3013         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3014         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3015         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3016         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3017         /* Mic2 (as headphone out) for HP output */
3018         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3019         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3020         /* Line In pin widget for input */
3021         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3022         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3023         /* Line2 (as front mic) pin widget for input and vref at 80% */
3024         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3025         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3026         /* CD pin widget for input */
3027         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3028
3029         { }
3030 };
3031
3032 /*
3033  * 5-stack pin configuration:
3034  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3035  * line-in/side = 0x1a, f-mic = 0x1b
3036  */
3037 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3038         /*
3039          * preset connection lists of input pins
3040          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3041          */
3042         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3043         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3044
3045         /*
3046          * Set pin mode and muting
3047          */
3048         /* set pin widgets 0x14-0x17 for output */
3049         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3050         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3051         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3052         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3053         /* unmute pins for output (no gain on this amp) */
3054         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3055         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3056         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3057         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3058
3059         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3060         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3061         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3062         /* Mic2 (as headphone out) for HP output */
3063         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3064         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3065         /* Line In pin widget for input */
3066         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3067         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3068         /* Line2 (as front mic) pin widget for input and vref at 80% */
3069         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3070         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3071         /* CD pin widget for input */
3072         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3073
3074         { }
3075 };
3076
3077 /*
3078  * W810 pin configuration:
3079  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3080  */
3081 static struct hda_verb alc880_pin_w810_init_verbs[] = {
3082         /* hphone/speaker input selector: front DAC */
3083         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3084
3085         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3086         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3087         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3088         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3089         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3090         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3091
3092         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3093         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3094
3095         { }
3096 };
3097
3098 /*
3099  * Z71V pin configuration:
3100  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3101  */
3102 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3103         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3104         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3105         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3106         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3107
3108         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3109         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3110         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3111         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3112
3113         { }
3114 };
3115
3116 /*
3117  * 6-stack pin configuration:
3118  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3119  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3120  */
3121 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3122         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3123
3124         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3125         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3126         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3127         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3128         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3129         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3130         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3131         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3132
3133         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3134         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3135         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3136         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3137         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3138         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3139         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3140         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3141         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3142
3143         { }
3144 };
3145
3146 /*
3147  * Uniwill pin configuration:
3148  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3149  * line = 0x1a
3150  */
3151 static struct hda_verb alc880_uniwill_init_verbs[] = {
3152         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3153
3154         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3155         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3156         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3157         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3158         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3159         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3160         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3161         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3162         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3163         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3164         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3165         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3166         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3167         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3168
3169         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3170         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3171         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3172         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3173         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3174         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3175         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3176         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3177         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3178
3179         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3180         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3181
3182         { }
3183 };
3184
3185 /*
3186 * Uniwill P53
3187 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3188  */
3189 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3190         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3191
3192         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3193         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3194         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3195         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3196         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3197         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3198         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3199         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3200         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3201         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3202         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3203         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3204
3205         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3206         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3207         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3208         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3209         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3210         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3211
3212         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3213         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3214
3215         { }
3216 };
3217
3218 static struct hda_verb alc880_beep_init_verbs[] = {
3219         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3220         { }
3221 };
3222
3223 /* auto-toggle front mic */
3224 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
3225 {
3226         unsigned int present;
3227         unsigned char bits;
3228
3229         present = snd_hda_jack_detect(codec, 0x18);
3230         bits = present ? HDA_AMP_MUTE : 0;
3231         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3232 }
3233
3234 static void alc880_uniwill_setup(struct hda_codec *codec)
3235 {
3236         struct alc_spec *spec = codec->spec;
3237
3238         spec->autocfg.hp_pins[0] = 0x14;
3239         spec->autocfg.speaker_pins[0] = 0x15;
3240         spec->autocfg.speaker_pins[0] = 0x16;
3241 }
3242
3243 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3244 {
3245         alc_automute_amp(codec);
3246         alc880_uniwill_mic_automute(codec);
3247 }
3248
3249 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3250                                        unsigned int res)
3251 {
3252         /* Looks like the unsol event is incompatible with the standard
3253          * definition.  4bit tag is placed at 28 bit!
3254          */
3255         switch (res >> 28) {
3256         case ALC880_MIC_EVENT:
3257                 alc880_uniwill_mic_automute(codec);
3258                 break;
3259         default:
3260                 alc_automute_amp_unsol_event(codec, res);
3261                 break;
3262         }
3263 }
3264
3265 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3266 {
3267         struct alc_spec *spec = codec->spec;
3268
3269         spec->autocfg.hp_pins[0] = 0x14;
3270         spec->autocfg.speaker_pins[0] = 0x15;
3271 }
3272
3273 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3274 {
3275         unsigned int present;
3276
3277         present = snd_hda_codec_read(codec, 0x21, 0,
3278                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3279         present &= HDA_AMP_VOLMASK;
3280         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3281                                  HDA_AMP_VOLMASK, present);
3282         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3283                                  HDA_AMP_VOLMASK, present);
3284 }
3285
3286 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3287                                            unsigned int res)
3288 {
3289         /* Looks like the unsol event is incompatible with the standard
3290          * definition.  4bit tag is placed at 28 bit!
3291          */
3292         if ((res >> 28) == ALC880_DCVOL_EVENT)
3293                 alc880_uniwill_p53_dcvol_automute(codec);
3294         else
3295                 alc_automute_amp_unsol_event(codec, res);
3296 }
3297
3298 /*
3299  * F1734 pin configuration:
3300  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3301  */
3302 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3303         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3304         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3305         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3306         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3307         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3308
3309         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3310         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3311         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3312         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3313
3314         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3315         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3316         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3317         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3318         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3319         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3320         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3321         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3322         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3323
3324         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3325         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3326
3327         { }
3328 };
3329
3330 /*
3331  * ASUS pin configuration:
3332  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3333  */
3334 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3335         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3336         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3337         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3338         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3339
3340         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3341         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3342         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3343         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3344         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3345         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3346         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3347         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3348
3349         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3350         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3351         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3352         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3353         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3354         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3355         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3356         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3357         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3358
3359         { }
3360 };
3361
3362 /* Enable GPIO mask and set output */
3363 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3364 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3365 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3366
3367 /* Clevo m520g init */
3368 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3369         /* headphone output */
3370         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3371         /* line-out */
3372         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3373         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3374         /* Line-in */
3375         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3376         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3377         /* CD */
3378         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3379         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3380         /* Mic1 (rear panel) */
3381         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3382         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3383         /* Mic2 (front panel) */
3384         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3385         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3386         /* headphone */
3387         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3388         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3389         /* change to EAPD mode */
3390         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3391         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3392
3393         { }
3394 };
3395
3396 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3397         /* change to EAPD mode */
3398         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3399         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3400
3401         /* Headphone output */
3402         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3403         /* Front output*/
3404         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3405         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3406
3407         /* Line In pin widget for input */
3408         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3409         /* CD pin widget for input */
3410         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3411         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3412         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3413
3414         /* change to EAPD mode */
3415         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3416         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3417
3418         { }
3419 };
3420
3421 /*
3422  * LG m1 express dual
3423  *
3424  * Pin assignment:
3425  *   Rear Line-In/Out (blue): 0x14
3426  *   Build-in Mic-In: 0x15
3427  *   Speaker-out: 0x17
3428  *   HP-Out (green): 0x1b
3429  *   Mic-In/Out (red): 0x19
3430  *   SPDIF-Out: 0x1e
3431  */
3432
3433 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3434 static hda_nid_t alc880_lg_dac_nids[3] = {
3435         0x05, 0x02, 0x03
3436 };
3437
3438 /* seems analog CD is not working */
3439 static struct hda_input_mux alc880_lg_capture_source = {
3440         .num_items = 3,
3441         .items = {
3442                 { "Mic", 0x1 },
3443                 { "Line", 0x5 },
3444                 { "Internal Mic", 0x6 },
3445         },
3446 };
3447
3448 /* 2,4,6 channel modes */
3449 static struct hda_verb alc880_lg_ch2_init[] = {
3450         /* set line-in and mic-in to input */
3451         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3452         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3453         { }
3454 };
3455
3456 static struct hda_verb alc880_lg_ch4_init[] = {
3457         /* set line-in to out and mic-in to input */
3458         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3459         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3460         { }
3461 };
3462
3463 static struct hda_verb alc880_lg_ch6_init[] = {
3464         /* set line-in and mic-in to output */
3465         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3466         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3467         { }
3468 };
3469
3470 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3471         { 2, alc880_lg_ch2_init },
3472         { 4, alc880_lg_ch4_init },
3473         { 6, alc880_lg_ch6_init },
3474 };
3475
3476 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3477         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3478         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3479         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3480         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3481         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3482         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3483         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3484         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3485         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3486         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3487         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3488         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3489         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3490         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3491         {
3492                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3493                 .name = "Channel Mode",
3494                 .info = alc_ch_mode_info,
3495                 .get = alc_ch_mode_get,
3496                 .put = alc_ch_mode_put,
3497         },
3498         { } /* end */
3499 };
3500
3501 static struct hda_verb alc880_lg_init_verbs[] = {
3502         /* set capture source to mic-in */
3503         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3504         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3505         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3506         /* mute all amp mixer inputs */
3507         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3508         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3509         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3510         /* line-in to input */
3511         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3512         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3513         /* built-in mic */
3514         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3515         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3516         /* speaker-out */
3517         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3518         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3519         /* mic-in to input */
3520         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3521         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3522         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3523         /* HP-out */
3524         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3525         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3526         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3527         /* jack sense */
3528         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3529         { }
3530 };
3531
3532 /* toggle speaker-output according to the hp-jack state */
3533 static void alc880_lg_setup(struct hda_codec *codec)
3534 {
3535         struct alc_spec *spec = codec->spec;
3536
3537         spec->autocfg.hp_pins[0] = 0x1b;
3538         spec->autocfg.speaker_pins[0] = 0x17;
3539 }
3540
3541 /*
3542  * LG LW20
3543  *
3544  * Pin assignment:
3545  *   Speaker-out: 0x14
3546  *   Mic-In: 0x18
3547  *   Built-in Mic-In: 0x19
3548  *   Line-In: 0x1b
3549  *   HP-Out: 0x1a
3550  *   SPDIF-Out: 0x1e
3551  */
3552
3553 static struct hda_input_mux alc880_lg_lw_capture_source = {
3554         .num_items = 3,
3555         .items = {
3556                 { "Mic", 0x0 },
3557                 { "Internal Mic", 0x1 },
3558                 { "Line In", 0x2 },
3559         },
3560 };
3561
3562 #define alc880_lg_lw_modes alc880_threestack_modes
3563
3564 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3565         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3566         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3567         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3568         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3569         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3570         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3571         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3572         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3573         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3574         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3575         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3576         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3577         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3578         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3579         {
3580                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3581                 .name = "Channel Mode",
3582                 .info = alc_ch_mode_info,
3583                 .get = alc_ch_mode_get,
3584                 .put = alc_ch_mode_put,
3585         },
3586         { } /* end */
3587 };
3588
3589 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3590         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3591         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3592         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3593
3594         /* set capture source to mic-in */
3595         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3596         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3597         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3598         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3599         /* speaker-out */
3600         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3601         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3602         /* HP-out */
3603         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3604         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3605         /* mic-in to input */
3606         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3607         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3608         /* built-in mic */
3609         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3610         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3611         /* jack sense */
3612         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3613         { }
3614 };
3615
3616 /* toggle speaker-output according to the hp-jack state */
3617 static void alc880_lg_lw_setup(struct hda_codec *codec)
3618 {
3619         struct alc_spec *spec = codec->spec;
3620
3621         spec->autocfg.hp_pins[0] = 0x1b;
3622         spec->autocfg.speaker_pins[0] = 0x14;
3623 }
3624
3625 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3626         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3627         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3628         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3629         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3630         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3631         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3632         { } /* end */
3633 };
3634
3635 static struct hda_input_mux alc880_medion_rim_capture_source = {
3636         .num_items = 2,
3637         .items = {
3638                 { "Mic", 0x0 },
3639                 { "Internal Mic", 0x1 },
3640         },
3641 };
3642
3643 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3644         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3645
3646         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3647         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3648
3649         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3650         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3651         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3652         /* Mic2 (as headphone out) for HP output */
3653         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3654         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3655         /* Internal Speaker */
3656         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3657         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3658
3659         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3660         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3661
3662         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3663         { }
3664 };
3665
3666 /* toggle speaker-output according to the hp-jack state */
3667 static void alc880_medion_rim_automute(struct hda_codec *codec)
3668 {
3669         struct alc_spec *spec = codec->spec;
3670         alc_automute_amp(codec);
3671         /* toggle EAPD */
3672         if (spec->jack_present)
3673                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3674         else
3675                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3676 }
3677
3678 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3679                                           unsigned int res)
3680 {
3681         /* Looks like the unsol event is incompatible with the standard
3682          * definition.  4bit tag is placed at 28 bit!
3683          */
3684         if ((res >> 28) == ALC880_HP_EVENT)
3685                 alc880_medion_rim_automute(codec);
3686 }
3687
3688 static void alc880_medion_rim_setup(struct hda_codec *codec)
3689 {
3690         struct alc_spec *spec = codec->spec;
3691
3692         spec->autocfg.hp_pins[0] = 0x14;
3693         spec->autocfg.speaker_pins[0] = 0x1b;
3694 }
3695
3696 #ifdef CONFIG_SND_HDA_POWER_SAVE
3697 static struct hda_amp_list alc880_loopbacks[] = {
3698         { 0x0b, HDA_INPUT, 0 },
3699         { 0x0b, HDA_INPUT, 1 },
3700         { 0x0b, HDA_INPUT, 2 },
3701         { 0x0b, HDA_INPUT, 3 },
3702         { 0x0b, HDA_INPUT, 4 },
3703         { } /* end */
3704 };
3705
3706 static struct hda_amp_list alc880_lg_loopbacks[] = {
3707         { 0x0b, HDA_INPUT, 1 },
3708         { 0x0b, HDA_INPUT, 6 },
3709         { 0x0b, HDA_INPUT, 7 },
3710         { } /* end */
3711 };
3712 #endif
3713
3714 /*
3715  * Common callbacks
3716  */
3717
3718 static int alc_init(struct hda_codec *codec)
3719 {
3720         struct alc_spec *spec = codec->spec;
3721         unsigned int i;
3722
3723         alc_fix_pll(codec);
3724         alc_auto_init_amp(codec, spec->init_amp);
3725
3726         for (i = 0; i < spec->num_init_verbs; i++)
3727                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3728
3729         if (spec->init_hook)
3730                 spec->init_hook(codec);
3731
3732 #ifdef CONFIG_SND_HDA_POWER_SAVE
3733         if (codec->patch_ops.check_power_status)
3734                 codec->patch_ops.check_power_status(codec, 0x01);
3735 #endif
3736         return 0;
3737 }
3738
3739 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3740 {
3741         struct alc_spec *spec = codec->spec;
3742
3743         if (spec->unsol_event)
3744                 spec->unsol_event(codec, res);
3745 }
3746
3747 #ifdef CONFIG_SND_HDA_POWER_SAVE
3748 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3749 {
3750         struct alc_spec *spec = codec->spec;
3751         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3752 }
3753 #endif
3754
3755 /*
3756  * Analog playback callbacks
3757  */
3758 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3759                                     struct hda_codec *codec,
3760                                     struct snd_pcm_substream *substream)
3761 {
3762         struct alc_spec *spec = codec->spec;
3763         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3764                                              hinfo);
3765 }
3766
3767 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3768                                        struct hda_codec *codec,
3769                                        unsigned int stream_tag,
3770                                        unsigned int format,
3771                                        struct snd_pcm_substream *substream)
3772 {
3773         struct alc_spec *spec = codec->spec;
3774         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3775                                                 stream_tag, format, substream);
3776 }
3777
3778 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3779                                        struct hda_codec *codec,
3780                                        struct snd_pcm_substream *substream)
3781 {
3782         struct alc_spec *spec = codec->spec;
3783         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3784 }
3785
3786 /*
3787  * Digital out
3788  */
3789 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3790                                         struct hda_codec *codec,
3791                                         struct snd_pcm_substream *substream)
3792 {
3793         struct alc_spec *spec = codec->spec;
3794         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3795 }
3796
3797 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3798                                            struct hda_codec *codec,
3799                                            unsigned int stream_tag,
3800                                            unsigned int format,
3801                                            struct snd_pcm_substream *substream)
3802 {
3803         struct alc_spec *spec = codec->spec;
3804         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3805                                              stream_tag, format, substream);
3806 }
3807
3808 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3809                                            struct hda_codec *codec,
3810                                            struct snd_pcm_substream *substream)
3811 {
3812         struct alc_spec *spec = codec->spec;
3813         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3814 }
3815
3816 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3817                                          struct hda_codec *codec,
3818                                          struct snd_pcm_substream *substream)
3819 {
3820         struct alc_spec *spec = codec->spec;
3821         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3822 }
3823
3824 /*
3825  * Analog capture
3826  */
3827 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3828                                       struct hda_codec *codec,
3829                                       unsigned int stream_tag,
3830                                       unsigned int format,
3831                                       struct snd_pcm_substream *substream)
3832 {
3833         struct alc_spec *spec = codec->spec;
3834
3835         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3836                                    stream_tag, 0, format);
3837         return 0;
3838 }
3839
3840 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3841                                       struct hda_codec *codec,
3842                                       struct snd_pcm_substream *substream)
3843 {
3844         struct alc_spec *spec = codec->spec;
3845
3846         snd_hda_codec_cleanup_stream(codec,
3847                                      spec->adc_nids[substream->number + 1]);
3848         return 0;
3849 }
3850
3851 /* analog capture with dynamic dual-adc changes */
3852 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3853                                        struct hda_codec *codec,
3854                                        unsigned int stream_tag,
3855                                        unsigned int format,
3856                                        struct snd_pcm_substream *substream)
3857 {
3858         struct alc_spec *spec = codec->spec;
3859         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3860         spec->cur_adc_stream_tag = stream_tag;
3861         spec->cur_adc_format = format;
3862         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3863         return 0;
3864 }
3865
3866 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3867                                        struct hda_codec *codec,
3868                                        struct snd_pcm_substream *substream)
3869 {
3870         struct alc_spec *spec = codec->spec;
3871         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3872         spec->cur_adc = 0;
3873         return 0;
3874 }
3875
3876 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
3877         .substreams = 1,
3878         .channels_min = 2,
3879         .channels_max = 2,
3880         .nid = 0, /* fill later */
3881         .ops = {
3882                 .prepare = dualmic_capture_pcm_prepare,
3883                 .cleanup = dualmic_capture_pcm_cleanup
3884         },
3885 };
3886
3887 /*
3888  */
3889 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3890         .substreams = 1,
3891         .channels_min = 2,
3892         .channels_max = 8,
3893         /* NID is set in alc_build_pcms */
3894         .ops = {
3895                 .open = alc880_playback_pcm_open,
3896                 .prepare = alc880_playback_pcm_prepare,
3897                 .cleanup = alc880_playback_pcm_cleanup
3898         },
3899 };
3900
3901 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3902         .substreams = 1,
3903         .channels_min = 2,
3904         .channels_max = 2,
3905         /* NID is set in alc_build_pcms */
3906 };
3907
3908 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3909         .substreams = 1,
3910         .channels_min = 2,
3911         .channels_max = 2,
3912         /* NID is set in alc_build_pcms */
3913 };
3914
3915 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3916         .substreams = 2, /* can be overridden */
3917         .channels_min = 2,
3918         .channels_max = 2,
3919         /* NID is set in alc_build_pcms */
3920         .ops = {
3921                 .prepare = alc880_alt_capture_pcm_prepare,
3922                 .cleanup = alc880_alt_capture_pcm_cleanup
3923         },
3924 };
3925
3926 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3927         .substreams = 1,
3928         .channels_min = 2,
3929         .channels_max = 2,
3930         /* NID is set in alc_build_pcms */
3931         .ops = {
3932                 .open = alc880_dig_playback_pcm_open,
3933                 .close = alc880_dig_playback_pcm_close,
3934                 .prepare = alc880_dig_playback_pcm_prepare,
3935                 .cleanup = alc880_dig_playback_pcm_cleanup
3936         },
3937 };
3938
3939 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3940         .substreams = 1,
3941         .channels_min = 2,
3942         .channels_max = 2,
3943         /* NID is set in alc_build_pcms */
3944 };
3945
3946 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3947 static struct hda_pcm_stream alc_pcm_null_stream = {
3948         .substreams = 0,
3949         .channels_min = 0,
3950         .channels_max = 0,
3951 };
3952
3953 static int alc_build_pcms(struct hda_codec *codec)
3954 {
3955         struct alc_spec *spec = codec->spec;
3956         struct hda_pcm *info = spec->pcm_rec;
3957         int i;
3958
3959         codec->num_pcms = 1;
3960         codec->pcm_info = info;
3961
3962         if (spec->no_analog)
3963                 goto skip_analog;
3964
3965         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3966                  "%s Analog", codec->chip_name);
3967         info->name = spec->stream_name_analog;
3968
3969         if (spec->stream_analog_playback) {
3970                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3971                         return -EINVAL;
3972                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3973                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3974         }
3975         if (spec->stream_analog_capture) {
3976                 if (snd_BUG_ON(!spec->adc_nids))
3977                         return -EINVAL;
3978                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3979                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3980         }
3981
3982         if (spec->channel_mode) {
3983                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3984                 for (i = 0; i < spec->num_channel_mode; i++) {
3985                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3986                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3987                         }
3988                 }
3989         }
3990
3991  skip_analog:
3992         /* SPDIF for stream index #1 */
3993         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3994                 snprintf(spec->stream_name_digital,
3995                          sizeof(spec->stream_name_digital),
3996                          "%s Digital", codec->chip_name);
3997                 codec->num_pcms = 2;
3998                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3999                 info = spec->pcm_rec + 1;
4000                 info->name = spec->stream_name_digital;
4001                 if (spec->dig_out_type)
4002                         info->pcm_type = spec->dig_out_type;
4003                 else
4004                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4005                 if (spec->multiout.dig_out_nid &&
4006                     spec->stream_digital_playback) {
4007                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4008                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4009                 }
4010                 if (spec->dig_in_nid &&
4011                     spec->stream_digital_capture) {
4012                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4013                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4014                 }
4015                 /* FIXME: do we need this for all Realtek codec models? */
4016                 codec->spdif_status_reset = 1;
4017         }
4018
4019         if (spec->no_analog)
4020                 return 0;
4021
4022         /* If the use of more than one ADC is requested for the current
4023          * model, configure a second analog capture-only PCM.
4024          */
4025         /* Additional Analaog capture for index #2 */
4026         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4027             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4028                 codec->num_pcms = 3;
4029                 info = spec->pcm_rec + 2;
4030                 info->name = spec->stream_name_analog;
4031                 if (spec->alt_dac_nid) {
4032                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4033                                 *spec->stream_analog_alt_playback;
4034                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4035                                 spec->alt_dac_nid;
4036                 } else {
4037                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4038                                 alc_pcm_null_stream;
4039                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4040                 }
4041                 if (spec->num_adc_nids > 1) {
4042                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4043                                 *spec->stream_analog_alt_capture;
4044                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4045                                 spec->adc_nids[1];
4046                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4047                                 spec->num_adc_nids - 1;
4048                 } else {
4049                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4050                                 alc_pcm_null_stream;
4051                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4052                 }
4053         }
4054
4055         return 0;
4056 }
4057
4058 static inline void alc_shutup(struct hda_codec *codec)
4059 {
4060         snd_hda_shutup_pins(codec);
4061 }
4062
4063 static void alc_free_kctls(struct hda_codec *codec)
4064 {
4065         struct alc_spec *spec = codec->spec;
4066
4067         if (spec->kctls.list) {
4068                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4069                 int i;
4070                 for (i = 0; i < spec->kctls.used; i++)
4071                         kfree(kctl[i].name);
4072         }
4073         snd_array_free(&spec->kctls);
4074 }
4075
4076 static void alc_free(struct hda_codec *codec)
4077 {
4078         struct alc_spec *spec = codec->spec;
4079
4080         if (!spec)
4081                 return;
4082
4083         alc_shutup(codec);
4084         alc_free_kctls(codec);
4085         kfree(spec);
4086         snd_hda_detach_beep_device(codec);
4087 }
4088
4089 #ifdef CONFIG_SND_HDA_POWER_SAVE
4090 static void alc_power_eapd(struct hda_codec *codec)
4091 {
4092         /* We currently only handle front, HP */
4093         switch (codec->vendor_id) {
4094         case 0x10ec0260:
4095                 set_eapd(codec, 0x0f, 0);
4096                 set_eapd(codec, 0x10, 0);
4097                 break;
4098         case 0x10ec0262:
4099         case 0x10ec0267:
4100         case 0x10ec0268:
4101         case 0x10ec0269:
4102         case 0x10ec0270:
4103         case 0x10ec0272:
4104         case 0x10ec0660:
4105         case 0x10ec0662:
4106         case 0x10ec0663:
4107         case 0x10ec0862:
4108         case 0x10ec0889:
4109                 set_eapd(codec, 0x14, 0);
4110                 set_eapd(codec, 0x15, 0);
4111                 break;
4112         }
4113 }
4114
4115 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4116 {
4117         struct alc_spec *spec = codec->spec;
4118         alc_shutup(codec);
4119         if (spec && spec->power_hook)
4120                 spec->power_hook(codec);
4121         return 0;
4122 }
4123 #endif
4124
4125 #ifdef SND_HDA_NEEDS_RESUME
4126 static int alc_resume(struct hda_codec *codec)
4127 {
4128         codec->patch_ops.init(codec);
4129         snd_hda_codec_resume_amp(codec);
4130         snd_hda_codec_resume_cache(codec);
4131 #ifdef CONFIG_SND_HDA_POWER_SAVE
4132         if (codec->patch_ops.check_power_status)
4133                 codec->patch_ops.check_power_status(codec, 0x01);
4134 #endif
4135         return 0;
4136 }
4137 #endif
4138
4139 /*
4140  */
4141 static struct hda_codec_ops alc_patch_ops = {
4142         .build_controls = alc_build_controls,
4143         .build_pcms = alc_build_pcms,
4144         .init = alc_init,
4145         .free = alc_free,
4146         .unsol_event = alc_unsol_event,
4147 #ifdef SND_HDA_NEEDS_RESUME
4148         .resume = alc_resume,
4149 #endif
4150 #ifdef CONFIG_SND_HDA_POWER_SAVE
4151         .suspend = alc_suspend,
4152         .check_power_status = alc_check_power_status,
4153 #endif
4154         .reboot_notify = alc_shutup,
4155 };
4156
4157 /* replace the codec chip_name with the given string */
4158 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4159 {
4160         kfree(codec->chip_name);
4161         codec->chip_name = kstrdup(name, GFP_KERNEL);
4162         if (!codec->chip_name) {
4163                 alc_free(codec);
4164                 return -ENOMEM;
4165         }
4166         return 0;
4167 }
4168
4169 /*
4170  * Test configuration for debugging
4171  *
4172  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4173  * enum controls.
4174  */
4175 #ifdef CONFIG_SND_DEBUG
4176 static hda_nid_t alc880_test_dac_nids[4] = {
4177         0x02, 0x03, 0x04, 0x05
4178 };
4179
4180 static struct hda_input_mux alc880_test_capture_source = {
4181         .num_items = 7,
4182         .items = {
4183                 { "In-1", 0x0 },
4184                 { "In-2", 0x1 },
4185                 { "In-3", 0x2 },
4186                 { "In-4", 0x3 },
4187                 { "CD", 0x4 },
4188                 { "Front", 0x5 },
4189                 { "Surround", 0x6 },
4190         },
4191 };
4192
4193 static struct hda_channel_mode alc880_test_modes[4] = {
4194         { 2, NULL },
4195         { 4, NULL },
4196         { 6, NULL },
4197         { 8, NULL },
4198 };
4199
4200 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4201                                  struct snd_ctl_elem_info *uinfo)
4202 {
4203         static char *texts[] = {
4204                 "N/A", "Line Out", "HP Out",
4205                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4206         };
4207         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4208         uinfo->count = 1;
4209         uinfo->value.enumerated.items = 8;
4210         if (uinfo->value.enumerated.item >= 8)
4211                 uinfo->value.enumerated.item = 7;
4212         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4213         return 0;
4214 }
4215
4216 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4217                                 struct snd_ctl_elem_value *ucontrol)
4218 {
4219         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4220         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4221         unsigned int pin_ctl, item = 0;
4222
4223         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4224                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4225         if (pin_ctl & AC_PINCTL_OUT_EN) {
4226                 if (pin_ctl & AC_PINCTL_HP_EN)
4227                         item = 2;
4228                 else
4229                         item = 1;
4230         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4231                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4232                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4233                 case AC_PINCTL_VREF_50:  item = 4; break;
4234                 case AC_PINCTL_VREF_GRD: item = 5; break;
4235                 case AC_PINCTL_VREF_80:  item = 6; break;
4236                 case AC_PINCTL_VREF_100: item = 7; break;
4237                 }
4238         }
4239         ucontrol->value.enumerated.item[0] = item;
4240         return 0;
4241 }
4242
4243 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4244                                 struct snd_ctl_elem_value *ucontrol)
4245 {
4246         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4247         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4248         static unsigned int ctls[] = {
4249                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4250                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4251                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4252                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4253                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4254                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4255         };
4256         unsigned int old_ctl, new_ctl;
4257
4258         old_ctl = snd_hda_codec_read(codec, nid, 0,
4259                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4260         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4261         if (old_ctl != new_ctl) {
4262                 int val;
4263                 snd_hda_codec_write_cache(codec, nid, 0,
4264                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4265                                           new_ctl);
4266                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4267                         HDA_AMP_MUTE : 0;
4268                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4269                                          HDA_AMP_MUTE, val);
4270                 return 1;
4271         }
4272         return 0;
4273 }
4274
4275 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4276                                  struct snd_ctl_elem_info *uinfo)
4277 {
4278         static char *texts[] = {
4279                 "Front", "Surround", "CLFE", "Side"
4280         };
4281         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4282         uinfo->count = 1;
4283         uinfo->value.enumerated.items = 4;
4284         if (uinfo->value.enumerated.item >= 4)
4285                 uinfo->value.enumerated.item = 3;
4286         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4287         return 0;
4288 }
4289
4290 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4291                                 struct snd_ctl_elem_value *ucontrol)
4292 {
4293         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4294         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4295         unsigned int sel;
4296
4297         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4298         ucontrol->value.enumerated.item[0] = sel & 3;
4299         return 0;
4300 }
4301
4302 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4303                                 struct snd_ctl_elem_value *ucontrol)
4304 {
4305         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4306         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4307         unsigned int sel;
4308
4309         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4310         if (ucontrol->value.enumerated.item[0] != sel) {
4311                 sel = ucontrol->value.enumerated.item[0] & 3;
4312                 snd_hda_codec_write_cache(codec, nid, 0,
4313                                           AC_VERB_SET_CONNECT_SEL, sel);
4314                 return 1;
4315         }
4316         return 0;
4317 }
4318
4319 #define PIN_CTL_TEST(xname,nid) {                       \
4320                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4321                         .name = xname,                 \
4322                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4323                         .info = alc_test_pin_ctl_info, \
4324                         .get = alc_test_pin_ctl_get,   \
4325                         .put = alc_test_pin_ctl_put,   \
4326                         .private_value = nid           \
4327                         }
4328
4329 #define PIN_SRC_TEST(xname,nid) {                       \
4330                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4331                         .name = xname,                 \
4332                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4333                         .info = alc_test_pin_src_info, \
4334                         .get = alc_test_pin_src_get,   \
4335                         .put = alc_test_pin_src_put,   \
4336                         .private_value = nid           \
4337                         }
4338
4339 static struct snd_kcontrol_new alc880_test_mixer[] = {
4340         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4341         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4342         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4343         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4344         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4345         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4346         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4347         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4348         PIN_CTL_TEST("Front Pin Mode", 0x14),
4349         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4350         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4351         PIN_CTL_TEST("Side Pin Mode", 0x17),
4352         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4353         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4354         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4355         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4356         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4357         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4358         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4359         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4360         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4361         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4362         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4363         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4364         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4365         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4366         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4367         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4368         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4369         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4370         {
4371                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4372                 .name = "Channel Mode",
4373                 .info = alc_ch_mode_info,
4374                 .get = alc_ch_mode_get,
4375                 .put = alc_ch_mode_put,
4376         },
4377         { } /* end */
4378 };
4379
4380 static struct hda_verb alc880_test_init_verbs[] = {
4381         /* Unmute inputs of 0x0c - 0x0f */
4382         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4383         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4384         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4385         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4386         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4387         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4388         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4389         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4390         /* Vol output for 0x0c-0x0f */
4391         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4392         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4393         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4394         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4395         /* Set output pins 0x14-0x17 */
4396         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4397         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4398         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4399         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4400         /* Unmute output pins 0x14-0x17 */
4401         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4402         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4403         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4404         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4405         /* Set input pins 0x18-0x1c */
4406         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4407         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4408         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4409         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4410         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4411         /* Mute input pins 0x18-0x1b */
4412         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4413         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4414         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4415         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4416         /* ADC set up */
4417         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4418         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4419         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4420         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4421         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4422         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4423         /* Analog input/passthru */
4424         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4425         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4426         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4427         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4428         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4429         { }
4430 };
4431 #endif
4432
4433 /*
4434  */
4435
4436 static const char *alc880_models[ALC880_MODEL_LAST] = {
4437         [ALC880_3ST]            = "3stack",
4438         [ALC880_TCL_S700]       = "tcl",
4439         [ALC880_3ST_DIG]        = "3stack-digout",
4440         [ALC880_CLEVO]          = "clevo",
4441         [ALC880_5ST]            = "5stack",
4442         [ALC880_5ST_DIG]        = "5stack-digout",
4443         [ALC880_W810]           = "w810",
4444         [ALC880_Z71V]           = "z71v",
4445         [ALC880_6ST]            = "6stack",
4446         [ALC880_6ST_DIG]        = "6stack-digout",
4447         [ALC880_ASUS]           = "asus",
4448         [ALC880_ASUS_W1V]       = "asus-w1v",
4449         [ALC880_ASUS_DIG]       = "asus-dig",
4450         [ALC880_ASUS_DIG2]      = "asus-dig2",
4451         [ALC880_UNIWILL_DIG]    = "uniwill",
4452         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4453         [ALC880_FUJITSU]        = "fujitsu",
4454         [ALC880_F1734]          = "F1734",
4455         [ALC880_LG]             = "lg",
4456         [ALC880_LG_LW]          = "lg-lw",
4457         [ALC880_MEDION_RIM]     = "medion",
4458 #ifdef CONFIG_SND_DEBUG
4459         [ALC880_TEST]           = "test",
4460 #endif
4461         [ALC880_AUTO]           = "auto",
4462 };
4463
4464 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4465         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4466         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4467         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4468         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4469         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4470         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4471         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4472         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4473         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4474         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4475         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4476         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4477         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4478         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4479         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4480         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4481         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4482         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4483         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4484         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4485         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4486         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4487         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4488         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4489         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4490         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4491         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4492         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4493         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4494         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4495         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4496         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4497         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4498         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4499         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4500         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4501         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4502         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4503         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4504         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4505         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4506         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4507         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4508         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4509         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4510         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4511         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4512         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4513         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4514         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4515         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4516         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4517         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4518         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4519         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4520         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4521         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4522         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4523         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4524         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4525         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4526         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4527         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4528         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4529         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4530         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4531         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4532         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4533         /* default Intel */
4534         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4535         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4536         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4537         {}
4538 };
4539
4540 /*
4541  * ALC880 codec presets
4542  */
4543 static struct alc_config_preset alc880_presets[] = {
4544         [ALC880_3ST] = {
4545                 .mixers = { alc880_three_stack_mixer },
4546                 .init_verbs = { alc880_volume_init_verbs,
4547                                 alc880_pin_3stack_init_verbs },
4548                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4549                 .dac_nids = alc880_dac_nids,
4550                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4551                 .channel_mode = alc880_threestack_modes,
4552                 .need_dac_fix = 1,
4553                 .input_mux = &alc880_capture_source,
4554         },
4555         [ALC880_3ST_DIG] = {
4556                 .mixers = { alc880_three_stack_mixer },
4557                 .init_verbs = { alc880_volume_init_verbs,
4558                                 alc880_pin_3stack_init_verbs },
4559                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4560                 .dac_nids = alc880_dac_nids,
4561                 .dig_out_nid = ALC880_DIGOUT_NID,
4562                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4563                 .channel_mode = alc880_threestack_modes,
4564                 .need_dac_fix = 1,
4565                 .input_mux = &alc880_capture_source,
4566         },
4567         [ALC880_TCL_S700] = {
4568                 .mixers = { alc880_tcl_s700_mixer },
4569                 .init_verbs = { alc880_volume_init_verbs,
4570                                 alc880_pin_tcl_S700_init_verbs,
4571                                 alc880_gpio2_init_verbs },
4572                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4573                 .dac_nids = alc880_dac_nids,
4574                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4575                 .num_adc_nids = 1, /* single ADC */
4576                 .hp_nid = 0x03,
4577                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4578                 .channel_mode = alc880_2_jack_modes,
4579                 .input_mux = &alc880_capture_source,
4580         },
4581         [ALC880_5ST] = {
4582                 .mixers = { alc880_three_stack_mixer,
4583                             alc880_five_stack_mixer},
4584                 .init_verbs = { alc880_volume_init_verbs,
4585                                 alc880_pin_5stack_init_verbs },
4586                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4587                 .dac_nids = alc880_dac_nids,
4588                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4589                 .channel_mode = alc880_fivestack_modes,
4590                 .input_mux = &alc880_capture_source,
4591         },
4592         [ALC880_5ST_DIG] = {
4593                 .mixers = { alc880_three_stack_mixer,
4594                             alc880_five_stack_mixer },
4595                 .init_verbs = { alc880_volume_init_verbs,
4596                                 alc880_pin_5stack_init_verbs },
4597                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4598                 .dac_nids = alc880_dac_nids,
4599                 .dig_out_nid = ALC880_DIGOUT_NID,
4600                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4601                 .channel_mode = alc880_fivestack_modes,
4602                 .input_mux = &alc880_capture_source,
4603         },
4604         [ALC880_6ST] = {
4605                 .mixers = { alc880_six_stack_mixer },
4606                 .init_verbs = { alc880_volume_init_verbs,
4607                                 alc880_pin_6stack_init_verbs },
4608                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4609                 .dac_nids = alc880_6st_dac_nids,
4610                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4611                 .channel_mode = alc880_sixstack_modes,
4612                 .input_mux = &alc880_6stack_capture_source,
4613         },
4614         [ALC880_6ST_DIG] = {
4615                 .mixers = { alc880_six_stack_mixer },
4616                 .init_verbs = { alc880_volume_init_verbs,
4617                                 alc880_pin_6stack_init_verbs },
4618                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4619                 .dac_nids = alc880_6st_dac_nids,
4620                 .dig_out_nid = ALC880_DIGOUT_NID,
4621                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4622                 .channel_mode = alc880_sixstack_modes,
4623                 .input_mux = &alc880_6stack_capture_source,
4624         },
4625         [ALC880_W810] = {
4626                 .mixers = { alc880_w810_base_mixer },
4627                 .init_verbs = { alc880_volume_init_verbs,
4628                                 alc880_pin_w810_init_verbs,
4629                                 alc880_gpio2_init_verbs },
4630                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4631                 .dac_nids = alc880_w810_dac_nids,
4632                 .dig_out_nid = ALC880_DIGOUT_NID,
4633                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4634                 .channel_mode = alc880_w810_modes,
4635                 .input_mux = &alc880_capture_source,
4636         },
4637         [ALC880_Z71V] = {
4638                 .mixers = { alc880_z71v_mixer },
4639                 .init_verbs = { alc880_volume_init_verbs,
4640                                 alc880_pin_z71v_init_verbs },
4641                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4642                 .dac_nids = alc880_z71v_dac_nids,
4643                 .dig_out_nid = ALC880_DIGOUT_NID,
4644                 .hp_nid = 0x03,
4645                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4646                 .channel_mode = alc880_2_jack_modes,
4647                 .input_mux = &alc880_capture_source,
4648         },
4649         [ALC880_F1734] = {
4650                 .mixers = { alc880_f1734_mixer },
4651                 .init_verbs = { alc880_volume_init_verbs,
4652                                 alc880_pin_f1734_init_verbs },
4653                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4654                 .dac_nids = alc880_f1734_dac_nids,
4655                 .hp_nid = 0x02,
4656                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4657                 .channel_mode = alc880_2_jack_modes,
4658                 .input_mux = &alc880_f1734_capture_source,
4659                 .unsol_event = alc880_uniwill_p53_unsol_event,
4660                 .setup = alc880_uniwill_p53_setup,
4661                 .init_hook = alc_automute_amp,
4662         },
4663         [ALC880_ASUS] = {
4664                 .mixers = { alc880_asus_mixer },
4665                 .init_verbs = { alc880_volume_init_verbs,
4666                                 alc880_pin_asus_init_verbs,
4667                                 alc880_gpio1_init_verbs },
4668                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4669                 .dac_nids = alc880_asus_dac_nids,
4670                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4671                 .channel_mode = alc880_asus_modes,
4672                 .need_dac_fix = 1,
4673                 .input_mux = &alc880_capture_source,
4674         },
4675         [ALC880_ASUS_DIG] = {
4676                 .mixers = { alc880_asus_mixer },
4677                 .init_verbs = { alc880_volume_init_verbs,
4678                                 alc880_pin_asus_init_verbs,
4679                                 alc880_gpio1_init_verbs },
4680                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4681                 .dac_nids = alc880_asus_dac_nids,
4682                 .dig_out_nid = ALC880_DIGOUT_NID,
4683                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4684                 .channel_mode = alc880_asus_modes,
4685                 .need_dac_fix = 1,
4686                 .input_mux = &alc880_capture_source,
4687         },
4688         [ALC880_ASUS_DIG2] = {
4689                 .mixers = { alc880_asus_mixer },
4690                 .init_verbs = { alc880_volume_init_verbs,
4691                                 alc880_pin_asus_init_verbs,
4692                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4693                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4694                 .dac_nids = alc880_asus_dac_nids,
4695                 .dig_out_nid = ALC880_DIGOUT_NID,
4696                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4697                 .channel_mode = alc880_asus_modes,
4698                 .need_dac_fix = 1,
4699                 .input_mux = &alc880_capture_source,
4700         },
4701         [ALC880_ASUS_W1V] = {
4702                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4703                 .init_verbs = { alc880_volume_init_verbs,
4704                                 alc880_pin_asus_init_verbs,
4705                                 alc880_gpio1_init_verbs },
4706                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4707                 .dac_nids = alc880_asus_dac_nids,
4708                 .dig_out_nid = ALC880_DIGOUT_NID,
4709                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4710                 .channel_mode = alc880_asus_modes,
4711                 .need_dac_fix = 1,
4712                 .input_mux = &alc880_capture_source,
4713         },
4714         [ALC880_UNIWILL_DIG] = {
4715                 .mixers = { alc880_asus_mixer },
4716                 .init_verbs = { alc880_volume_init_verbs,
4717                                 alc880_pin_asus_init_verbs },
4718                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4719                 .dac_nids = alc880_asus_dac_nids,
4720                 .dig_out_nid = ALC880_DIGOUT_NID,
4721                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4722                 .channel_mode = alc880_asus_modes,
4723                 .need_dac_fix = 1,
4724                 .input_mux = &alc880_capture_source,
4725         },
4726         [ALC880_UNIWILL] = {
4727                 .mixers = { alc880_uniwill_mixer },
4728                 .init_verbs = { alc880_volume_init_verbs,
4729                                 alc880_uniwill_init_verbs },
4730                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4731                 .dac_nids = alc880_asus_dac_nids,
4732                 .dig_out_nid = ALC880_DIGOUT_NID,
4733                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4734                 .channel_mode = alc880_threestack_modes,
4735                 .need_dac_fix = 1,
4736                 .input_mux = &alc880_capture_source,
4737                 .unsol_event = alc880_uniwill_unsol_event,
4738                 .setup = alc880_uniwill_setup,
4739                 .init_hook = alc880_uniwill_init_hook,
4740         },
4741         [ALC880_UNIWILL_P53] = {
4742                 .mixers = { alc880_uniwill_p53_mixer },
4743                 .init_verbs = { alc880_volume_init_verbs,
4744                                 alc880_uniwill_p53_init_verbs },
4745                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4746                 .dac_nids = alc880_asus_dac_nids,
4747                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4748                 .channel_mode = alc880_threestack_modes,
4749                 .input_mux = &alc880_capture_source,
4750                 .unsol_event = alc880_uniwill_p53_unsol_event,
4751                 .setup = alc880_uniwill_p53_setup,
4752                 .init_hook = alc_automute_amp,
4753         },
4754         [ALC880_FUJITSU] = {
4755                 .mixers = { alc880_fujitsu_mixer },
4756                 .init_verbs = { alc880_volume_init_verbs,
4757                                 alc880_uniwill_p53_init_verbs,
4758                                 alc880_beep_init_verbs },
4759                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4760                 .dac_nids = alc880_dac_nids,
4761                 .dig_out_nid = ALC880_DIGOUT_NID,
4762                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4763                 .channel_mode = alc880_2_jack_modes,
4764                 .input_mux = &alc880_capture_source,
4765                 .unsol_event = alc880_uniwill_p53_unsol_event,
4766                 .setup = alc880_uniwill_p53_setup,
4767                 .init_hook = alc_automute_amp,
4768         },
4769         [ALC880_CLEVO] = {
4770                 .mixers = { alc880_three_stack_mixer },
4771                 .init_verbs = { alc880_volume_init_verbs,
4772                                 alc880_pin_clevo_init_verbs },
4773                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4774                 .dac_nids = alc880_dac_nids,
4775                 .hp_nid = 0x03,
4776                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4777                 .channel_mode = alc880_threestack_modes,
4778                 .need_dac_fix = 1,
4779                 .input_mux = &alc880_capture_source,
4780         },
4781         [ALC880_LG] = {
4782                 .mixers = { alc880_lg_mixer },
4783                 .init_verbs = { alc880_volume_init_verbs,
4784                                 alc880_lg_init_verbs },
4785                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4786                 .dac_nids = alc880_lg_dac_nids,
4787                 .dig_out_nid = ALC880_DIGOUT_NID,
4788                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4789                 .channel_mode = alc880_lg_ch_modes,
4790                 .need_dac_fix = 1,
4791                 .input_mux = &alc880_lg_capture_source,
4792                 .unsol_event = alc_automute_amp_unsol_event,
4793                 .setup = alc880_lg_setup,
4794                 .init_hook = alc_automute_amp,
4795 #ifdef CONFIG_SND_HDA_POWER_SAVE
4796                 .loopbacks = alc880_lg_loopbacks,
4797 #endif
4798         },
4799         [ALC880_LG_LW] = {
4800                 .mixers = { alc880_lg_lw_mixer },
4801                 .init_verbs = { alc880_volume_init_verbs,
4802                                 alc880_lg_lw_init_verbs },
4803                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4804                 .dac_nids = alc880_dac_nids,
4805                 .dig_out_nid = ALC880_DIGOUT_NID,
4806                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4807                 .channel_mode = alc880_lg_lw_modes,
4808                 .input_mux = &alc880_lg_lw_capture_source,
4809                 .unsol_event = alc_automute_amp_unsol_event,
4810                 .setup = alc880_lg_lw_setup,
4811                 .init_hook = alc_automute_amp,
4812         },
4813         [ALC880_MEDION_RIM] = {
4814                 .mixers = { alc880_medion_rim_mixer },
4815                 .init_verbs = { alc880_volume_init_verbs,
4816                                 alc880_medion_rim_init_verbs,
4817                                 alc_gpio2_init_verbs },
4818                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4819                 .dac_nids = alc880_dac_nids,
4820                 .dig_out_nid = ALC880_DIGOUT_NID,
4821                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4822                 .channel_mode = alc880_2_jack_modes,
4823                 .input_mux = &alc880_medion_rim_capture_source,
4824                 .unsol_event = alc880_medion_rim_unsol_event,
4825                 .setup = alc880_medion_rim_setup,
4826                 .init_hook = alc880_medion_rim_automute,
4827         },
4828 #ifdef CONFIG_SND_DEBUG
4829         [ALC880_TEST] = {
4830                 .mixers = { alc880_test_mixer },
4831                 .init_verbs = { alc880_test_init_verbs },
4832                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4833                 .dac_nids = alc880_test_dac_nids,
4834                 .dig_out_nid = ALC880_DIGOUT_NID,
4835                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4836                 .channel_mode = alc880_test_modes,
4837                 .input_mux = &alc880_test_capture_source,
4838         },
4839 #endif
4840 };
4841
4842 /*
4843  * Automatic parse of I/O pins from the BIOS configuration
4844  */
4845
4846 enum {
4847         ALC_CTL_WIDGET_VOL,
4848         ALC_CTL_WIDGET_MUTE,
4849         ALC_CTL_BIND_MUTE,
4850 };
4851 static struct snd_kcontrol_new alc880_control_templates[] = {
4852         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4853         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4854         HDA_BIND_MUTE(NULL, 0, 0, 0),
4855 };
4856
4857 /* add dynamic controls */
4858 static int add_control(struct alc_spec *spec, int type, const char *name,
4859                        int cidx, unsigned long val)
4860 {
4861         struct snd_kcontrol_new *knew;
4862
4863         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4864         knew = snd_array_new(&spec->kctls);
4865         if (!knew)
4866                 return -ENOMEM;
4867         *knew = alc880_control_templates[type];
4868         knew->name = kstrdup(name, GFP_KERNEL);
4869         if (!knew->name)
4870                 return -ENOMEM;
4871         knew->index = cidx;
4872         if (get_amp_nid_(val))
4873                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4874         knew->private_value = val;
4875         return 0;
4876 }
4877
4878 static int add_control_with_pfx(struct alc_spec *spec, int type,
4879                                 const char *pfx, const char *dir,
4880                                 const char *sfx, int cidx, unsigned long val)
4881 {
4882         char name[32];
4883         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4884         return add_control(spec, type, name, cidx, val);
4885 }
4886
4887 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
4888         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
4889 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
4890         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
4891 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
4892         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
4893 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
4894         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
4895
4896 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4897 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4898 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4899 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4900 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4901 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4902 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4903 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4904 #define ALC880_PIN_CD_NID               0x1c
4905
4906 /* fill in the dac_nids table from the parsed pin configuration */
4907 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4908                                      const struct auto_pin_cfg *cfg)
4909 {
4910         hda_nid_t nid;
4911         int assigned[4];
4912         int i, j;
4913
4914         memset(assigned, 0, sizeof(assigned));
4915         spec->multiout.dac_nids = spec->private_dac_nids;
4916
4917         /* check the pins hardwired to audio widget */
4918         for (i = 0; i < cfg->line_outs; i++) {
4919                 nid = cfg->line_out_pins[i];
4920                 if (alc880_is_fixed_pin(nid)) {
4921                         int idx = alc880_fixed_pin_idx(nid);
4922                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4923                         assigned[idx] = 1;
4924                 }
4925         }
4926         /* left pins can be connect to any audio widget */
4927         for (i = 0; i < cfg->line_outs; i++) {
4928                 nid = cfg->line_out_pins[i];
4929                 if (alc880_is_fixed_pin(nid))
4930                         continue;
4931                 /* search for an empty channel */
4932                 for (j = 0; j < cfg->line_outs; j++) {
4933                         if (!assigned[j]) {
4934                                 spec->multiout.dac_nids[i] =
4935                                         alc880_idx_to_dac(j);
4936                                 assigned[j] = 1;
4937                                 break;
4938                         }
4939                 }
4940         }
4941         spec->multiout.num_dacs = cfg->line_outs;
4942         return 0;
4943 }
4944
4945 /* add playback controls from the parsed DAC table */
4946 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4947                                              const struct auto_pin_cfg *cfg)
4948 {
4949         static const char *chname[4] = {
4950                 "Front", "Surround", NULL /*CLFE*/, "Side"
4951         };
4952         hda_nid_t nid;
4953         int i, err;
4954
4955         for (i = 0; i < cfg->line_outs; i++) {
4956                 if (!spec->multiout.dac_nids[i])
4957                         continue;
4958                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4959                 if (i == 2) {
4960                         /* Center/LFE */
4961                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4962                                               "Center",
4963                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4964                                                               HDA_OUTPUT));
4965                         if (err < 0)
4966                                 return err;
4967                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4968                                               "LFE",
4969                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4970                                                               HDA_OUTPUT));
4971                         if (err < 0)
4972                                 return err;
4973                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4974                                              "Center",
4975                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4976                                                               HDA_INPUT));
4977                         if (err < 0)
4978                                 return err;
4979                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4980                                              "LFE",
4981                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4982                                                               HDA_INPUT));
4983                         if (err < 0)
4984                                 return err;
4985                 } else {
4986                         const char *pfx;
4987                         if (cfg->line_outs == 1 &&
4988                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4989                                 pfx = "Speaker";
4990                         else
4991                                 pfx = chname[i];
4992                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4993                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4994                                                               HDA_OUTPUT));
4995                         if (err < 0)
4996                                 return err;
4997                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4998                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4999                                                               HDA_INPUT));
5000                         if (err < 0)
5001                                 return err;
5002                 }
5003         }
5004         return 0;
5005 }
5006
5007 /* add playback controls for speaker and HP outputs */
5008 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5009                                         const char *pfx)
5010 {
5011         hda_nid_t nid;
5012         int err;
5013
5014         if (!pin)
5015                 return 0;
5016
5017         if (alc880_is_fixed_pin(pin)) {
5018                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5019                 /* specify the DAC as the extra output */
5020                 if (!spec->multiout.hp_nid)
5021                         spec->multiout.hp_nid = nid;
5022                 else
5023                         spec->multiout.extra_out_nid[0] = nid;
5024                 /* control HP volume/switch on the output mixer amp */
5025                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5026                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5027                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5028                 if (err < 0)
5029                         return err;
5030                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5031                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5032                 if (err < 0)
5033                         return err;
5034         } else if (alc880_is_multi_pin(pin)) {
5035                 /* set manual connection */
5036                 /* we have only a switch on HP-out PIN */
5037                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5038                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5039                 if (err < 0)
5040                         return err;
5041         }
5042         return 0;
5043 }
5044
5045 /* create input playback/capture controls for the given pin */
5046 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5047                             const char *ctlname, int ctlidx,
5048                             int idx, hda_nid_t mix_nid)
5049 {
5050         int err;
5051
5052         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5053                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5054         if (err < 0)
5055                 return err;
5056         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5057                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5058         if (err < 0)
5059                 return err;
5060         return 0;
5061 }
5062
5063 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5064 {
5065         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5066         return (pincap & AC_PINCAP_IN) != 0;
5067 }
5068
5069 /* create playback/capture controls for input pins */
5070 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5071                                       const struct auto_pin_cfg *cfg,
5072                                       hda_nid_t mixer,
5073                                       hda_nid_t cap1, hda_nid_t cap2)
5074 {
5075         struct alc_spec *spec = codec->spec;
5076         struct hda_input_mux *imux = &spec->private_imux[0];
5077         int i, err, idx, type, type_idx = 0;
5078
5079         for (i = 0; i < cfg->num_inputs; i++) {
5080                 hda_nid_t pin;
5081                 const char *label;
5082
5083                 pin = cfg->inputs[i].pin;
5084                 if (!alc_is_input_pin(codec, pin))
5085                         continue;
5086
5087                 type = cfg->inputs[i].type;
5088                 if (i > 0 && type == cfg->inputs[i - 1].type)
5089                         type_idx++;
5090                 else
5091                         type_idx = 0;
5092                 label = hda_get_autocfg_input_label(codec, cfg, i);
5093                 if (mixer) {
5094                         idx = get_connection_index(codec, mixer, pin);
5095                         if (idx >= 0) {
5096                                 err = new_analog_input(spec, pin,
5097                                                        label, type_idx,
5098                                                        idx, mixer);
5099                                 if (err < 0)
5100                                         return err;
5101                         }
5102                 }
5103
5104                 if (!cap1)
5105                         continue;
5106                 idx = get_connection_index(codec, cap1, pin);
5107                 if (idx < 0 && cap2)
5108                         idx = get_connection_index(codec, cap2, pin);
5109                 if (idx >= 0)
5110                         snd_hda_add_imux_item(imux, label, idx, NULL);
5111         }
5112         return 0;
5113 }
5114
5115 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5116                                                 const struct auto_pin_cfg *cfg)
5117 {
5118         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5119 }
5120
5121 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5122                                unsigned int pin_type)
5123 {
5124         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5125                             pin_type);
5126         /* unmute pin */
5127         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5128                             AMP_OUT_UNMUTE);
5129 }
5130
5131 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5132                                               hda_nid_t nid, int pin_type,
5133                                               int dac_idx)
5134 {
5135         alc_set_pin_output(codec, nid, pin_type);
5136         /* need the manual connection? */
5137         if (alc880_is_multi_pin(nid)) {
5138                 struct alc_spec *spec = codec->spec;
5139                 int idx = alc880_multi_pin_idx(nid);
5140                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5141                                     AC_VERB_SET_CONNECT_SEL,
5142                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5143         }
5144 }
5145
5146 static int get_pin_type(int line_out_type)
5147 {
5148         if (line_out_type == AUTO_PIN_HP_OUT)
5149                 return PIN_HP;
5150         else
5151                 return PIN_OUT;
5152 }
5153
5154 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5155 {
5156         struct alc_spec *spec = codec->spec;
5157         int i;
5158
5159         for (i = 0; i < spec->autocfg.line_outs; i++) {
5160                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5161                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5162                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5163         }
5164 }
5165
5166 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5167 {
5168         struct alc_spec *spec = codec->spec;
5169         hda_nid_t pin;
5170
5171         pin = spec->autocfg.speaker_pins[0];
5172         if (pin) /* connect to front */
5173                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5174         pin = spec->autocfg.hp_pins[0];
5175         if (pin) /* connect to front */
5176                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5177 }
5178
5179 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5180 {
5181         struct alc_spec *spec = codec->spec;
5182         struct auto_pin_cfg *cfg = &spec->autocfg;
5183         int i;
5184
5185         for (i = 0; i < cfg->num_inputs; i++) {
5186                 hda_nid_t nid = cfg->inputs[i].pin;
5187                 if (alc_is_input_pin(codec, nid)) {
5188                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5189                         if (nid != ALC880_PIN_CD_NID &&
5190                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5191                                 snd_hda_codec_write(codec, nid, 0,
5192                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5193                                                     AMP_OUT_MUTE);
5194                 }
5195         }
5196 }
5197
5198 static void alc880_auto_init_input_src(struct hda_codec *codec)
5199 {
5200         struct alc_spec *spec = codec->spec;
5201         int c;
5202
5203         for (c = 0; c < spec->num_adc_nids; c++) {
5204                 unsigned int mux_idx;
5205                 const struct hda_input_mux *imux;
5206                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5207                 imux = &spec->input_mux[mux_idx];
5208                 if (!imux->num_items && mux_idx > 0)
5209                         imux = &spec->input_mux[0];
5210                 if (imux)
5211                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5212                                             AC_VERB_SET_CONNECT_SEL,
5213                                             imux->items[0].index);
5214         }
5215 }
5216
5217 /* parse the BIOS configuration and set up the alc_spec */
5218 /* return 1 if successful, 0 if the proper config is not found,
5219  * or a negative error code
5220  */
5221 static int alc880_parse_auto_config(struct hda_codec *codec)
5222 {
5223         struct alc_spec *spec = codec->spec;
5224         int err;
5225         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5226
5227         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5228                                            alc880_ignore);
5229         if (err < 0)
5230                 return err;
5231         if (!spec->autocfg.line_outs)
5232                 return 0; /* can't find valid BIOS pin config */
5233
5234         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5235         if (err < 0)
5236                 return err;
5237         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5238         if (err < 0)
5239                 return err;
5240         err = alc880_auto_create_extra_out(spec,
5241                                            spec->autocfg.speaker_pins[0],
5242                                            "Speaker");
5243         if (err < 0)
5244                 return err;
5245         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5246                                            "Headphone");
5247         if (err < 0)
5248                 return err;
5249         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5250         if (err < 0)
5251                 return err;
5252
5253         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5254
5255         alc_auto_parse_digital(codec);
5256
5257         if (spec->kctls.list)
5258                 add_mixer(spec, spec->kctls.list);
5259
5260         add_verb(spec, alc880_volume_init_verbs);
5261
5262         spec->num_mux_defs = 1;
5263         spec->input_mux = &spec->private_imux[0];
5264
5265         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5266
5267         return 1;
5268 }
5269
5270 /* additional initialization for auto-configuration model */
5271 static void alc880_auto_init(struct hda_codec *codec)
5272 {
5273         struct alc_spec *spec = codec->spec;
5274         alc880_auto_init_multi_out(codec);
5275         alc880_auto_init_extra_out(codec);
5276         alc880_auto_init_analog_input(codec);
5277         alc880_auto_init_input_src(codec);
5278         alc_auto_init_digital(codec);
5279         if (spec->unsol_event)
5280                 alc_inithook(codec);
5281 }
5282
5283 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5284  * one of two digital mic pins, e.g. on ALC272
5285  */
5286 static void fixup_automic_adc(struct hda_codec *codec)
5287 {
5288         struct alc_spec *spec = codec->spec;
5289         int i;
5290
5291         for (i = 0; i < spec->num_adc_nids; i++) {
5292                 hda_nid_t cap = spec->capsrc_nids ?
5293                         spec->capsrc_nids[i] : spec->adc_nids[i];
5294                 int iidx, eidx;
5295
5296                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5297                 if (iidx < 0)
5298                         continue;
5299                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5300                 if (eidx < 0)
5301                         continue;
5302                 spec->int_mic.mux_idx = iidx;
5303                 spec->ext_mic.mux_idx = eidx;
5304                 if (spec->capsrc_nids)
5305                         spec->capsrc_nids += i;
5306                 spec->adc_nids += i;
5307                 spec->num_adc_nids = 1;
5308                 return;
5309         }
5310         snd_printd(KERN_INFO "hda_codec: %s: "
5311                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5312                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5313         spec->auto_mic = 0; /* disable auto-mic to be sure */
5314 }
5315
5316 /* select or unmute the given capsrc route */
5317 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5318                                     int idx)
5319 {
5320         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5321                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5322                                          HDA_AMP_MUTE, 0);
5323         } else {
5324                 snd_hda_codec_write_cache(codec, cap, 0,
5325                                           AC_VERB_SET_CONNECT_SEL, idx);
5326         }
5327 }
5328
5329 /* set the default connection to that pin */
5330 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5331 {
5332         struct alc_spec *spec = codec->spec;
5333         int i;
5334
5335         for (i = 0; i < spec->num_adc_nids; i++) {
5336                 hda_nid_t cap = spec->capsrc_nids ?
5337                         spec->capsrc_nids[i] : spec->adc_nids[i];
5338                 int idx;
5339
5340                 idx = get_connection_index(codec, cap, pin);
5341                 if (idx < 0)
5342                         continue;
5343                 select_or_unmute_capsrc(codec, cap, idx);
5344                 return i; /* return the found index */
5345         }
5346         return -1; /* not found */
5347 }
5348
5349 /* choose the ADC/MUX containing the input pin and initialize the setup */
5350 static void fixup_single_adc(struct hda_codec *codec)
5351 {
5352         struct alc_spec *spec = codec->spec;
5353         struct auto_pin_cfg *cfg = &spec->autocfg;
5354         int i;
5355
5356         /* search for the input pin; there must be only one */
5357         if (cfg->num_inputs != 1)
5358                 return;
5359         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5360         if (i >= 0) {
5361                 /* use only this ADC */
5362                 if (spec->capsrc_nids)
5363                         spec->capsrc_nids += i;
5364                 spec->adc_nids += i;
5365                 spec->num_adc_nids = 1;
5366         }
5367 }
5368
5369 /* initialize dual adcs */
5370 static void fixup_dual_adc_switch(struct hda_codec *codec)
5371 {
5372         struct alc_spec *spec = codec->spec;
5373         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5374         init_capsrc_for_pin(codec, spec->int_mic.pin);
5375 }
5376
5377 static void set_capture_mixer(struct hda_codec *codec)
5378 {
5379         struct alc_spec *spec = codec->spec;
5380         static struct snd_kcontrol_new *caps[2][3] = {
5381                 { alc_capture_mixer_nosrc1,
5382                   alc_capture_mixer_nosrc2,
5383                   alc_capture_mixer_nosrc3 },
5384                 { alc_capture_mixer1,
5385                   alc_capture_mixer2,
5386                   alc_capture_mixer3 },
5387         };
5388         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5389                 int mux = 0;
5390                 int num_adcs = spec->num_adc_nids;
5391                 if (spec->dual_adc_switch)
5392                         fixup_dual_adc_switch(codec);
5393                 else if (spec->auto_mic)
5394                         fixup_automic_adc(codec);
5395                 else if (spec->input_mux) {
5396                         if (spec->input_mux->num_items > 1)
5397                                 mux = 1;
5398                         else if (spec->input_mux->num_items == 1)
5399                                 fixup_single_adc(codec);
5400                 }
5401                 if (spec->dual_adc_switch)
5402                         num_adcs = 1;
5403                 spec->cap_mixer = caps[mux][num_adcs - 1];
5404         }
5405 }
5406
5407 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5408 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5409                                  int num_nids)
5410 {
5411         struct alc_spec *spec = codec->spec;
5412         struct auto_pin_cfg *cfg = &spec->autocfg;
5413         int n;
5414         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5415
5416         for (n = 0; n < num_nids; n++) {
5417                 hda_nid_t adc, cap;
5418                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5419                 int nconns, i, j;
5420
5421                 adc = nids[n];
5422                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5423                         continue;
5424                 cap = adc;
5425                 nconns = snd_hda_get_connections(codec, cap, conn,
5426                                                  ARRAY_SIZE(conn));
5427                 if (nconns == 1) {
5428                         cap = conn[0];
5429                         nconns = snd_hda_get_connections(codec, cap, conn,
5430                                                          ARRAY_SIZE(conn));
5431                 }
5432                 if (nconns <= 0)
5433                         continue;
5434                 if (!fallback_adc) {
5435                         fallback_adc = adc;
5436                         fallback_cap = cap;
5437                 }
5438                 for (i = 0; i < cfg->num_inputs; i++) {
5439                         hda_nid_t nid = cfg->inputs[i].pin;
5440                         for (j = 0; j < nconns; j++) {
5441                                 if (conn[j] == nid)
5442                                         break;
5443                         }
5444                         if (j >= nconns)
5445                                 break;
5446                 }
5447                 if (i >= cfg->num_inputs) {
5448                         int num_adcs = spec->num_adc_nids;
5449                         spec->private_adc_nids[num_adcs] = adc;
5450                         spec->private_capsrc_nids[num_adcs] = cap;
5451                         spec->num_adc_nids++;
5452                         spec->adc_nids = spec->private_adc_nids;
5453                         if (adc != cap)
5454                                 spec->capsrc_nids = spec->private_capsrc_nids;
5455                 }
5456         }
5457         if (!spec->num_adc_nids) {
5458                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5459                        " using fallback 0x%x\n",
5460                        codec->chip_name, fallback_adc);
5461                 spec->private_adc_nids[0] = fallback_adc;
5462                 spec->adc_nids = spec->private_adc_nids;
5463                 if (fallback_adc != fallback_cap) {
5464                         spec->private_capsrc_nids[0] = fallback_cap;
5465                         spec->capsrc_nids = spec->private_adc_nids;
5466                 }
5467         }
5468 }
5469
5470 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5471 #define set_beep_amp(spec, nid, idx, dir) \
5472         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5473
5474 static struct snd_pci_quirk beep_white_list[] = {
5475         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5476         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5477         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5478         {}
5479 };
5480
5481 static inline int has_cdefine_beep(struct hda_codec *codec)
5482 {
5483         struct alc_spec *spec = codec->spec;
5484         const struct snd_pci_quirk *q;
5485         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5486         if (q)
5487                 return q->value;
5488         return spec->cdefine.enable_pcbeep;
5489 }
5490 #else
5491 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5492 #define has_cdefine_beep(codec)         0
5493 #endif
5494
5495 /*
5496  * OK, here we have finally the patch for ALC880
5497  */
5498
5499 static int patch_alc880(struct hda_codec *codec)
5500 {
5501         struct alc_spec *spec;
5502         int board_config;
5503         int err;
5504
5505         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5506         if (spec == NULL)
5507                 return -ENOMEM;
5508
5509         codec->spec = spec;
5510
5511         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5512                                                   alc880_models,
5513                                                   alc880_cfg_tbl);
5514         if (board_config < 0) {
5515                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5516                        codec->chip_name);
5517                 board_config = ALC880_AUTO;
5518         }
5519
5520         if (board_config == ALC880_AUTO) {
5521                 /* automatic parse from the BIOS config */
5522                 err = alc880_parse_auto_config(codec);
5523                 if (err < 0) {
5524                         alc_free(codec);
5525                         return err;
5526                 } else if (!err) {
5527                         printk(KERN_INFO
5528                                "hda_codec: Cannot set up configuration "
5529                                "from BIOS.  Using 3-stack mode...\n");
5530                         board_config = ALC880_3ST;
5531                 }
5532         }
5533
5534         err = snd_hda_attach_beep_device(codec, 0x1);
5535         if (err < 0) {
5536                 alc_free(codec);
5537                 return err;
5538         }
5539
5540         if (board_config != ALC880_AUTO)
5541                 setup_preset(codec, &alc880_presets[board_config]);
5542
5543         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5544         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5545         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5546
5547         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5548         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5549
5550         if (!spec->adc_nids && spec->input_mux) {
5551                 /* check whether NID 0x07 is valid */
5552                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5553                 /* get type */
5554                 wcap = get_wcaps_type(wcap);
5555                 if (wcap != AC_WID_AUD_IN) {
5556                         spec->adc_nids = alc880_adc_nids_alt;
5557                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5558                 } else {
5559                         spec->adc_nids = alc880_adc_nids;
5560                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5561                 }
5562         }
5563         set_capture_mixer(codec);
5564         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5565
5566         spec->vmaster_nid = 0x0c;
5567
5568         codec->patch_ops = alc_patch_ops;
5569         if (board_config == ALC880_AUTO)
5570                 spec->init_hook = alc880_auto_init;
5571 #ifdef CONFIG_SND_HDA_POWER_SAVE
5572         if (!spec->loopback.amplist)
5573                 spec->loopback.amplist = alc880_loopbacks;
5574 #endif
5575
5576         return 0;
5577 }
5578
5579
5580 /*
5581  * ALC260 support
5582  */
5583
5584 static hda_nid_t alc260_dac_nids[1] = {
5585         /* front */
5586         0x02,
5587 };
5588
5589 static hda_nid_t alc260_adc_nids[1] = {
5590         /* ADC0 */
5591         0x04,
5592 };
5593
5594 static hda_nid_t alc260_adc_nids_alt[1] = {
5595         /* ADC1 */
5596         0x05,
5597 };
5598
5599 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5600  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5601  */
5602 static hda_nid_t alc260_dual_adc_nids[2] = {
5603         /* ADC0, ADC1 */
5604         0x04, 0x05
5605 };
5606
5607 #define ALC260_DIGOUT_NID       0x03
5608 #define ALC260_DIGIN_NID        0x06
5609
5610 static struct hda_input_mux alc260_capture_source = {
5611         .num_items = 4,
5612         .items = {
5613                 { "Mic", 0x0 },
5614                 { "Front Mic", 0x1 },
5615                 { "Line", 0x2 },
5616                 { "CD", 0x4 },
5617         },
5618 };
5619
5620 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5621  * headphone jack and the internal CD lines since these are the only pins at
5622  * which audio can appear.  For flexibility, also allow the option of
5623  * recording the mixer output on the second ADC (ADC0 doesn't have a
5624  * connection to the mixer output).
5625  */
5626 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5627         {
5628                 .num_items = 3,
5629                 .items = {
5630                         { "Mic/Line", 0x0 },
5631                         { "CD", 0x4 },
5632                         { "Headphone", 0x2 },
5633                 },
5634         },
5635         {
5636                 .num_items = 4,
5637                 .items = {
5638                         { "Mic/Line", 0x0 },
5639                         { "CD", 0x4 },
5640                         { "Headphone", 0x2 },
5641                         { "Mixer", 0x5 },
5642                 },
5643         },
5644
5645 };
5646
5647 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5648  * the Fujitsu S702x, but jacks are marked differently.
5649  */
5650 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5651         {
5652                 .num_items = 4,
5653                 .items = {
5654                         { "Mic", 0x0 },
5655                         { "Line", 0x2 },
5656                         { "CD", 0x4 },
5657                         { "Headphone", 0x5 },
5658                 },
5659         },
5660         {
5661                 .num_items = 5,
5662                 .items = {
5663                         { "Mic", 0x0 },
5664                         { "Line", 0x2 },
5665                         { "CD", 0x4 },
5666                         { "Headphone", 0x6 },
5667                         { "Mixer", 0x5 },
5668                 },
5669         },
5670 };
5671
5672 /* Maxdata Favorit 100XS */
5673 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5674         {
5675                 .num_items = 2,
5676                 .items = {
5677                         { "Line/Mic", 0x0 },
5678                         { "CD", 0x4 },
5679                 },
5680         },
5681         {
5682                 .num_items = 3,
5683                 .items = {
5684                         { "Line/Mic", 0x0 },
5685                         { "CD", 0x4 },
5686                         { "Mixer", 0x5 },
5687                 },
5688         },
5689 };
5690
5691 /*
5692  * This is just place-holder, so there's something for alc_build_pcms to look
5693  * at when it calculates the maximum number of channels. ALC260 has no mixer
5694  * element which allows changing the channel mode, so the verb list is
5695  * never used.
5696  */
5697 static struct hda_channel_mode alc260_modes[1] = {
5698         { 2, NULL },
5699 };
5700
5701
5702 /* Mixer combinations
5703  *
5704  * basic: base_output + input + pc_beep + capture
5705  * HP: base_output + input + capture_alt
5706  * HP_3013: hp_3013 + input + capture
5707  * fujitsu: fujitsu + capture
5708  * acer: acer + capture
5709  */
5710
5711 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5712         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5713         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5714         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5715         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5716         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5717         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5718         { } /* end */
5719 };
5720
5721 static struct snd_kcontrol_new alc260_input_mixer[] = {
5722         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5723         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5724         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5725         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5726         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5727         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5728         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5729         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5730         { } /* end */
5731 };
5732
5733 /* update HP, line and mono out pins according to the master switch */
5734 static void alc260_hp_master_update(struct hda_codec *codec,
5735                                     hda_nid_t hp, hda_nid_t line,
5736                                     hda_nid_t mono)
5737 {
5738         struct alc_spec *spec = codec->spec;
5739         unsigned int val = spec->master_sw ? PIN_HP : 0;
5740         /* change HP and line-out pins */
5741         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5742                             val);
5743         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5744                             val);
5745         /* mono (speaker) depending on the HP jack sense */
5746         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5747         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5748                             val);
5749 }
5750
5751 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5752                                    struct snd_ctl_elem_value *ucontrol)
5753 {
5754         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5755         struct alc_spec *spec = codec->spec;
5756         *ucontrol->value.integer.value = spec->master_sw;
5757         return 0;
5758 }
5759
5760 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5761                                    struct snd_ctl_elem_value *ucontrol)
5762 {
5763         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5764         struct alc_spec *spec = codec->spec;
5765         int val = !!*ucontrol->value.integer.value;
5766         hda_nid_t hp, line, mono;
5767
5768         if (val == spec->master_sw)
5769                 return 0;
5770         spec->master_sw = val;
5771         hp = (kcontrol->private_value >> 16) & 0xff;
5772         line = (kcontrol->private_value >> 8) & 0xff;
5773         mono = kcontrol->private_value & 0xff;
5774         alc260_hp_master_update(codec, hp, line, mono);
5775         return 1;
5776 }
5777
5778 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5779         {
5780                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5781                 .name = "Master Playback Switch",
5782                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5783                 .info = snd_ctl_boolean_mono_info,
5784                 .get = alc260_hp_master_sw_get,
5785                 .put = alc260_hp_master_sw_put,
5786                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5787         },
5788         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5789         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5790         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5791         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5792         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5793                               HDA_OUTPUT),
5794         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5795         { } /* end */
5796 };
5797
5798 static struct hda_verb alc260_hp_unsol_verbs[] = {
5799         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5800         {},
5801 };
5802
5803 static void alc260_hp_automute(struct hda_codec *codec)
5804 {
5805         struct alc_spec *spec = codec->spec;
5806
5807         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5808         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5809 }
5810
5811 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5812 {
5813         if ((res >> 26) == ALC880_HP_EVENT)
5814                 alc260_hp_automute(codec);
5815 }
5816
5817 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5818         {
5819                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5820                 .name = "Master Playback Switch",
5821                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5822                 .info = snd_ctl_boolean_mono_info,
5823                 .get = alc260_hp_master_sw_get,
5824                 .put = alc260_hp_master_sw_put,
5825                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5826         },
5827         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5828         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5829         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5830         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5831         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5832         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5833         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5834         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5835         { } /* end */
5836 };
5837
5838 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5839         .ops = &snd_hda_bind_vol,
5840         .values = {
5841                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5842                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5843                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5844                 0
5845         },
5846 };
5847
5848 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5849         .ops = &snd_hda_bind_sw,
5850         .values = {
5851                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5852                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5853                 0
5854         },
5855 };
5856
5857 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5858         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5859         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5860         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5861         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5862         { } /* end */
5863 };
5864
5865 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5866         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5867         {},
5868 };
5869
5870 static void alc260_hp_3013_automute(struct hda_codec *codec)
5871 {
5872         struct alc_spec *spec = codec->spec;
5873
5874         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5875         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5876 }
5877
5878 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5879                                        unsigned int res)
5880 {
5881         if ((res >> 26) == ALC880_HP_EVENT)
5882                 alc260_hp_3013_automute(codec);
5883 }
5884
5885 static void alc260_hp_3012_automute(struct hda_codec *codec)
5886 {
5887         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5888
5889         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5890                             bits);
5891         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5892                             bits);
5893         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5894                             bits);
5895 }
5896
5897 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5898                                        unsigned int res)
5899 {
5900         if ((res >> 26) == ALC880_HP_EVENT)
5901                 alc260_hp_3012_automute(codec);
5902 }
5903
5904 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5905  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5906  */
5907 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5908         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5909         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5910         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5911         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5912         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5913         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5914         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5915         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5916         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5917         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5918         { } /* end */
5919 };
5920
5921 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5922  * versions of the ALC260 don't act on requests to enable mic bias from NID
5923  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5924  * datasheet doesn't mention this restriction.  At this stage it's not clear
5925  * whether this behaviour is intentional or is a hardware bug in chip
5926  * revisions available in early 2006.  Therefore for now allow the
5927  * "Headphone Jack Mode" control to span all choices, but if it turns out
5928  * that the lack of mic bias for this NID is intentional we could change the
5929  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5930  *
5931  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5932  * don't appear to make the mic bias available from the "line" jack, even
5933  * though the NID used for this jack (0x14) can supply it.  The theory is
5934  * that perhaps Acer have included blocking capacitors between the ALC260
5935  * and the output jack.  If this turns out to be the case for all such
5936  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5937  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5938  *
5939  * The C20x Tablet series have a mono internal speaker which is controlled
5940  * via the chip's Mono sum widget and pin complex, so include the necessary
5941  * controls for such models.  On models without a "mono speaker" the control
5942  * won't do anything.
5943  */
5944 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5945         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5946         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5947         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5948         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5949                               HDA_OUTPUT),
5950         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5951                            HDA_INPUT),
5952         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5953         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5954         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5955         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5956         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5957         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5958         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5959         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5960         { } /* end */
5961 };
5962
5963 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5964  */
5965 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5966         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5967         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5968         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5969         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5970         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5971         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5972         { } /* end */
5973 };
5974
5975 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5976  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5977  */
5978 static struct snd_kcontrol_new alc260_will_mixer[] = {
5979         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5980         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5981         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5982         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5983         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5984         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5985         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5986         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5987         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5988         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5989         { } /* end */
5990 };
5991
5992 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5993  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5994  */
5995 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5996         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5997         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5998         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5999         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6000         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6001         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6002         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6003         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6004         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6005         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6006         { } /* end */
6007 };
6008
6009 /*
6010  * initialization verbs
6011  */
6012 static struct hda_verb alc260_init_verbs[] = {
6013         /* Line In pin widget for input */
6014         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6015         /* CD pin widget for input */
6016         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6017         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6018         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6019         /* Mic2 (front panel) pin widget for input and vref at 80% */
6020         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6021         /* LINE-2 is used for line-out in rear */
6022         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6023         /* select line-out */
6024         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6025         /* LINE-OUT pin */
6026         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6027         /* enable HP */
6028         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6029         /* enable Mono */
6030         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6031         /* mute capture amp left and right */
6032         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6033         /* set connection select to line in (default select for this ADC) */
6034         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6035         /* mute capture amp left and right */
6036         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6037         /* set connection select to line in (default select for this ADC) */
6038         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6039         /* set vol=0 Line-Out mixer amp left and right */
6040         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6041         /* unmute pin widget amp left and right (no gain on this amp) */
6042         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6043         /* set vol=0 HP mixer amp left and right */
6044         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6045         /* unmute pin widget amp left and right (no gain on this amp) */
6046         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6047         /* set vol=0 Mono mixer amp left and right */
6048         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6049         /* unmute pin widget amp left and right (no gain on this amp) */
6050         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6051         /* unmute LINE-2 out pin */
6052         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6053         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6054          * Line In 2 = 0x03
6055          */
6056         /* mute analog inputs */
6057         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6058         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6059         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6060         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6061         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6062         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6063         /* mute Front out path */
6064         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6065         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6066         /* mute Headphone out path */
6067         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6068         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6069         /* mute Mono out path */
6070         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6071         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6072         { }
6073 };
6074
6075 #if 0 /* should be identical with alc260_init_verbs? */
6076 static struct hda_verb alc260_hp_init_verbs[] = {
6077         /* Headphone and output */
6078         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6079         /* mono output */
6080         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6081         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6082         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6083         /* Mic2 (front panel) pin widget for input and vref at 80% */
6084         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6085         /* Line In pin widget for input */
6086         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6087         /* Line-2 pin widget for output */
6088         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6089         /* CD pin widget for input */
6090         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6091         /* unmute amp left and right */
6092         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6093         /* set connection select to line in (default select for this ADC) */
6094         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6095         /* unmute Line-Out mixer amp left and right (volume = 0) */
6096         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6097         /* mute pin widget amp left and right (no gain on this amp) */
6098         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6099         /* unmute HP mixer amp left and right (volume = 0) */
6100         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6101         /* mute pin widget amp left and right (no gain on this amp) */
6102         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6103         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6104          * Line In 2 = 0x03
6105          */
6106         /* mute analog inputs */
6107         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6108         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6109         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6110         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6111         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6112         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6113         /* Unmute Front out path */
6114         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6115         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6116         /* Unmute Headphone out path */
6117         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6118         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6119         /* Unmute Mono out path */
6120         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6121         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6122         { }
6123 };
6124 #endif
6125
6126 static struct hda_verb alc260_hp_3013_init_verbs[] = {
6127         /* Line out and output */
6128         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6129         /* mono output */
6130         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6131         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6132         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6133         /* Mic2 (front panel) pin widget for input and vref at 80% */
6134         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6135         /* Line In pin widget for input */
6136         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6137         /* Headphone pin widget for output */
6138         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6139         /* CD pin widget for input */
6140         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6141         /* unmute amp left and right */
6142         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6143         /* set connection select to line in (default select for this ADC) */
6144         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6145         /* unmute Line-Out mixer amp left and right (volume = 0) */
6146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6147         /* mute pin widget amp left and right (no gain on this amp) */
6148         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6149         /* unmute HP mixer amp left and right (volume = 0) */
6150         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6151         /* mute pin widget amp left and right (no gain on this amp) */
6152         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6153         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6154          * Line In 2 = 0x03
6155          */
6156         /* mute analog inputs */
6157         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6158         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6159         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6160         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6161         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6162         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6163         /* Unmute Front out path */
6164         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6165         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6166         /* Unmute Headphone out path */
6167         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6168         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6169         /* Unmute Mono out path */
6170         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6171         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6172         { }
6173 };
6174
6175 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6176  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6177  * audio = 0x16, internal speaker = 0x10.
6178  */
6179 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6180         /* Disable all GPIOs */
6181         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6182         /* Internal speaker is connected to headphone pin */
6183         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6184         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6185         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6186         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6187         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6188         /* Ensure all other unused pins are disabled and muted. */
6189         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6190         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6191         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6192         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6193         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6194         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6195         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6196         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6197
6198         /* Disable digital (SPDIF) pins */
6199         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6200         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6201
6202         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6203          * when acting as an output.
6204          */
6205         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6206
6207         /* Start with output sum widgets muted and their output gains at min */
6208         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6209         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6210         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6211         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6212         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6213         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6214         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6215         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6216         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6217
6218         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6219         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6220         /* Unmute Line1 pin widget output buffer since it starts as an output.
6221          * If the pin mode is changed by the user the pin mode control will
6222          * take care of enabling the pin's input/output buffers as needed.
6223          * Therefore there's no need to enable the input buffer at this
6224          * stage.
6225          */
6226         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6227         /* Unmute input buffer of pin widget used for Line-in (no equiv
6228          * mixer ctrl)
6229          */
6230         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6231
6232         /* Mute capture amp left and right */
6233         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6234         /* Set ADC connection select to match default mixer setting - line
6235          * in (on mic1 pin)
6236          */
6237         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6238
6239         /* Do the same for the second ADC: mute capture input amp and
6240          * set ADC connection to line in (on mic1 pin)
6241          */
6242         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6243         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6244
6245         /* Mute all inputs to mixer widget (even unconnected ones) */
6246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6249         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6250         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6251         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6252         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6253         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6254
6255         { }
6256 };
6257
6258 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6259  * similar laptops (adapted from Fujitsu init verbs).
6260  */
6261 static struct hda_verb alc260_acer_init_verbs[] = {
6262         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6263          * the headphone jack.  Turn this on and rely on the standard mute
6264          * methods whenever the user wants to turn these outputs off.
6265          */
6266         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6267         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6268         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6269         /* Internal speaker/Headphone jack is connected to Line-out pin */
6270         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6271         /* Internal microphone/Mic jack is connected to Mic1 pin */
6272         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6273         /* Line In jack is connected to Line1 pin */
6274         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6275         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6276         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6277         /* Ensure all other unused pins are disabled and muted. */
6278         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6279         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6280         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6281         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6282         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6283         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6284         /* Disable digital (SPDIF) pins */
6285         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6286         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6287
6288         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6289          * bus when acting as outputs.
6290          */
6291         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6292         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6293
6294         /* Start with output sum widgets muted and their output gains at min */
6295         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6296         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6297         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6298         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6299         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6300         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6301         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6302         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6303         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6304
6305         /* Unmute Line-out pin widget amp left and right
6306          * (no equiv mixer ctrl)
6307          */
6308         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6309         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6310         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6311         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6312          * inputs. If the pin mode is changed by the user the pin mode control
6313          * will take care of enabling the pin's input/output buffers as needed.
6314          * Therefore there's no need to enable the input buffer at this
6315          * stage.
6316          */
6317         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6318         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6319
6320         /* Mute capture amp left and right */
6321         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6322         /* Set ADC connection select to match default mixer setting - mic
6323          * (on mic1 pin)
6324          */
6325         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6326
6327         /* Do similar with the second ADC: mute capture input amp and
6328          * set ADC connection to mic to match ALSA's default state.
6329          */
6330         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6331         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6332
6333         /* Mute all inputs to mixer widget (even unconnected ones) */
6334         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6335         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6336         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6337         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6338         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6339         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6340         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6341         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6342
6343         { }
6344 };
6345
6346 /* Initialisation sequence for Maxdata Favorit 100XS
6347  * (adapted from Acer init verbs).
6348  */
6349 static struct hda_verb alc260_favorit100_init_verbs[] = {
6350         /* GPIO 0 enables the output jack.
6351          * Turn this on and rely on the standard mute
6352          * methods whenever the user wants to turn these outputs off.
6353          */
6354         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6355         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6356         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6357         /* Line/Mic input jack is connected to Mic1 pin */
6358         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6359         /* Ensure all other unused pins are disabled and muted. */
6360         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6361         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6362         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6363         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6364         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6365         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6366         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6367         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6368         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6369         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6370         /* Disable digital (SPDIF) pins */
6371         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6372         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6373
6374         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6375          * bus when acting as outputs.
6376          */
6377         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6378         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6379
6380         /* Start with output sum widgets muted and their output gains at min */
6381         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6382         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6383         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6384         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6385         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6386         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6387         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6388         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6389         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6390
6391         /* Unmute Line-out pin widget amp left and right
6392          * (no equiv mixer ctrl)
6393          */
6394         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6395         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6396          * inputs. If the pin mode is changed by the user the pin mode control
6397          * will take care of enabling the pin's input/output buffers as needed.
6398          * Therefore there's no need to enable the input buffer at this
6399          * stage.
6400          */
6401         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6402
6403         /* Mute capture amp left and right */
6404         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6405         /* Set ADC connection select to match default mixer setting - mic
6406          * (on mic1 pin)
6407          */
6408         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6409
6410         /* Do similar with the second ADC: mute capture input amp and
6411          * set ADC connection to mic to match ALSA's default state.
6412          */
6413         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6414         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6415
6416         /* Mute all inputs to mixer widget (even unconnected ones) */
6417         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6418         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6419         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6420         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6421         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6422         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6423         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6424         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6425
6426         { }
6427 };
6428
6429 static struct hda_verb alc260_will_verbs[] = {
6430         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6431         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6432         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6433         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6434         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6435         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6436         {}
6437 };
6438
6439 static struct hda_verb alc260_replacer_672v_verbs[] = {
6440         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6441         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6442         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6443
6444         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6445         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6446         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6447
6448         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6449         {}
6450 };
6451
6452 /* toggle speaker-output according to the hp-jack state */
6453 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6454 {
6455         unsigned int present;
6456
6457         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6458         present = snd_hda_jack_detect(codec, 0x0f);
6459         if (present) {
6460                 snd_hda_codec_write_cache(codec, 0x01, 0,
6461                                           AC_VERB_SET_GPIO_DATA, 1);
6462                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6463                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6464                                           PIN_HP);
6465         } else {
6466                 snd_hda_codec_write_cache(codec, 0x01, 0,
6467                                           AC_VERB_SET_GPIO_DATA, 0);
6468                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6469                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6470                                           PIN_OUT);
6471         }
6472 }
6473
6474 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6475                                        unsigned int res)
6476 {
6477         if ((res >> 26) == ALC880_HP_EVENT)
6478                 alc260_replacer_672v_automute(codec);
6479 }
6480
6481 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6482         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6483         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6484         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6485         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6486         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6487         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6488         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6489         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6490         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6491         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6492         {}
6493 };
6494
6495 /* Test configuration for debugging, modelled after the ALC880 test
6496  * configuration.
6497  */
6498 #ifdef CONFIG_SND_DEBUG
6499 static hda_nid_t alc260_test_dac_nids[1] = {
6500         0x02,
6501 };
6502 static hda_nid_t alc260_test_adc_nids[2] = {
6503         0x04, 0x05,
6504 };
6505 /* For testing the ALC260, each input MUX needs its own definition since
6506  * the signal assignments are different.  This assumes that the first ADC
6507  * is NID 0x04.
6508  */
6509 static struct hda_input_mux alc260_test_capture_sources[2] = {
6510         {
6511                 .num_items = 7,
6512                 .items = {
6513                         { "MIC1 pin", 0x0 },
6514                         { "MIC2 pin", 0x1 },
6515                         { "LINE1 pin", 0x2 },
6516                         { "LINE2 pin", 0x3 },
6517                         { "CD pin", 0x4 },
6518                         { "LINE-OUT pin", 0x5 },
6519                         { "HP-OUT pin", 0x6 },
6520                 },
6521         },
6522         {
6523                 .num_items = 8,
6524                 .items = {
6525                         { "MIC1 pin", 0x0 },
6526                         { "MIC2 pin", 0x1 },
6527                         { "LINE1 pin", 0x2 },
6528                         { "LINE2 pin", 0x3 },
6529                         { "CD pin", 0x4 },
6530                         { "Mixer", 0x5 },
6531                         { "LINE-OUT pin", 0x6 },
6532                         { "HP-OUT pin", 0x7 },
6533                 },
6534         },
6535 };
6536 static struct snd_kcontrol_new alc260_test_mixer[] = {
6537         /* Output driver widgets */
6538         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6539         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6540         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6541         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6542         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6543         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6544
6545         /* Modes for retasking pin widgets
6546          * Note: the ALC260 doesn't seem to act on requests to enable mic
6547          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6548          * mention this restriction.  At this stage it's not clear whether
6549          * this behaviour is intentional or is a hardware bug in chip
6550          * revisions available at least up until early 2006.  Therefore for
6551          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6552          * choices, but if it turns out that the lack of mic bias for these
6553          * NIDs is intentional we could change their modes from
6554          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6555          */
6556         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6557         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6558         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6559         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6560         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6561         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6562
6563         /* Loopback mixer controls */
6564         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6565         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6566         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6567         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6568         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6569         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6570         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6571         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6572         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6573         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6574         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6575         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6576         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6577         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6578
6579         /* Controls for GPIO pins, assuming they are configured as outputs */
6580         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6581         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6582         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6583         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6584
6585         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6586          * is ambigious as to which NID is which; testing on laptops which
6587          * make this output available should provide clarification.
6588          */
6589         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6590         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6591
6592         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6593          * this output to turn on an external amplifier.
6594          */
6595         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6596         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6597
6598         { } /* end */
6599 };
6600 static struct hda_verb alc260_test_init_verbs[] = {
6601         /* Enable all GPIOs as outputs with an initial value of 0 */
6602         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6603         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6604         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6605
6606         /* Enable retasking pins as output, initially without power amp */
6607         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6608         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6609         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6610         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6611         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6612         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6613
6614         /* Disable digital (SPDIF) pins initially, but users can enable
6615          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6616          * payload also sets the generation to 0, output to be in "consumer"
6617          * PCM format, copyright asserted, no pre-emphasis and no validity
6618          * control.
6619          */
6620         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6621         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6622
6623         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6624          * OUT1 sum bus when acting as an output.
6625          */
6626         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6627         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6628         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6629         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6630
6631         /* Start with output sum widgets muted and their output gains at min */
6632         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6633         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6634         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6635         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6636         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6637         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6638         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6639         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6640         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6641
6642         /* Unmute retasking pin widget output buffers since the default
6643          * state appears to be output.  As the pin mode is changed by the
6644          * user the pin mode control will take care of enabling the pin's
6645          * input/output buffers as needed.
6646          */
6647         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6648         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6649         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6650         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6651         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6652         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6653         /* Also unmute the mono-out pin widget */
6654         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6655
6656         /* Mute capture amp left and right */
6657         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6658         /* Set ADC connection select to match default mixer setting (mic1
6659          * pin)
6660          */
6661         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6662
6663         /* Do the same for the second ADC: mute capture input amp and
6664          * set ADC connection to mic1 pin
6665          */
6666         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6667         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6668
6669         /* Mute all inputs to mixer widget (even unconnected ones) */
6670         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6671         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6672         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6673         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6674         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6675         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6676         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6677         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6678
6679         { }
6680 };
6681 #endif
6682
6683 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6684 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6685
6686 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6687 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6688
6689 /*
6690  * for BIOS auto-configuration
6691  */
6692
6693 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6694                                         const char *pfx, int *vol_bits)
6695 {
6696         hda_nid_t nid_vol;
6697         unsigned long vol_val, sw_val;
6698         int err;
6699
6700         if (nid >= 0x0f && nid < 0x11) {
6701                 nid_vol = nid - 0x7;
6702                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6703                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6704         } else if (nid == 0x11) {
6705                 nid_vol = nid - 0x7;
6706                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6707                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6708         } else if (nid >= 0x12 && nid <= 0x15) {
6709                 nid_vol = 0x08;
6710                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6711                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6712         } else
6713                 return 0; /* N/A */
6714
6715         if (!(*vol_bits & (1 << nid_vol))) {
6716                 /* first control for the volume widget */
6717                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6718                 if (err < 0)
6719                         return err;
6720                 *vol_bits |= (1 << nid_vol);
6721         }
6722         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6723         if (err < 0)
6724                 return err;
6725         return 1;
6726 }
6727
6728 /* add playback controls from the parsed DAC table */
6729 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6730                                              const struct auto_pin_cfg *cfg)
6731 {
6732         hda_nid_t nid;
6733         int err;
6734         int vols = 0;
6735
6736         spec->multiout.num_dacs = 1;
6737         spec->multiout.dac_nids = spec->private_dac_nids;
6738         spec->multiout.dac_nids[0] = 0x02;
6739
6740         nid = cfg->line_out_pins[0];
6741         if (nid) {
6742                 const char *pfx;
6743                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6744                         pfx = "Master";
6745                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6746                         pfx = "Speaker";
6747                 else
6748                         pfx = "Front";
6749                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6750                 if (err < 0)
6751                         return err;
6752         }
6753
6754         nid = cfg->speaker_pins[0];
6755         if (nid) {
6756                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6757                 if (err < 0)
6758                         return err;
6759         }
6760
6761         nid = cfg->hp_pins[0];
6762         if (nid) {
6763                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6764                                                    &vols);
6765                 if (err < 0)
6766                         return err;
6767         }
6768         return 0;
6769 }
6770
6771 /* create playback/capture controls for input pins */
6772 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6773                                                 const struct auto_pin_cfg *cfg)
6774 {
6775         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6776 }
6777
6778 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6779                                               hda_nid_t nid, int pin_type,
6780                                               int sel_idx)
6781 {
6782         alc_set_pin_output(codec, nid, pin_type);
6783         /* need the manual connection? */
6784         if (nid >= 0x12) {
6785                 int idx = nid - 0x12;
6786                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6787                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6788         }
6789 }
6790
6791 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6792 {
6793         struct alc_spec *spec = codec->spec;
6794         hda_nid_t nid;
6795
6796         nid = spec->autocfg.line_out_pins[0];
6797         if (nid) {
6798                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6799                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6800         }
6801
6802         nid = spec->autocfg.speaker_pins[0];
6803         if (nid)
6804                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6805
6806         nid = spec->autocfg.hp_pins[0];
6807         if (nid)
6808                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6809 }
6810
6811 #define ALC260_PIN_CD_NID               0x16
6812 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6813 {
6814         struct alc_spec *spec = codec->spec;
6815         struct auto_pin_cfg *cfg = &spec->autocfg;
6816         int i;
6817
6818         for (i = 0; i < cfg->num_inputs; i++) {
6819                 hda_nid_t nid = cfg->inputs[i].pin;
6820                 if (nid >= 0x12) {
6821                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6822                         if (nid != ALC260_PIN_CD_NID &&
6823                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6824                                 snd_hda_codec_write(codec, nid, 0,
6825                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6826                                                     AMP_OUT_MUTE);
6827                 }
6828         }
6829 }
6830
6831 #define alc260_auto_init_input_src      alc880_auto_init_input_src
6832
6833 /*
6834  * generic initialization of ADC, input mixers and output mixers
6835  */
6836 static struct hda_verb alc260_volume_init_verbs[] = {
6837         /*
6838          * Unmute ADC0-1 and set the default input to mic-in
6839          */
6840         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6841         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6842         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6843         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6844
6845         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6846          * mixer widget
6847          * Note: PASD motherboards uses the Line In 2 as the input for
6848          * front panel mic (mic 2)
6849          */
6850         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6851         /* mute analog inputs */
6852         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6853         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6854         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6855         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6856         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6857
6858         /*
6859          * Set up output mixers (0x08 - 0x0a)
6860          */
6861         /* set vol=0 to output mixers */
6862         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6863         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6864         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6865         /* set up input amps for analog loopback */
6866         /* Amp Indices: DAC = 0, mixer = 1 */
6867         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6868         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6869         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6870         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6871         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6872         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6873
6874         { }
6875 };
6876
6877 static int alc260_parse_auto_config(struct hda_codec *codec)
6878 {
6879         struct alc_spec *spec = codec->spec;
6880         int err;
6881         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6882
6883         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6884                                            alc260_ignore);
6885         if (err < 0)
6886                 return err;
6887         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6888         if (err < 0)
6889                 return err;
6890         if (!spec->kctls.list)
6891                 return 0; /* can't find valid BIOS pin config */
6892         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6893         if (err < 0)
6894                 return err;
6895
6896         spec->multiout.max_channels = 2;
6897
6898         if (spec->autocfg.dig_outs)
6899                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6900         if (spec->kctls.list)
6901                 add_mixer(spec, spec->kctls.list);
6902
6903         add_verb(spec, alc260_volume_init_verbs);
6904
6905         spec->num_mux_defs = 1;
6906         spec->input_mux = &spec->private_imux[0];
6907
6908         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6909
6910         return 1;
6911 }
6912
6913 /* additional initialization for auto-configuration model */
6914 static void alc260_auto_init(struct hda_codec *codec)
6915 {
6916         struct alc_spec *spec = codec->spec;
6917         alc260_auto_init_multi_out(codec);
6918         alc260_auto_init_analog_input(codec);
6919         alc260_auto_init_input_src(codec);
6920         alc_auto_init_digital(codec);
6921         if (spec->unsol_event)
6922                 alc_inithook(codec);
6923 }
6924
6925 #ifdef CONFIG_SND_HDA_POWER_SAVE
6926 static struct hda_amp_list alc260_loopbacks[] = {
6927         { 0x07, HDA_INPUT, 0 },
6928         { 0x07, HDA_INPUT, 1 },
6929         { 0x07, HDA_INPUT, 2 },
6930         { 0x07, HDA_INPUT, 3 },
6931         { 0x07, HDA_INPUT, 4 },
6932         { } /* end */
6933 };
6934 #endif
6935
6936 /*
6937  * Pin config fixes
6938  */
6939 enum {
6940         PINFIX_HP_DC5750,
6941 };
6942
6943 static const struct alc_fixup alc260_fixups[] = {
6944         [PINFIX_HP_DC5750] = {
6945                 .pins = (const struct alc_pincfg[]) {
6946                         { 0x11, 0x90130110 }, /* speaker */
6947                         { }
6948                 }
6949         },
6950 };
6951
6952 static struct snd_pci_quirk alc260_fixup_tbl[] = {
6953         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
6954         {}
6955 };
6956
6957 /*
6958  * ALC260 configurations
6959  */
6960 static const char *alc260_models[ALC260_MODEL_LAST] = {
6961         [ALC260_BASIC]          = "basic",
6962         [ALC260_HP]             = "hp",
6963         [ALC260_HP_3013]        = "hp-3013",
6964         [ALC260_HP_DC7600]      = "hp-dc7600",
6965         [ALC260_FUJITSU_S702X]  = "fujitsu",
6966         [ALC260_ACER]           = "acer",
6967         [ALC260_WILL]           = "will",
6968         [ALC260_REPLACER_672V]  = "replacer",
6969         [ALC260_FAVORIT100]     = "favorit100",
6970 #ifdef CONFIG_SND_DEBUG
6971         [ALC260_TEST]           = "test",
6972 #endif
6973         [ALC260_AUTO]           = "auto",
6974 };
6975
6976 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6977         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6978         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6979         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6980         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6981         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6982         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6983         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6984         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6985         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6986         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6987         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6988         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6989         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6990         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6991         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6992         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6993         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6994         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6995         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6996         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6997         {}
6998 };
6999
7000 static struct alc_config_preset alc260_presets[] = {
7001         [ALC260_BASIC] = {
7002                 .mixers = { alc260_base_output_mixer,
7003                             alc260_input_mixer },
7004                 .init_verbs = { alc260_init_verbs },
7005                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7006                 .dac_nids = alc260_dac_nids,
7007                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7008                 .adc_nids = alc260_dual_adc_nids,
7009                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7010                 .channel_mode = alc260_modes,
7011                 .input_mux = &alc260_capture_source,
7012         },
7013         [ALC260_HP] = {
7014                 .mixers = { alc260_hp_output_mixer,
7015                             alc260_input_mixer },
7016                 .init_verbs = { alc260_init_verbs,
7017                                 alc260_hp_unsol_verbs },
7018                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7019                 .dac_nids = alc260_dac_nids,
7020                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7021                 .adc_nids = alc260_adc_nids_alt,
7022                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7023                 .channel_mode = alc260_modes,
7024                 .input_mux = &alc260_capture_source,
7025                 .unsol_event = alc260_hp_unsol_event,
7026                 .init_hook = alc260_hp_automute,
7027         },
7028         [ALC260_HP_DC7600] = {
7029                 .mixers = { alc260_hp_dc7600_mixer,
7030                             alc260_input_mixer },
7031                 .init_verbs = { alc260_init_verbs,
7032                                 alc260_hp_dc7600_verbs },
7033                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7034                 .dac_nids = alc260_dac_nids,
7035                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7036                 .adc_nids = alc260_adc_nids_alt,
7037                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7038                 .channel_mode = alc260_modes,
7039                 .input_mux = &alc260_capture_source,
7040                 .unsol_event = alc260_hp_3012_unsol_event,
7041                 .init_hook = alc260_hp_3012_automute,
7042         },
7043         [ALC260_HP_3013] = {
7044                 .mixers = { alc260_hp_3013_mixer,
7045                             alc260_input_mixer },
7046                 .init_verbs = { alc260_hp_3013_init_verbs,
7047                                 alc260_hp_3013_unsol_verbs },
7048                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7049                 .dac_nids = alc260_dac_nids,
7050                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7051                 .adc_nids = alc260_adc_nids_alt,
7052                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7053                 .channel_mode = alc260_modes,
7054                 .input_mux = &alc260_capture_source,
7055                 .unsol_event = alc260_hp_3013_unsol_event,
7056                 .init_hook = alc260_hp_3013_automute,
7057         },
7058         [ALC260_FUJITSU_S702X] = {
7059                 .mixers = { alc260_fujitsu_mixer },
7060                 .init_verbs = { alc260_fujitsu_init_verbs },
7061                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7062                 .dac_nids = alc260_dac_nids,
7063                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7064                 .adc_nids = alc260_dual_adc_nids,
7065                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7066                 .channel_mode = alc260_modes,
7067                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7068                 .input_mux = alc260_fujitsu_capture_sources,
7069         },
7070         [ALC260_ACER] = {
7071                 .mixers = { alc260_acer_mixer },
7072                 .init_verbs = { alc260_acer_init_verbs },
7073                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7074                 .dac_nids = alc260_dac_nids,
7075                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7076                 .adc_nids = alc260_dual_adc_nids,
7077                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7078                 .channel_mode = alc260_modes,
7079                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7080                 .input_mux = alc260_acer_capture_sources,
7081         },
7082         [ALC260_FAVORIT100] = {
7083                 .mixers = { alc260_favorit100_mixer },
7084                 .init_verbs = { alc260_favorit100_init_verbs },
7085                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7086                 .dac_nids = alc260_dac_nids,
7087                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7088                 .adc_nids = alc260_dual_adc_nids,
7089                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7090                 .channel_mode = alc260_modes,
7091                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7092                 .input_mux = alc260_favorit100_capture_sources,
7093         },
7094         [ALC260_WILL] = {
7095                 .mixers = { alc260_will_mixer },
7096                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7097                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7098                 .dac_nids = alc260_dac_nids,
7099                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7100                 .adc_nids = alc260_adc_nids,
7101                 .dig_out_nid = ALC260_DIGOUT_NID,
7102                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7103                 .channel_mode = alc260_modes,
7104                 .input_mux = &alc260_capture_source,
7105         },
7106         [ALC260_REPLACER_672V] = {
7107                 .mixers = { alc260_replacer_672v_mixer },
7108                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7109                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7110                 .dac_nids = alc260_dac_nids,
7111                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7112                 .adc_nids = alc260_adc_nids,
7113                 .dig_out_nid = ALC260_DIGOUT_NID,
7114                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7115                 .channel_mode = alc260_modes,
7116                 .input_mux = &alc260_capture_source,
7117                 .unsol_event = alc260_replacer_672v_unsol_event,
7118                 .init_hook = alc260_replacer_672v_automute,
7119         },
7120 #ifdef CONFIG_SND_DEBUG
7121         [ALC260_TEST] = {
7122                 .mixers = { alc260_test_mixer },
7123                 .init_verbs = { alc260_test_init_verbs },
7124                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7125                 .dac_nids = alc260_test_dac_nids,
7126                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7127                 .adc_nids = alc260_test_adc_nids,
7128                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7129                 .channel_mode = alc260_modes,
7130                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7131                 .input_mux = alc260_test_capture_sources,
7132         },
7133 #endif
7134 };
7135
7136 static int patch_alc260(struct hda_codec *codec)
7137 {
7138         struct alc_spec *spec;
7139         int err, board_config;
7140
7141         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7142         if (spec == NULL)
7143                 return -ENOMEM;
7144
7145         codec->spec = spec;
7146
7147         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7148                                                   alc260_models,
7149                                                   alc260_cfg_tbl);
7150         if (board_config < 0) {
7151                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7152                            codec->chip_name);
7153                 board_config = ALC260_AUTO;
7154         }
7155
7156         if (board_config == ALC260_AUTO)
7157                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7158
7159         if (board_config == ALC260_AUTO) {
7160                 /* automatic parse from the BIOS config */
7161                 err = alc260_parse_auto_config(codec);
7162                 if (err < 0) {
7163                         alc_free(codec);
7164                         return err;
7165                 } else if (!err) {
7166                         printk(KERN_INFO
7167                                "hda_codec: Cannot set up configuration "
7168                                "from BIOS.  Using base mode...\n");
7169                         board_config = ALC260_BASIC;
7170                 }
7171         }
7172
7173         err = snd_hda_attach_beep_device(codec, 0x1);
7174         if (err < 0) {
7175                 alc_free(codec);
7176                 return err;
7177         }
7178
7179         if (board_config != ALC260_AUTO)
7180                 setup_preset(codec, &alc260_presets[board_config]);
7181
7182         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7183         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7184         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7185
7186         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7187         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7188
7189         if (!spec->adc_nids && spec->input_mux) {
7190                 /* check whether NID 0x04 is valid */
7191                 unsigned int wcap = get_wcaps(codec, 0x04);
7192                 wcap = get_wcaps_type(wcap);
7193                 /* get type */
7194                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7195                         spec->adc_nids = alc260_adc_nids_alt;
7196                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7197                 } else {
7198                         spec->adc_nids = alc260_adc_nids;
7199                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7200                 }
7201         }
7202         set_capture_mixer(codec);
7203         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7204
7205         if (board_config == ALC260_AUTO)
7206                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7207
7208         spec->vmaster_nid = 0x08;
7209
7210         codec->patch_ops = alc_patch_ops;
7211         if (board_config == ALC260_AUTO)
7212                 spec->init_hook = alc260_auto_init;
7213 #ifdef CONFIG_SND_HDA_POWER_SAVE
7214         if (!spec->loopback.amplist)
7215                 spec->loopback.amplist = alc260_loopbacks;
7216 #endif
7217
7218         return 0;
7219 }
7220
7221
7222 /*
7223  * ALC882/883/885/888/889 support
7224  *
7225  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7226  * configuration.  Each pin widget can choose any input DACs and a mixer.
7227  * Each ADC is connected from a mixer of all inputs.  This makes possible
7228  * 6-channel independent captures.
7229  *
7230  * In addition, an independent DAC for the multi-playback (not used in this
7231  * driver yet).
7232  */
7233 #define ALC882_DIGOUT_NID       0x06
7234 #define ALC882_DIGIN_NID        0x0a
7235 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7236 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7237 #define ALC1200_DIGOUT_NID      0x10
7238
7239
7240 static struct hda_channel_mode alc882_ch_modes[1] = {
7241         { 8, NULL }
7242 };
7243
7244 /* DACs */
7245 static hda_nid_t alc882_dac_nids[4] = {
7246         /* front, rear, clfe, rear_surr */
7247         0x02, 0x03, 0x04, 0x05
7248 };
7249 #define alc883_dac_nids         alc882_dac_nids
7250
7251 /* ADCs */
7252 #define alc882_adc_nids         alc880_adc_nids
7253 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7254 #define alc883_adc_nids         alc882_adc_nids_alt
7255 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7256 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7257 #define alc889_adc_nids         alc880_adc_nids
7258
7259 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7260 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7261 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7262 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7263 #define alc889_capsrc_nids      alc882_capsrc_nids
7264
7265 /* input MUX */
7266 /* FIXME: should be a matrix-type input source selection */
7267
7268 static struct hda_input_mux alc882_capture_source = {
7269         .num_items = 4,
7270         .items = {
7271                 { "Mic", 0x0 },
7272                 { "Front Mic", 0x1 },
7273                 { "Line", 0x2 },
7274                 { "CD", 0x4 },
7275         },
7276 };
7277
7278 #define alc883_capture_source   alc882_capture_source
7279
7280 static struct hda_input_mux alc889_capture_source = {
7281         .num_items = 3,
7282         .items = {
7283                 { "Front Mic", 0x0 },
7284                 { "Mic", 0x3 },
7285                 { "Line", 0x2 },
7286         },
7287 };
7288
7289 static struct hda_input_mux mb5_capture_source = {
7290         .num_items = 3,
7291         .items = {
7292                 { "Mic", 0x1 },
7293                 { "Line", 0x7 },
7294                 { "CD", 0x4 },
7295         },
7296 };
7297
7298 static struct hda_input_mux macmini3_capture_source = {
7299         .num_items = 2,
7300         .items = {
7301                 { "Line", 0x2 },
7302                 { "CD", 0x4 },
7303         },
7304 };
7305
7306 static struct hda_input_mux alc883_3stack_6ch_intel = {
7307         .num_items = 4,
7308         .items = {
7309                 { "Mic", 0x1 },
7310                 { "Front Mic", 0x0 },
7311                 { "Line", 0x2 },
7312                 { "CD", 0x4 },
7313         },
7314 };
7315
7316 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7317         .num_items = 2,
7318         .items = {
7319                 { "Mic", 0x1 },
7320                 { "Line", 0x2 },
7321         },
7322 };
7323
7324 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7325         .num_items = 4,
7326         .items = {
7327                 { "Mic", 0x0 },
7328                 { "Int Mic", 0x1 },
7329                 { "Line", 0x2 },
7330                 { "CD", 0x4 },
7331         },
7332 };
7333
7334 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7335         .num_items = 2,
7336         .items = {
7337                 { "Mic", 0x0 },
7338                 { "Int Mic", 0x1 },
7339         },
7340 };
7341
7342 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7343         .num_items = 3,
7344         .items = {
7345                 { "Mic", 0x0 },
7346                 { "Front Mic", 0x1 },
7347                 { "Line", 0x4 },
7348         },
7349 };
7350
7351 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7352         .num_items = 2,
7353         .items = {
7354                 { "Mic", 0x0 },
7355                 { "Line", 0x2 },
7356         },
7357 };
7358
7359 static struct hda_input_mux alc889A_mb31_capture_source = {
7360         .num_items = 2,
7361         .items = {
7362                 { "Mic", 0x0 },
7363                 /* Front Mic (0x01) unused */
7364                 { "Line", 0x2 },
7365                 /* Line 2 (0x03) unused */
7366                 /* CD (0x04) unused? */
7367         },
7368 };
7369
7370 static struct hda_input_mux alc889A_imac91_capture_source = {
7371         .num_items = 2,
7372         .items = {
7373                 { "Mic", 0x01 },
7374                 { "Line", 0x2 }, /* Not sure! */
7375         },
7376 };
7377
7378 /*
7379  * 2ch mode
7380  */
7381 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7382         { 2, NULL }
7383 };
7384
7385 /*
7386  * 2ch mode
7387  */
7388 static struct hda_verb alc882_3ST_ch2_init[] = {
7389         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7390         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7391         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7392         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7393         { } /* end */
7394 };
7395
7396 /*
7397  * 4ch mode
7398  */
7399 static struct hda_verb alc882_3ST_ch4_init[] = {
7400         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7401         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7402         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7403         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7404         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7405         { } /* end */
7406 };
7407
7408 /*
7409  * 6ch mode
7410  */
7411 static struct hda_verb alc882_3ST_ch6_init[] = {
7412         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7413         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7414         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7415         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7416         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7417         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7418         { } /* end */
7419 };
7420
7421 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7422         { 2, alc882_3ST_ch2_init },
7423         { 4, alc882_3ST_ch4_init },
7424         { 6, alc882_3ST_ch6_init },
7425 };
7426
7427 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7428
7429 /*
7430  * 2ch mode
7431  */
7432 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7433         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7434         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7435         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7436         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7437         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7438         { } /* end */
7439 };
7440
7441 /*
7442  * 4ch mode
7443  */
7444 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7445         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7446         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7447         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7448         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7449         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7450         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7451         { } /* end */
7452 };
7453
7454 /*
7455  * 6ch mode
7456  */
7457 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7458         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7459         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7460         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7461         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7462         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7463         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7464         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7465         { } /* end */
7466 };
7467
7468 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7469         { 2, alc883_3ST_ch2_clevo_init },
7470         { 4, alc883_3ST_ch4_clevo_init },
7471         { 6, alc883_3ST_ch6_clevo_init },
7472 };
7473
7474
7475 /*
7476  * 6ch mode
7477  */
7478 static struct hda_verb alc882_sixstack_ch6_init[] = {
7479         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7480         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7481         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7482         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7483         { } /* end */
7484 };
7485
7486 /*
7487  * 8ch mode
7488  */
7489 static struct hda_verb alc882_sixstack_ch8_init[] = {
7490         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7491         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7492         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7493         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7494         { } /* end */
7495 };
7496
7497 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7498         { 6, alc882_sixstack_ch6_init },
7499         { 8, alc882_sixstack_ch8_init },
7500 };
7501
7502
7503 /* Macbook Air 2,1 */
7504
7505 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7506       { 2, NULL },
7507 };
7508
7509 /*
7510  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7511  */
7512
7513 /*
7514  * 2ch mode
7515  */
7516 static struct hda_verb alc885_mbp_ch2_init[] = {
7517         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7518         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7519         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7520         { } /* end */
7521 };
7522
7523 /*
7524  * 4ch mode
7525  */
7526 static struct hda_verb alc885_mbp_ch4_init[] = {
7527         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7528         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7529         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7530         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7531         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7532         { } /* end */
7533 };
7534
7535 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7536         { 2, alc885_mbp_ch2_init },
7537         { 4, alc885_mbp_ch4_init },
7538 };
7539
7540 /*
7541  * 2ch
7542  * Speakers/Woofer/HP = Front
7543  * LineIn = Input
7544  */
7545 static struct hda_verb alc885_mb5_ch2_init[] = {
7546         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7547         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7548         { } /* end */
7549 };
7550
7551 /*
7552  * 6ch mode
7553  * Speakers/HP = Front
7554  * Woofer = LFE
7555  * LineIn = Surround
7556  */
7557 static struct hda_verb alc885_mb5_ch6_init[] = {
7558         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7559         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7560         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7561         { } /* end */
7562 };
7563
7564 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7565         { 2, alc885_mb5_ch2_init },
7566         { 6, alc885_mb5_ch6_init },
7567 };
7568
7569 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7570
7571 /*
7572  * 2ch mode
7573  */
7574 static struct hda_verb alc883_4ST_ch2_init[] = {
7575         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7576         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7577         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7578         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7579         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7580         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7581         { } /* end */
7582 };
7583
7584 /*
7585  * 4ch mode
7586  */
7587 static struct hda_verb alc883_4ST_ch4_init[] = {
7588         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7589         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7590         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7591         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7592         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7593         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7594         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7595         { } /* end */
7596 };
7597
7598 /*
7599  * 6ch mode
7600  */
7601 static struct hda_verb alc883_4ST_ch6_init[] = {
7602         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7603         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7604         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7605         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7606         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7607         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7608         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7609         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7610         { } /* end */
7611 };
7612
7613 /*
7614  * 8ch mode
7615  */
7616 static struct hda_verb alc883_4ST_ch8_init[] = {
7617         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7618         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7619         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7620         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7621         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7622         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7623         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7624         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7625         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7626         { } /* end */
7627 };
7628
7629 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7630         { 2, alc883_4ST_ch2_init },
7631         { 4, alc883_4ST_ch4_init },
7632         { 6, alc883_4ST_ch6_init },
7633         { 8, alc883_4ST_ch8_init },
7634 };
7635
7636
7637 /*
7638  * 2ch mode
7639  */
7640 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7641         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7642         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7643         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7644         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7645         { } /* end */
7646 };
7647
7648 /*
7649  * 4ch mode
7650  */
7651 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7652         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7653         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7654         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7655         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7656         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7657         { } /* end */
7658 };
7659
7660 /*
7661  * 6ch mode
7662  */
7663 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7664         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7665         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7666         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7667         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7668         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7669         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7670         { } /* end */
7671 };
7672
7673 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7674         { 2, alc883_3ST_ch2_intel_init },
7675         { 4, alc883_3ST_ch4_intel_init },
7676         { 6, alc883_3ST_ch6_intel_init },
7677 };
7678
7679 /*
7680  * 2ch mode
7681  */
7682 static struct hda_verb alc889_ch2_intel_init[] = {
7683         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7684         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7685         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7686         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7687         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7688         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7689         { } /* end */
7690 };
7691
7692 /*
7693  * 6ch mode
7694  */
7695 static struct hda_verb alc889_ch6_intel_init[] = {
7696         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7697         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7698         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7699         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7700         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7701         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7702         { } /* end */
7703 };
7704
7705 /*
7706  * 8ch mode
7707  */
7708 static struct hda_verb alc889_ch8_intel_init[] = {
7709         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7710         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7711         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7712         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7713         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7714         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7715         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7716         { } /* end */
7717 };
7718
7719 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7720         { 2, alc889_ch2_intel_init },
7721         { 6, alc889_ch6_intel_init },
7722         { 8, alc889_ch8_intel_init },
7723 };
7724
7725 /*
7726  * 6ch mode
7727  */
7728 static struct hda_verb alc883_sixstack_ch6_init[] = {
7729         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7730         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7731         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7732         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7733         { } /* end */
7734 };
7735
7736 /*
7737  * 8ch mode
7738  */
7739 static struct hda_verb alc883_sixstack_ch8_init[] = {
7740         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7741         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7742         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7743         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7744         { } /* end */
7745 };
7746
7747 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7748         { 6, alc883_sixstack_ch6_init },
7749         { 8, alc883_sixstack_ch8_init },
7750 };
7751
7752
7753 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7754  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7755  */
7756 static struct snd_kcontrol_new alc882_base_mixer[] = {
7757         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7758         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7759         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7760         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7761         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7762         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7763         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7764         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7765         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7766         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7767         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7768         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7769         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7770         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7771         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7772         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7773         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7774         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7775         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7776         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7777         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7778         { } /* end */
7779 };
7780
7781 /* Macbook Air 2,1 same control for HP and internal Speaker */
7782
7783 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7784       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7785       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7786      { }
7787 };
7788
7789
7790 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7791         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7792         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7793         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7794         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7795         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7796         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7797         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7798         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7799         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7800         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7801         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7802         { } /* end */
7803 };
7804
7805 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7806         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7807         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7808         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7809         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7810         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7811         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7812         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7813         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7814         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7815         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7816         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7817         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7818         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7819         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7820         { } /* end */
7821 };
7822
7823 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7824         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7825         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7826         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7827         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7828         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7829         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7830         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7831         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7832         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7833         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7834         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7835         { } /* end */
7836 };
7837
7838 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7839         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7840         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7841         { } /* end */
7842 };
7843
7844
7845 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7846         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7847         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7848         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7849         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7850         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7851         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7852         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7853         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7854         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7855         { } /* end */
7856 };
7857
7858 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7859         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7860         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7861         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7862         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7863         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7864         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7865         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7866         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7867         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7868         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7869         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7870         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7871         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7872         { } /* end */
7873 };
7874
7875 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7876  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7877  */
7878 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7880         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7881         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7882         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7883         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7884         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7885         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7886         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7887         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7888         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7889         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7890         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7891         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7892         { } /* end */
7893 };
7894
7895 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7896         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7897         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7898         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7899         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7900         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7901         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7902         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7903         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7904         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7905         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7906         { } /* end */
7907 };
7908
7909 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7910         {
7911                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7912                 .name = "Channel Mode",
7913                 .info = alc_ch_mode_info,
7914                 .get = alc_ch_mode_get,
7915                 .put = alc_ch_mode_put,
7916         },
7917         { } /* end */
7918 };
7919
7920 static struct hda_verb alc882_base_init_verbs[] = {
7921         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7922         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7923         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7924         /* Rear mixer */
7925         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7926         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7927         /* CLFE mixer */
7928         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7929         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7930         /* Side mixer */
7931         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7932         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7933
7934         /* Front Pin: output 0 (0x0c) */
7935         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7936         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7937         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7938         /* Rear Pin: output 1 (0x0d) */
7939         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7940         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7941         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7942         /* CLFE Pin: output 2 (0x0e) */
7943         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7944         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7945         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7946         /* Side Pin: output 3 (0x0f) */
7947         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7948         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7949         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7950         /* Mic (rear) pin: input vref at 80% */
7951         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7952         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7953         /* Front Mic pin: input vref at 80% */
7954         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7955         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7956         /* Line In pin: input */
7957         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7958         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7959         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7960         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7961         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7962         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7963         /* CD pin widget for input */
7964         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7965
7966         /* FIXME: use matrix-type input source selection */
7967         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7968         /* Input mixer2 */
7969         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7970         /* Input mixer3 */
7971         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7972         /* ADC2: mute amp left and right */
7973         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7974         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7975         /* ADC3: mute amp left and right */
7976         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7977         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7978
7979         { }
7980 };
7981
7982 static struct hda_verb alc882_adc1_init_verbs[] = {
7983         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7984         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7985         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7986         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7987         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7988         /* ADC1: mute amp left and right */
7989         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7990         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7991         { }
7992 };
7993
7994 static struct hda_verb alc882_eapd_verbs[] = {
7995         /* change to EAPD mode */
7996         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7997         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7998         { }
7999 };
8000
8001 static struct hda_verb alc889_eapd_verbs[] = {
8002         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8003         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8004         { }
8005 };
8006
8007 static struct hda_verb alc_hp15_unsol_verbs[] = {
8008         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8009         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8010         {}
8011 };
8012
8013 static struct hda_verb alc885_init_verbs[] = {
8014         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8015         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8016         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8017         /* Rear mixer */
8018         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8019         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8020         /* CLFE mixer */
8021         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8022         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8023         /* Side mixer */
8024         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8025         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8026
8027         /* Front HP Pin: output 0 (0x0c) */
8028         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8029         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8030         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8031         /* Front Pin: output 0 (0x0c) */
8032         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8033         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8034         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8035         /* Rear Pin: output 1 (0x0d) */
8036         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8037         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8038         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8039         /* CLFE Pin: output 2 (0x0e) */
8040         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8041         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8042         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8043         /* Side Pin: output 3 (0x0f) */
8044         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8045         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8046         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8047         /* Mic (rear) pin: input vref at 80% */
8048         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8049         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8050         /* Front Mic pin: input vref at 80% */
8051         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8052         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8053         /* Line In pin: input */
8054         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8055         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8056
8057         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8058         /* Input mixer1 */
8059         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8060         /* Input mixer2 */
8061         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8062         /* Input mixer3 */
8063         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8064         /* ADC2: mute amp left and right */
8065         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8066         /* ADC3: mute amp left and right */
8067         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8068
8069         { }
8070 };
8071
8072 static struct hda_verb alc885_init_input_verbs[] = {
8073         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8074         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8075         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8076         { }
8077 };
8078
8079
8080 /* Unmute Selector 24h and set the default input to front mic */
8081 static struct hda_verb alc889_init_input_verbs[] = {
8082         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8083         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8084         { }
8085 };
8086
8087
8088 #define alc883_init_verbs       alc882_base_init_verbs
8089
8090 /* Mac Pro test */
8091 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8092         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8093         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8094         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8095         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8096         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8097         /* FIXME: this looks suspicious...
8098         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8099         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8100         */
8101         { } /* end */
8102 };
8103
8104 static struct hda_verb alc882_macpro_init_verbs[] = {
8105         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8106         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8107         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8108         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8109         /* Front Pin: output 0 (0x0c) */
8110         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8111         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8112         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8113         /* Front Mic pin: input vref at 80% */
8114         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8115         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8116         /* Speaker:  output */
8117         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8118         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8119         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8120         /* Headphone output (output 0 - 0x0c) */
8121         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8122         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8123         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8124
8125         /* FIXME: use matrix-type input source selection */
8126         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8127         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8128         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8129         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8130         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8131         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8132         /* Input mixer2 */
8133         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8134         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8135         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8136         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8137         /* Input mixer3 */
8138         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8139         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8140         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8141         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8142         /* ADC1: mute amp left and right */
8143         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8144         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8145         /* ADC2: mute amp left and right */
8146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8147         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8148         /* ADC3: mute amp left and right */
8149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8150         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8151
8152         { }
8153 };
8154
8155 /* Macbook 5,1 */
8156 static struct hda_verb alc885_mb5_init_verbs[] = {
8157         /* DACs */
8158         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8159         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8160         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8161         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8162         /* Front mixer */
8163         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8164         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8165         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8166         /* Surround mixer */
8167         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8168         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8169         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8170         /* LFE mixer */
8171         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8172         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8173         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8174         /* HP mixer */
8175         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8176         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8177         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8178         /* Front Pin (0x0c) */
8179         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8180         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8181         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8182         /* LFE Pin (0x0e) */
8183         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8184         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8185         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8186         /* HP Pin (0x0f) */
8187         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8188         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8189         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8190         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8191         /* Front Mic pin: input vref at 80% */
8192         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8193         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8194         /* Line In pin */
8195         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8196         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8197
8198         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8199         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8200         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8201         { }
8202 };
8203
8204 /* Macmini 3,1 */
8205 static struct hda_verb alc885_macmini3_init_verbs[] = {
8206         /* DACs */
8207         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8208         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8209         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8210         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8211         /* Front mixer */
8212         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8213         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8214         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8215         /* Surround mixer */
8216         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8217         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8218         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8219         /* LFE mixer */
8220         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8221         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8222         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8223         /* HP mixer */
8224         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8225         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8226         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8227         /* Front Pin (0x0c) */
8228         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8229         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8230         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8231         /* LFE Pin (0x0e) */
8232         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8233         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8234         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8235         /* HP Pin (0x0f) */
8236         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8237         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8238         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8239         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8240         /* Line In pin */
8241         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8242         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8243
8244         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8245         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8246         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8247         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8248         { }
8249 };
8250
8251
8252 static struct hda_verb alc885_mba21_init_verbs[] = {
8253         /*Internal and HP Speaker Mixer*/
8254         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8255         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8256         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8257         /*Internal Speaker Pin (0x0c)*/
8258         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8259         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8260         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8261         /* HP Pin: output 0 (0x0e) */
8262         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8263         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8264         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8265         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8266         /* Line in (is hp when jack connected)*/
8267         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8268         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8269
8270         { }
8271  };
8272
8273
8274 /* Macbook Pro rev3 */
8275 static struct hda_verb alc885_mbp3_init_verbs[] = {
8276         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8277         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8278         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8279         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8280         /* Rear mixer */
8281         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8282         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8283         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8284         /* HP mixer */
8285         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8286         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8287         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8288         /* Front Pin: output 0 (0x0c) */
8289         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8290         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8291         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8292         /* HP Pin: output 0 (0x0e) */
8293         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8294         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8295         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8296         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8297         /* Mic (rear) pin: input vref at 80% */
8298         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8299         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8300         /* Front Mic pin: input vref at 80% */
8301         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8302         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8303         /* Line In pin: use output 1 when in LineOut mode */
8304         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8305         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8306         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8307
8308         /* FIXME: use matrix-type input source selection */
8309         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8310         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8311         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8312         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8313         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8314         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8315         /* Input mixer2 */
8316         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8317         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8318         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8319         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8320         /* Input mixer3 */
8321         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8322         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8323         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8324         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8325         /* ADC1: mute amp left and right */
8326         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8327         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8328         /* ADC2: mute amp left and right */
8329         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8330         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8331         /* ADC3: mute amp left and right */
8332         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8333         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8334
8335         { }
8336 };
8337
8338 /* iMac 9,1 */
8339 static struct hda_verb alc885_imac91_init_verbs[] = {
8340         /* Internal Speaker Pin (0x0c) */
8341         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8342         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8343         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8344         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8345         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8346         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8347         /* HP Pin: Rear */
8348         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8349         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8350         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8351         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8352         /* Line in Rear */
8353         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8354         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8355         /* Front Mic pin: input vref at 80% */
8356         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8357         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8358         /* Rear mixer */
8359         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8360         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8361         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8362         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8363         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8364         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8365         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8366         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8367         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8368         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8369         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8371         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8372         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8373         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8374         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8375         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8376         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8377         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8378         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8379         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8380         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8381         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8382         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8383         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8384         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8385         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8386         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8387         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8388         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8389         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8390         { }
8391 };
8392
8393 /* iMac 24 mixer. */
8394 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8395         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8396         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8397         { } /* end */
8398 };
8399
8400 /* iMac 24 init verbs. */
8401 static struct hda_verb alc885_imac24_init_verbs[] = {
8402         /* Internal speakers: output 0 (0x0c) */
8403         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8404         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8405         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8406         /* Internal speakers: output 0 (0x0c) */
8407         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8408         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8409         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8410         /* Headphone: output 0 (0x0c) */
8411         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8412         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8413         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8414         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8415         /* Front Mic: input vref at 80% */
8416         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8417         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8418         { }
8419 };
8420
8421 /* Toggle speaker-output according to the hp-jack state */
8422 static void alc885_imac24_setup(struct hda_codec *codec)
8423 {
8424         struct alc_spec *spec = codec->spec;
8425
8426         spec->autocfg.hp_pins[0] = 0x14;
8427         spec->autocfg.speaker_pins[0] = 0x18;
8428         spec->autocfg.speaker_pins[1] = 0x1a;
8429 }
8430
8431 #define alc885_mb5_setup        alc885_imac24_setup
8432 #define alc885_macmini3_setup   alc885_imac24_setup
8433
8434 /* Macbook Air 2,1 */
8435 static void alc885_mba21_setup(struct hda_codec *codec)
8436 {
8437        struct alc_spec *spec = codec->spec;
8438
8439        spec->autocfg.hp_pins[0] = 0x14;
8440        spec->autocfg.speaker_pins[0] = 0x18;
8441 }
8442
8443
8444
8445 static void alc885_mbp3_setup(struct hda_codec *codec)
8446 {
8447         struct alc_spec *spec = codec->spec;
8448
8449         spec->autocfg.hp_pins[0] = 0x15;
8450         spec->autocfg.speaker_pins[0] = 0x14;
8451 }
8452
8453 static void alc885_imac91_setup(struct hda_codec *codec)
8454 {
8455         struct alc_spec *spec = codec->spec;
8456
8457         spec->autocfg.hp_pins[0] = 0x14;
8458         spec->autocfg.speaker_pins[0] = 0x18;
8459         spec->autocfg.speaker_pins[1] = 0x1a;
8460 }
8461
8462 static struct hda_verb alc882_targa_verbs[] = {
8463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8464         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8465
8466         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8467         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8468
8469         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8470         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8471         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8472
8473         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8474         { } /* end */
8475 };
8476
8477 /* toggle speaker-output according to the hp-jack state */
8478 static void alc882_targa_automute(struct hda_codec *codec)
8479 {
8480         struct alc_spec *spec = codec->spec;
8481         alc_automute_amp(codec);
8482         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8483                                   spec->jack_present ? 1 : 3);
8484 }
8485
8486 static void alc882_targa_setup(struct hda_codec *codec)
8487 {
8488         struct alc_spec *spec = codec->spec;
8489
8490         spec->autocfg.hp_pins[0] = 0x14;
8491         spec->autocfg.speaker_pins[0] = 0x1b;
8492 }
8493
8494 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8495 {
8496         if ((res >> 26) == ALC880_HP_EVENT)
8497                 alc882_targa_automute(codec);
8498 }
8499
8500 static struct hda_verb alc882_asus_a7j_verbs[] = {
8501         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8502         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8503
8504         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8505         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8506         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8507
8508         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8509         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8510         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8511
8512         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8513         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8514         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8515         { } /* end */
8516 };
8517
8518 static struct hda_verb alc882_asus_a7m_verbs[] = {
8519         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8520         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8521
8522         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8523         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8524         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8525
8526         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8527         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8528         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8529
8530         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8531         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8532         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8533         { } /* end */
8534 };
8535
8536 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8537 {
8538         unsigned int gpiostate, gpiomask, gpiodir;
8539
8540         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8541                                        AC_VERB_GET_GPIO_DATA, 0);
8542
8543         if (!muted)
8544                 gpiostate |= (1 << pin);
8545         else
8546                 gpiostate &= ~(1 << pin);
8547
8548         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8549                                       AC_VERB_GET_GPIO_MASK, 0);
8550         gpiomask |= (1 << pin);
8551
8552         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8553                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8554         gpiodir |= (1 << pin);
8555
8556
8557         snd_hda_codec_write(codec, codec->afg, 0,
8558                             AC_VERB_SET_GPIO_MASK, gpiomask);
8559         snd_hda_codec_write(codec, codec->afg, 0,
8560                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8561
8562         msleep(1);
8563
8564         snd_hda_codec_write(codec, codec->afg, 0,
8565                             AC_VERB_SET_GPIO_DATA, gpiostate);
8566 }
8567
8568 /* set up GPIO at initialization */
8569 static void alc885_macpro_init_hook(struct hda_codec *codec)
8570 {
8571         alc882_gpio_mute(codec, 0, 0);
8572         alc882_gpio_mute(codec, 1, 0);
8573 }
8574
8575 /* set up GPIO and update auto-muting at initialization */
8576 static void alc885_imac24_init_hook(struct hda_codec *codec)
8577 {
8578         alc885_macpro_init_hook(codec);
8579         alc_automute_amp(codec);
8580 }
8581
8582 /*
8583  * generic initialization of ADC, input mixers and output mixers
8584  */
8585 static struct hda_verb alc883_auto_init_verbs[] = {
8586         /*
8587          * Unmute ADC0-2 and set the default input to mic-in
8588          */
8589         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8590         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8591         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8592         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8593
8594         /*
8595          * Set up output mixers (0x0c - 0x0f)
8596          */
8597         /* set vol=0 to output mixers */
8598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8599         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8600         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8601         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8602         /* set up input amps for analog loopback */
8603         /* Amp Indices: DAC = 0, mixer = 1 */
8604         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8605         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8606         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8607         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8608         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8609         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8610         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8611         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8612         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8613         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8614
8615         /* FIXME: use matrix-type input source selection */
8616         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8617         /* Input mixer2 */
8618         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8619         /* Input mixer3 */
8620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8621         { }
8622 };
8623
8624 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8625 static struct hda_verb alc889A_mb31_ch2_init[] = {
8626         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8627         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8628         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8629         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8630         { } /* end */
8631 };
8632
8633 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8634 static struct hda_verb alc889A_mb31_ch4_init[] = {
8635         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8636         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8637         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8638         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8639         { } /* end */
8640 };
8641
8642 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8643 static struct hda_verb alc889A_mb31_ch5_init[] = {
8644         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8645         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8646         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8647         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8648         { } /* end */
8649 };
8650
8651 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8652 static struct hda_verb alc889A_mb31_ch6_init[] = {
8653         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8654         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8655         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8656         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8657         { } /* end */
8658 };
8659
8660 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8661         { 2, alc889A_mb31_ch2_init },
8662         { 4, alc889A_mb31_ch4_init },
8663         { 5, alc889A_mb31_ch5_init },
8664         { 6, alc889A_mb31_ch6_init },
8665 };
8666
8667 static struct hda_verb alc883_medion_eapd_verbs[] = {
8668         /* eanable EAPD on medion laptop */
8669         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8670         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8671         { }
8672 };
8673
8674 #define alc883_base_mixer       alc882_base_mixer
8675
8676 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8677         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8678         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8679         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8680         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8681         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8682         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8683         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8684         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8685         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8686         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8687         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8688         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8689         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8690         { } /* end */
8691 };
8692
8693 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8694         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8695         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8696         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8697         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8698         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8699         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8700         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8701         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8702         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8703         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8704         { } /* end */
8705 };
8706
8707 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8708         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8709         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8710         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8711         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8712         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8713         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8714         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8715         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8716         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8717         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8718         { } /* end */
8719 };
8720
8721 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8722         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8723         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8724         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8725         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8726         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8727         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8728         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8729         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8730         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8731         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8732         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8733         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8734         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8735         { } /* end */
8736 };
8737
8738 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8739         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8740         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8741         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8742         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8743         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8744         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8745         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8746         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8747         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8748         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8749         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8750         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8751         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8752         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8753         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8754         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8755         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8756         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8757         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8758         { } /* end */
8759 };
8760
8761 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8762         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8763         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8764         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8765         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8766         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8767                               HDA_OUTPUT),
8768         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8769         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8770         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8771         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8772         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8773         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8774         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8775         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8776         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8777         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8778         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8779         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8780         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8781         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8782         { } /* end */
8783 };
8784
8785 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8786         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8787         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8788         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8789         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8790         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8791                               HDA_OUTPUT),
8792         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8793         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8794         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8795         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8796         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8797         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8798         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8799         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8800         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8801         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8802         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8803         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8804         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8805         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8806         { } /* end */
8807 };
8808
8809 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8810         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8811         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8812         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8813         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8814         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8815         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8816         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8817         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8818         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8819         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8820         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8821         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8822         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8823         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8824         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8825         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8826         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8827         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8828         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8829         { } /* end */
8830 };
8831
8832 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8833         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8834         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8835         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8836         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8837         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8838         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8839         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8840         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8841         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8842         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8843         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8844         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8845         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8846         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8847         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8848         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8849         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8850         { } /* end */
8851 };
8852
8853 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8854         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8855         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8856         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8857         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8858         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8859         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8860         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8861         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8862         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8863         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8864         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8865         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8866         { } /* end */
8867 };
8868
8869 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8870         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8871         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8872         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8873         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8874         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8875         { } /* end */
8876 };
8877
8878 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8880         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8881         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8882         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8883         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8884         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8885         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8886         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8887         { } /* end */
8888 };
8889
8890 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8891         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8892         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8893         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8894         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8895         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8896         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8897         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8898         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8899         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8900         { } /* end */
8901 };
8902
8903 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8904         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8905         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8906         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8907         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8908         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8909         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8910         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8911         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8912         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8913         { } /* end */
8914 };
8915
8916 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
8917         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8918         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8919         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8920         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
8921         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
8922         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
8923         { } /* end */
8924 };
8925
8926 static struct hda_verb alc883_medion_wim2160_verbs[] = {
8927         /* Unmute front mixer */
8928         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8929         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8930
8931         /* Set speaker pin to front mixer */
8932         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8933
8934         /* Init headphone pin */
8935         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8936         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8937         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8938         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8939
8940         { } /* end */
8941 };
8942
8943 /* toggle speaker-output according to the hp-jack state */
8944 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
8945 {
8946         struct alc_spec *spec = codec->spec;
8947
8948         spec->autocfg.hp_pins[0] = 0x1a;
8949         spec->autocfg.speaker_pins[0] = 0x15;
8950 }
8951
8952 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8953         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8954         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8955         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8956         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8957         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8958         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8959         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8960         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8961         { } /* end */
8962 };
8963
8964 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8965         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8966         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8967         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8968         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, 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("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8972         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8973         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8974         { } /* end */
8975 };
8976
8977 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8978         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8979         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8980         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8981         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8982         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8983                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8984         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8985         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8986         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8987         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8988         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8989         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8990         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8991         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8992         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8993         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8994         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8995         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8996         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8997         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8998         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8999         { } /* end */
9000 };
9001
9002 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9003         /* Output mixers */
9004         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9005         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9006         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9007         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9008         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9009                 HDA_OUTPUT),
9010         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9011         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9012         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9013         /* Output switches */
9014         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9015         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9016         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9017         /* Boost mixers */
9018         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
9019         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
9020         /* Input mixers */
9021         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9022         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9023         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9024         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9025         { } /* end */
9026 };
9027
9028 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9029         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9030         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9031         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9032         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9033         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9034         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9035         { } /* end */
9036 };
9037
9038 static struct hda_bind_ctls alc883_bind_cap_vol = {
9039         .ops = &snd_hda_bind_vol,
9040         .values = {
9041                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9042                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9043                 0
9044         },
9045 };
9046
9047 static struct hda_bind_ctls alc883_bind_cap_switch = {
9048         .ops = &snd_hda_bind_sw,
9049         .values = {
9050                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9051                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9052                 0
9053         },
9054 };
9055
9056 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9057         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9058         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9059         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9060         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9061         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9062         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9063         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9064         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9065         { } /* end */
9066 };
9067
9068 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9069         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9070         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9071         {
9072                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9073                 /* .name = "Capture Source", */
9074                 .name = "Input Source",
9075                 .count = 1,
9076                 .info = alc_mux_enum_info,
9077                 .get = alc_mux_enum_get,
9078                 .put = alc_mux_enum_put,
9079         },
9080         { } /* end */
9081 };
9082
9083 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9084         {
9085                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9086                 .name = "Channel Mode",
9087                 .info = alc_ch_mode_info,
9088                 .get = alc_ch_mode_get,
9089                 .put = alc_ch_mode_put,
9090         },
9091         { } /* end */
9092 };
9093
9094 /* toggle speaker-output according to the hp-jack state */
9095 static void alc883_mitac_setup(struct hda_codec *codec)
9096 {
9097         struct alc_spec *spec = codec->spec;
9098
9099         spec->autocfg.hp_pins[0] = 0x15;
9100         spec->autocfg.speaker_pins[0] = 0x14;
9101         spec->autocfg.speaker_pins[1] = 0x17;
9102 }
9103
9104 /* auto-toggle front mic */
9105 /*
9106 static void alc883_mitac_mic_automute(struct hda_codec *codec)
9107 {
9108         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
9109
9110         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
9111 }
9112 */
9113
9114 static struct hda_verb alc883_mitac_verbs[] = {
9115         /* HP */
9116         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9117         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9118         /* Subwoofer */
9119         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9120         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9121
9122         /* enable unsolicited event */
9123         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9124         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9125
9126         { } /* end */
9127 };
9128
9129 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9130         /* HP */
9131         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9132         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9133         /* Int speaker */
9134         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9135
9136         /* enable unsolicited event */
9137         /*
9138         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9139         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9140         */
9141
9142         { } /* end */
9143 };
9144
9145 static struct hda_verb alc883_clevo_m720_verbs[] = {
9146         /* HP */
9147         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9148         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9149         /* Int speaker */
9150         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9151         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9152
9153         /* enable unsolicited event */
9154         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9155         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9156
9157         { } /* end */
9158 };
9159
9160 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9161         /* HP */
9162         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9163         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9164         /* Subwoofer */
9165         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9166         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9167
9168         /* enable unsolicited event */
9169         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9170
9171         { } /* end */
9172 };
9173
9174 static struct hda_verb alc883_targa_verbs[] = {
9175         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9176         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9177
9178         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9179         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9180
9181 /* Connect Line-Out side jack (SPDIF) to Side */
9182         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9183         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9184         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9185 /* Connect Mic jack to CLFE */
9186         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9187         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9188         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9189 /* Connect Line-in jack to Surround */
9190         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9191         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9192         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9193 /* Connect HP out jack to Front */
9194         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9195         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9196         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9197
9198         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9199
9200         { } /* end */
9201 };
9202
9203 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9204         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9205         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9206         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9207         { } /* end */
9208 };
9209
9210 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9211         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9212         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9213         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9214         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9215         { } /* end */
9216 };
9217
9218 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9219         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9220         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9221         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9222         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9223         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9224         { } /* end */
9225 };
9226
9227 static struct hda_verb alc883_haier_w66_verbs[] = {
9228         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9229         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9230
9231         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9232
9233         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9234         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9235         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9236         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9237         { } /* end */
9238 };
9239
9240 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9241         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9242         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9243         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9244         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9245         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9246         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9247         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9248         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9249         { } /* end */
9250 };
9251
9252 static struct hda_verb alc888_6st_dell_verbs[] = {
9253         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9254         { }
9255 };
9256
9257 static struct hda_verb alc883_vaiott_verbs[] = {
9258         /* HP */
9259         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9260         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9261
9262         /* enable unsolicited event */
9263         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9264
9265         { } /* end */
9266 };
9267
9268 static void alc888_3st_hp_setup(struct hda_codec *codec)
9269 {
9270         struct alc_spec *spec = codec->spec;
9271
9272         spec->autocfg.hp_pins[0] = 0x1b;
9273         spec->autocfg.speaker_pins[0] = 0x14;
9274         spec->autocfg.speaker_pins[1] = 0x16;
9275         spec->autocfg.speaker_pins[2] = 0x18;
9276 }
9277
9278 static struct hda_verb alc888_3st_hp_verbs[] = {
9279         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9280         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9281         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9282         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9283         { } /* end */
9284 };
9285
9286 /*
9287  * 2ch mode
9288  */
9289 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9290         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9291         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9292         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9293         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9294         { } /* end */
9295 };
9296
9297 /*
9298  * 4ch mode
9299  */
9300 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9301         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9302         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9303         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9304         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9305         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9306         { } /* end */
9307 };
9308
9309 /*
9310  * 6ch mode
9311  */
9312 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9313         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9314         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9315         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9316         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9317         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9318         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9319         { } /* end */
9320 };
9321
9322 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9323         { 2, alc888_3st_hp_2ch_init },
9324         { 4, alc888_3st_hp_4ch_init },
9325         { 6, alc888_3st_hp_6ch_init },
9326 };
9327
9328 /* toggle front-jack and RCA according to the hp-jack state */
9329 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9330 {
9331         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9332
9333         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9334                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9335         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9336                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9337 }
9338
9339 /* toggle RCA according to the front-jack state */
9340 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9341 {
9342         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9343
9344         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9345                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9346 }
9347
9348 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9349                                              unsigned int res)
9350 {
9351         if ((res >> 26) == ALC880_HP_EVENT)
9352                 alc888_lenovo_ms7195_front_automute(codec);
9353         if ((res >> 26) == ALC880_FRONT_EVENT)
9354                 alc888_lenovo_ms7195_rca_automute(codec);
9355 }
9356
9357 static struct hda_verb alc883_medion_md2_verbs[] = {
9358         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9359         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9360
9361         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9362
9363         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9364         { } /* end */
9365 };
9366
9367 /* toggle speaker-output according to the hp-jack state */
9368 static void alc883_medion_md2_setup(struct hda_codec *codec)
9369 {
9370         struct alc_spec *spec = codec->spec;
9371
9372         spec->autocfg.hp_pins[0] = 0x14;
9373         spec->autocfg.speaker_pins[0] = 0x15;
9374 }
9375
9376 /* toggle speaker-output according to the hp-jack state */
9377 #define alc883_targa_init_hook          alc882_targa_init_hook
9378 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9379
9380 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
9381 {
9382         unsigned int present;
9383
9384         present = snd_hda_jack_detect(codec, 0x18);
9385         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
9386                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9387 }
9388
9389 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9390 {
9391         struct alc_spec *spec = codec->spec;
9392
9393         spec->autocfg.hp_pins[0] = 0x15;
9394         spec->autocfg.speaker_pins[0] = 0x14;
9395 }
9396
9397 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9398 {
9399         alc_automute_amp(codec);
9400         alc883_clevo_m720_mic_automute(codec);
9401 }
9402
9403 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9404                                            unsigned int res)
9405 {
9406         switch (res >> 26) {
9407         case ALC880_MIC_EVENT:
9408                 alc883_clevo_m720_mic_automute(codec);
9409                 break;
9410         default:
9411                 alc_automute_amp_unsol_event(codec, res);
9412                 break;
9413         }
9414 }
9415
9416 /* toggle speaker-output according to the hp-jack state */
9417 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9418 {
9419         struct alc_spec *spec = codec->spec;
9420
9421         spec->autocfg.hp_pins[0] = 0x14;
9422         spec->autocfg.speaker_pins[0] = 0x15;
9423 }
9424
9425 static void alc883_haier_w66_setup(struct hda_codec *codec)
9426 {
9427         struct alc_spec *spec = codec->spec;
9428
9429         spec->autocfg.hp_pins[0] = 0x1b;
9430         spec->autocfg.speaker_pins[0] = 0x14;
9431 }
9432
9433 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9434 {
9435         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9436
9437         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9438                                  HDA_AMP_MUTE, bits);
9439 }
9440
9441 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9442 {
9443         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9444
9445         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9446                                  HDA_AMP_MUTE, bits);
9447         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9448                                  HDA_AMP_MUTE, bits);
9449 }
9450
9451 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9452                                            unsigned int res)
9453 {
9454         if ((res >> 26) == ALC880_HP_EVENT)
9455                 alc883_lenovo_101e_all_automute(codec);
9456         if ((res >> 26) == ALC880_FRONT_EVENT)
9457                 alc883_lenovo_101e_ispeaker_automute(codec);
9458 }
9459
9460 /* toggle speaker-output according to the hp-jack state */
9461 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9462 {
9463         struct alc_spec *spec = codec->spec;
9464
9465         spec->autocfg.hp_pins[0] = 0x14;
9466         spec->autocfg.speaker_pins[0] = 0x15;
9467         spec->autocfg.speaker_pins[1] = 0x16;
9468 }
9469
9470 static struct hda_verb alc883_acer_eapd_verbs[] = {
9471         /* HP Pin: output 0 (0x0c) */
9472         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9473         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9474         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9475         /* Front Pin: output 0 (0x0c) */
9476         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9477         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9478         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9479         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9480         /* eanable EAPD on medion laptop */
9481         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9482         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9483         /* enable unsolicited event */
9484         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9485         { }
9486 };
9487
9488 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
9489         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9490         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9491         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9492         { } /* end */
9493 };
9494
9495 static void alc888_6st_dell_setup(struct hda_codec *codec)
9496 {
9497         struct alc_spec *spec = codec->spec;
9498
9499         spec->autocfg.hp_pins[0] = 0x1b;
9500         spec->autocfg.speaker_pins[0] = 0x14;
9501         spec->autocfg.speaker_pins[1] = 0x15;
9502         spec->autocfg.speaker_pins[2] = 0x16;
9503         spec->autocfg.speaker_pins[3] = 0x17;
9504 }
9505
9506 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9507 {
9508         struct alc_spec *spec = codec->spec;
9509
9510         spec->autocfg.hp_pins[0] = 0x1b;
9511         spec->autocfg.speaker_pins[0] = 0x14;
9512         spec->autocfg.speaker_pins[1] = 0x15;
9513         spec->autocfg.speaker_pins[2] = 0x16;
9514         spec->autocfg.speaker_pins[3] = 0x17;
9515         spec->autocfg.speaker_pins[4] = 0x1a;
9516 }
9517
9518 static void alc883_vaiott_setup(struct hda_codec *codec)
9519 {
9520         struct alc_spec *spec = codec->spec;
9521
9522         spec->autocfg.hp_pins[0] = 0x15;
9523         spec->autocfg.speaker_pins[0] = 0x14;
9524         spec->autocfg.speaker_pins[1] = 0x17;
9525 }
9526
9527 static struct hda_verb alc888_asus_m90v_verbs[] = {
9528         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9529         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9530         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9531         /* enable unsolicited event */
9532         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9533         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9534         { } /* end */
9535 };
9536
9537 static void alc883_mode2_setup(struct hda_codec *codec)
9538 {
9539         struct alc_spec *spec = codec->spec;
9540
9541         spec->autocfg.hp_pins[0] = 0x1b;
9542         spec->autocfg.speaker_pins[0] = 0x14;
9543         spec->autocfg.speaker_pins[1] = 0x15;
9544         spec->autocfg.speaker_pins[2] = 0x16;
9545         spec->ext_mic.pin = 0x18;
9546         spec->int_mic.pin = 0x19;
9547         spec->ext_mic.mux_idx = 0;
9548         spec->int_mic.mux_idx = 1;
9549         spec->auto_mic = 1;
9550 }
9551
9552 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9553         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9554         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9555         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9556         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9557         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9558         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9559         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9560         /* enable unsolicited event */
9561         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9562         { } /* end */
9563 };
9564
9565 static void alc883_eee1601_inithook(struct hda_codec *codec)
9566 {
9567         struct alc_spec *spec = codec->spec;
9568
9569         spec->autocfg.hp_pins[0] = 0x14;
9570         spec->autocfg.speaker_pins[0] = 0x1b;
9571         alc_automute_pin(codec);
9572 }
9573
9574 static struct hda_verb alc889A_mb31_verbs[] = {
9575         /* Init rear pin (used as headphone output) */
9576         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9577         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9578         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9579         /* Init line pin (used as output in 4ch and 6ch mode) */
9580         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9581         /* Init line 2 pin (used as headphone out by default) */
9582         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9583         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9584         { } /* end */
9585 };
9586
9587 /* Mute speakers according to the headphone jack state */
9588 static void alc889A_mb31_automute(struct hda_codec *codec)
9589 {
9590         unsigned int present;
9591
9592         /* Mute only in 2ch or 4ch mode */
9593         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9594             == 0x00) {
9595                 present = snd_hda_jack_detect(codec, 0x15);
9596                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9597                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9598                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9599                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9600         }
9601 }
9602
9603 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9604 {
9605         if ((res >> 26) == ALC880_HP_EVENT)
9606                 alc889A_mb31_automute(codec);
9607 }
9608
9609
9610 #ifdef CONFIG_SND_HDA_POWER_SAVE
9611 #define alc882_loopbacks        alc880_loopbacks
9612 #endif
9613
9614 /* pcm configuration: identical with ALC880 */
9615 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9616 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9617 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9618 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9619
9620 static hda_nid_t alc883_slave_dig_outs[] = {
9621         ALC1200_DIGOUT_NID, 0,
9622 };
9623
9624 static hda_nid_t alc1200_slave_dig_outs[] = {
9625         ALC883_DIGOUT_NID, 0,
9626 };
9627
9628 /*
9629  * configuration and preset
9630  */
9631 static const char *alc882_models[ALC882_MODEL_LAST] = {
9632         [ALC882_3ST_DIG]        = "3stack-dig",
9633         [ALC882_6ST_DIG]        = "6stack-dig",
9634         [ALC882_ARIMA]          = "arima",
9635         [ALC882_W2JC]           = "w2jc",
9636         [ALC882_TARGA]          = "targa",
9637         [ALC882_ASUS_A7J]       = "asus-a7j",
9638         [ALC882_ASUS_A7M]       = "asus-a7m",
9639         [ALC885_MACPRO]         = "macpro",
9640         [ALC885_MB5]            = "mb5",
9641         [ALC885_MACMINI3]       = "macmini3",
9642         [ALC885_MBA21]          = "mba21",
9643         [ALC885_MBP3]           = "mbp3",
9644         [ALC885_IMAC24]         = "imac24",
9645         [ALC885_IMAC91]         = "imac91",
9646         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9647         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9648         [ALC883_3ST_6ch]        = "3stack-6ch",
9649         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9650         [ALC883_TARGA_DIG]      = "targa-dig",
9651         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9652         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9653         [ALC883_ACER]           = "acer",
9654         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9655         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9656         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9657         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9658         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9659         [ALC883_MEDION]         = "medion",
9660         [ALC883_MEDION_MD2]     = "medion-md2",
9661         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9662         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9663         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9664         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9665         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9666         [ALC888_LENOVO_SKY] = "lenovo-sky",
9667         [ALC883_HAIER_W66]      = "haier-w66",
9668         [ALC888_3ST_HP]         = "3stack-hp",
9669         [ALC888_6ST_DELL]       = "6stack-dell",
9670         [ALC883_MITAC]          = "mitac",
9671         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9672         [ALC883_CLEVO_M720]     = "clevo-m720",
9673         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9674         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9675         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9676         [ALC889A_INTEL]         = "intel-alc889a",
9677         [ALC889_INTEL]          = "intel-x58",
9678         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9679         [ALC889A_MB31]          = "mb31",
9680         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9681         [ALC882_AUTO]           = "auto",
9682 };
9683
9684 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9685         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9686
9687         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9688         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9689         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9690         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9691         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9692         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9693         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9694                 ALC888_ACER_ASPIRE_4930G),
9695         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9696                 ALC888_ACER_ASPIRE_4930G),
9697         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9698                 ALC888_ACER_ASPIRE_8930G),
9699         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9700                 ALC888_ACER_ASPIRE_8930G),
9701         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9702         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9703         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9704                 ALC888_ACER_ASPIRE_6530G),
9705         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9706                 ALC888_ACER_ASPIRE_6530G),
9707         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9708                 ALC888_ACER_ASPIRE_7730G),
9709         /* default Acer -- disabled as it causes more problems.
9710          *    model=auto should work fine now
9711          */
9712         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9713
9714         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9715
9716         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9717         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9718         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9719         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9720         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9721         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9722
9723         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9724         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9725         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9726         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9727         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9728         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9729         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9730         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9731         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9732         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9733         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9734
9735         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9736         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9737         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9738         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9739         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9740         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9741         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9742         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9743         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9744
9745         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9746         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9747         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9748         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9749         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9750         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9751         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9752         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9753         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9754         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9755         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9756         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9757         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9758         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9759         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9760         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9761         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9762         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9763         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9764         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9765         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9766         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9767         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9768         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9769         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9770         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9771         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9772         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9773         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9774         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9775         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9776
9777         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9778         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9779         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9780         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9781         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9782         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9783         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9784         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9785         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9786         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9787                       ALC883_FUJITSU_PI2515),
9788         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9789                 ALC888_FUJITSU_XA3530),
9790         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9791         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9792         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9793         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9794         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9795         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9796         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9797         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9798         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9799
9800         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9801         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9802         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9803         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9804         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9805         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9806         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9807
9808         {}
9809 };
9810
9811 /* codec SSID table for Intel Mac */
9812 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9813         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9814         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9815         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9816         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9817         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9818         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9819         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9820         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9821         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9822         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9823         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9824         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9825         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9826         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9827         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9828         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9829         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9830         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9831          * so apparently no perfect solution yet
9832          */
9833         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9834         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9835         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9836         {} /* terminator */
9837 };
9838
9839 static struct alc_config_preset alc882_presets[] = {
9840         [ALC882_3ST_DIG] = {
9841                 .mixers = { alc882_base_mixer },
9842                 .init_verbs = { alc882_base_init_verbs,
9843                                 alc882_adc1_init_verbs },
9844                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9845                 .dac_nids = alc882_dac_nids,
9846                 .dig_out_nid = ALC882_DIGOUT_NID,
9847                 .dig_in_nid = ALC882_DIGIN_NID,
9848                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9849                 .channel_mode = alc882_ch_modes,
9850                 .need_dac_fix = 1,
9851                 .input_mux = &alc882_capture_source,
9852         },
9853         [ALC882_6ST_DIG] = {
9854                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9855                 .init_verbs = { alc882_base_init_verbs,
9856                                 alc882_adc1_init_verbs },
9857                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9858                 .dac_nids = alc882_dac_nids,
9859                 .dig_out_nid = ALC882_DIGOUT_NID,
9860                 .dig_in_nid = ALC882_DIGIN_NID,
9861                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9862                 .channel_mode = alc882_sixstack_modes,
9863                 .input_mux = &alc882_capture_source,
9864         },
9865         [ALC882_ARIMA] = {
9866                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9867                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9868                                 alc882_eapd_verbs },
9869                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9870                 .dac_nids = alc882_dac_nids,
9871                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9872                 .channel_mode = alc882_sixstack_modes,
9873                 .input_mux = &alc882_capture_source,
9874         },
9875         [ALC882_W2JC] = {
9876                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9877                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9878                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9879                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9880                 .dac_nids = alc882_dac_nids,
9881                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9882                 .channel_mode = alc880_threestack_modes,
9883                 .need_dac_fix = 1,
9884                 .input_mux = &alc882_capture_source,
9885                 .dig_out_nid = ALC882_DIGOUT_NID,
9886         },
9887            [ALC885_MBA21] = {
9888                         .mixers = { alc885_mba21_mixer },
9889                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9890                         .num_dacs = 2,
9891                         .dac_nids = alc882_dac_nids,
9892                         .channel_mode = alc885_mba21_ch_modes,
9893                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9894                         .input_mux = &alc882_capture_source,
9895                         .unsol_event = alc_automute_amp_unsol_event,
9896                         .setup = alc885_mba21_setup,
9897                         .init_hook = alc_automute_amp,
9898        },
9899         [ALC885_MBP3] = {
9900                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9901                 .init_verbs = { alc885_mbp3_init_verbs,
9902                                 alc880_gpio1_init_verbs },
9903                 .num_dacs = 2,
9904                 .dac_nids = alc882_dac_nids,
9905                 .hp_nid = 0x04,
9906                 .channel_mode = alc885_mbp_4ch_modes,
9907                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9908                 .input_mux = &alc882_capture_source,
9909                 .dig_out_nid = ALC882_DIGOUT_NID,
9910                 .dig_in_nid = ALC882_DIGIN_NID,
9911                 .unsol_event = alc_automute_amp_unsol_event,
9912                 .setup = alc885_mbp3_setup,
9913                 .init_hook = alc_automute_amp,
9914         },
9915         [ALC885_MB5] = {
9916                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9917                 .init_verbs = { alc885_mb5_init_verbs,
9918                                 alc880_gpio1_init_verbs },
9919                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9920                 .dac_nids = alc882_dac_nids,
9921                 .channel_mode = alc885_mb5_6ch_modes,
9922                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9923                 .input_mux = &mb5_capture_source,
9924                 .dig_out_nid = ALC882_DIGOUT_NID,
9925                 .dig_in_nid = ALC882_DIGIN_NID,
9926                 .unsol_event = alc_automute_amp_unsol_event,
9927                 .setup = alc885_mb5_setup,
9928                 .init_hook = alc_automute_amp,
9929         },
9930         [ALC885_MACMINI3] = {
9931                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9932                 .init_verbs = { alc885_macmini3_init_verbs,
9933                                 alc880_gpio1_init_verbs },
9934                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9935                 .dac_nids = alc882_dac_nids,
9936                 .channel_mode = alc885_macmini3_6ch_modes,
9937                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9938                 .input_mux = &macmini3_capture_source,
9939                 .dig_out_nid = ALC882_DIGOUT_NID,
9940                 .dig_in_nid = ALC882_DIGIN_NID,
9941                 .unsol_event = alc_automute_amp_unsol_event,
9942                 .setup = alc885_macmini3_setup,
9943                 .init_hook = alc_automute_amp,
9944         },
9945         [ALC885_MACPRO] = {
9946                 .mixers = { alc882_macpro_mixer },
9947                 .init_verbs = { alc882_macpro_init_verbs },
9948                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9949                 .dac_nids = alc882_dac_nids,
9950                 .dig_out_nid = ALC882_DIGOUT_NID,
9951                 .dig_in_nid = ALC882_DIGIN_NID,
9952                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9953                 .channel_mode = alc882_ch_modes,
9954                 .input_mux = &alc882_capture_source,
9955                 .init_hook = alc885_macpro_init_hook,
9956         },
9957         [ALC885_IMAC24] = {
9958                 .mixers = { alc885_imac24_mixer },
9959                 .init_verbs = { alc885_imac24_init_verbs },
9960                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9961                 .dac_nids = alc882_dac_nids,
9962                 .dig_out_nid = ALC882_DIGOUT_NID,
9963                 .dig_in_nid = ALC882_DIGIN_NID,
9964                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9965                 .channel_mode = alc882_ch_modes,
9966                 .input_mux = &alc882_capture_source,
9967                 .unsol_event = alc_automute_amp_unsol_event,
9968                 .setup = alc885_imac24_setup,
9969                 .init_hook = alc885_imac24_init_hook,
9970         },
9971         [ALC885_IMAC91] = {
9972                 .mixers = {alc885_imac91_mixer},
9973                 .init_verbs = { alc885_imac91_init_verbs,
9974                                 alc880_gpio1_init_verbs },
9975                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9976                 .dac_nids = alc882_dac_nids,
9977                 .channel_mode = alc885_mba21_ch_modes,
9978                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9979                 .input_mux = &alc889A_imac91_capture_source,
9980                 .dig_out_nid = ALC882_DIGOUT_NID,
9981                 .dig_in_nid = ALC882_DIGIN_NID,
9982                 .unsol_event = alc_automute_amp_unsol_event,
9983                 .setup = alc885_imac91_setup,
9984                 .init_hook = alc_automute_amp,
9985         },
9986         [ALC882_TARGA] = {
9987                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9988                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9989                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9990                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9991                 .dac_nids = alc882_dac_nids,
9992                 .dig_out_nid = ALC882_DIGOUT_NID,
9993                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9994                 .adc_nids = alc882_adc_nids,
9995                 .capsrc_nids = alc882_capsrc_nids,
9996                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9997                 .channel_mode = alc882_3ST_6ch_modes,
9998                 .need_dac_fix = 1,
9999                 .input_mux = &alc882_capture_source,
10000                 .unsol_event = alc882_targa_unsol_event,
10001                 .setup = alc882_targa_setup,
10002                 .init_hook = alc882_targa_automute,
10003         },
10004         [ALC882_ASUS_A7J] = {
10005                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10006                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10007                                 alc882_asus_a7j_verbs},
10008                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10009                 .dac_nids = alc882_dac_nids,
10010                 .dig_out_nid = ALC882_DIGOUT_NID,
10011                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10012                 .adc_nids = alc882_adc_nids,
10013                 .capsrc_nids = alc882_capsrc_nids,
10014                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10015                 .channel_mode = alc882_3ST_6ch_modes,
10016                 .need_dac_fix = 1,
10017                 .input_mux = &alc882_capture_source,
10018         },
10019         [ALC882_ASUS_A7M] = {
10020                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10021                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10022                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10023                                 alc882_asus_a7m_verbs },
10024                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10025                 .dac_nids = alc882_dac_nids,
10026                 .dig_out_nid = ALC882_DIGOUT_NID,
10027                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10028                 .channel_mode = alc880_threestack_modes,
10029                 .need_dac_fix = 1,
10030                 .input_mux = &alc882_capture_source,
10031         },
10032         [ALC883_3ST_2ch_DIG] = {
10033                 .mixers = { alc883_3ST_2ch_mixer },
10034                 .init_verbs = { alc883_init_verbs },
10035                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10036                 .dac_nids = alc883_dac_nids,
10037                 .dig_out_nid = ALC883_DIGOUT_NID,
10038                 .dig_in_nid = ALC883_DIGIN_NID,
10039                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10040                 .channel_mode = alc883_3ST_2ch_modes,
10041                 .input_mux = &alc883_capture_source,
10042         },
10043         [ALC883_3ST_6ch_DIG] = {
10044                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10045                 .init_verbs = { alc883_init_verbs },
10046                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10047                 .dac_nids = alc883_dac_nids,
10048                 .dig_out_nid = ALC883_DIGOUT_NID,
10049                 .dig_in_nid = ALC883_DIGIN_NID,
10050                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10051                 .channel_mode = alc883_3ST_6ch_modes,
10052                 .need_dac_fix = 1,
10053                 .input_mux = &alc883_capture_source,
10054         },
10055         [ALC883_3ST_6ch] = {
10056                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10057                 .init_verbs = { alc883_init_verbs },
10058                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10059                 .dac_nids = alc883_dac_nids,
10060                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10061                 .channel_mode = alc883_3ST_6ch_modes,
10062                 .need_dac_fix = 1,
10063                 .input_mux = &alc883_capture_source,
10064         },
10065         [ALC883_3ST_6ch_INTEL] = {
10066                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10067                 .init_verbs = { alc883_init_verbs },
10068                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10069                 .dac_nids = alc883_dac_nids,
10070                 .dig_out_nid = ALC883_DIGOUT_NID,
10071                 .dig_in_nid = ALC883_DIGIN_NID,
10072                 .slave_dig_outs = alc883_slave_dig_outs,
10073                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10074                 .channel_mode = alc883_3ST_6ch_intel_modes,
10075                 .need_dac_fix = 1,
10076                 .input_mux = &alc883_3stack_6ch_intel,
10077         },
10078         [ALC889A_INTEL] = {
10079                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10080                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10081                                 alc_hp15_unsol_verbs },
10082                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10083                 .dac_nids = alc883_dac_nids,
10084                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10085                 .adc_nids = alc889_adc_nids,
10086                 .dig_out_nid = ALC883_DIGOUT_NID,
10087                 .dig_in_nid = ALC883_DIGIN_NID,
10088                 .slave_dig_outs = alc883_slave_dig_outs,
10089                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10090                 .channel_mode = alc889_8ch_intel_modes,
10091                 .capsrc_nids = alc889_capsrc_nids,
10092                 .input_mux = &alc889_capture_source,
10093                 .setup = alc889_automute_setup,
10094                 .init_hook = alc_automute_amp,
10095                 .unsol_event = alc_automute_amp_unsol_event,
10096                 .need_dac_fix = 1,
10097         },
10098         [ALC889_INTEL] = {
10099                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10100                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10101                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10102                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10103                 .dac_nids = alc883_dac_nids,
10104                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10105                 .adc_nids = alc889_adc_nids,
10106                 .dig_out_nid = ALC883_DIGOUT_NID,
10107                 .dig_in_nid = ALC883_DIGIN_NID,
10108                 .slave_dig_outs = alc883_slave_dig_outs,
10109                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10110                 .channel_mode = alc889_8ch_intel_modes,
10111                 .capsrc_nids = alc889_capsrc_nids,
10112                 .input_mux = &alc889_capture_source,
10113                 .setup = alc889_automute_setup,
10114                 .init_hook = alc889_intel_init_hook,
10115                 .unsol_event = alc_automute_amp_unsol_event,
10116                 .need_dac_fix = 1,
10117         },
10118         [ALC883_6ST_DIG] = {
10119                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10120                 .init_verbs = { alc883_init_verbs },
10121                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10122                 .dac_nids = alc883_dac_nids,
10123                 .dig_out_nid = ALC883_DIGOUT_NID,
10124                 .dig_in_nid = ALC883_DIGIN_NID,
10125                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10126                 .channel_mode = alc883_sixstack_modes,
10127                 .input_mux = &alc883_capture_source,
10128         },
10129         [ALC883_TARGA_DIG] = {
10130                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10131                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10132                                 alc883_targa_verbs},
10133                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10134                 .dac_nids = alc883_dac_nids,
10135                 .dig_out_nid = ALC883_DIGOUT_NID,
10136                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10137                 .channel_mode = alc883_3ST_6ch_modes,
10138                 .need_dac_fix = 1,
10139                 .input_mux = &alc883_capture_source,
10140                 .unsol_event = alc883_targa_unsol_event,
10141                 .setup = alc882_targa_setup,
10142                 .init_hook = alc882_targa_automute,
10143         },
10144         [ALC883_TARGA_2ch_DIG] = {
10145                 .mixers = { alc883_targa_2ch_mixer},
10146                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10147                                 alc883_targa_verbs},
10148                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10149                 .dac_nids = alc883_dac_nids,
10150                 .adc_nids = alc883_adc_nids_alt,
10151                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10152                 .capsrc_nids = alc883_capsrc_nids,
10153                 .dig_out_nid = ALC883_DIGOUT_NID,
10154                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10155                 .channel_mode = alc883_3ST_2ch_modes,
10156                 .input_mux = &alc883_capture_source,
10157                 .unsol_event = alc883_targa_unsol_event,
10158                 .setup = alc882_targa_setup,
10159                 .init_hook = alc882_targa_automute,
10160         },
10161         [ALC883_TARGA_8ch_DIG] = {
10162                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10163                             alc883_chmode_mixer },
10164                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10165                                 alc883_targa_verbs },
10166                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10167                 .dac_nids = alc883_dac_nids,
10168                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10169                 .adc_nids = alc883_adc_nids_rev,
10170                 .capsrc_nids = alc883_capsrc_nids_rev,
10171                 .dig_out_nid = ALC883_DIGOUT_NID,
10172                 .dig_in_nid = ALC883_DIGIN_NID,
10173                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10174                 .channel_mode = alc883_4ST_8ch_modes,
10175                 .need_dac_fix = 1,
10176                 .input_mux = &alc883_capture_source,
10177                 .unsol_event = alc883_targa_unsol_event,
10178                 .setup = alc882_targa_setup,
10179                 .init_hook = alc882_targa_automute,
10180         },
10181         [ALC883_ACER] = {
10182                 .mixers = { alc883_base_mixer },
10183                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10184                  * and the headphone jack.  Turn this on and rely on the
10185                  * standard mute methods whenever the user wants to turn
10186                  * these outputs off.
10187                  */
10188                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10189                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10190                 .dac_nids = alc883_dac_nids,
10191                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10192                 .channel_mode = alc883_3ST_2ch_modes,
10193                 .input_mux = &alc883_capture_source,
10194         },
10195         [ALC883_ACER_ASPIRE] = {
10196                 .mixers = { alc883_acer_aspire_mixer },
10197                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10198                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10199                 .dac_nids = alc883_dac_nids,
10200                 .dig_out_nid = ALC883_DIGOUT_NID,
10201                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10202                 .channel_mode = alc883_3ST_2ch_modes,
10203                 .input_mux = &alc883_capture_source,
10204                 .unsol_event = alc_automute_amp_unsol_event,
10205                 .setup = alc883_acer_aspire_setup,
10206                 .init_hook = alc_automute_amp,
10207         },
10208         [ALC888_ACER_ASPIRE_4930G] = {
10209                 .mixers = { alc888_base_mixer,
10210                                 alc883_chmode_mixer },
10211                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10212                                 alc888_acer_aspire_4930g_verbs },
10213                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10214                 .dac_nids = alc883_dac_nids,
10215                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10216                 .adc_nids = alc883_adc_nids_rev,
10217                 .capsrc_nids = alc883_capsrc_nids_rev,
10218                 .dig_out_nid = ALC883_DIGOUT_NID,
10219                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10220                 .channel_mode = alc883_3ST_6ch_modes,
10221                 .need_dac_fix = 1,
10222                 .const_channel_count = 6,
10223                 .num_mux_defs =
10224                         ARRAY_SIZE(alc888_2_capture_sources),
10225                 .input_mux = alc888_2_capture_sources,
10226                 .unsol_event = alc_automute_amp_unsol_event,
10227                 .setup = alc888_acer_aspire_4930g_setup,
10228                 .init_hook = alc_automute_amp,
10229         },
10230         [ALC888_ACER_ASPIRE_6530G] = {
10231                 .mixers = { alc888_acer_aspire_6530_mixer },
10232                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10233                                 alc888_acer_aspire_6530g_verbs },
10234                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10235                 .dac_nids = alc883_dac_nids,
10236                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10237                 .adc_nids = alc883_adc_nids_rev,
10238                 .capsrc_nids = alc883_capsrc_nids_rev,
10239                 .dig_out_nid = ALC883_DIGOUT_NID,
10240                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10241                 .channel_mode = alc883_3ST_2ch_modes,
10242                 .num_mux_defs =
10243                         ARRAY_SIZE(alc888_2_capture_sources),
10244                 .input_mux = alc888_acer_aspire_6530_sources,
10245                 .unsol_event = alc_automute_amp_unsol_event,
10246                 .setup = alc888_acer_aspire_6530g_setup,
10247                 .init_hook = alc_automute_amp,
10248         },
10249         [ALC888_ACER_ASPIRE_8930G] = {
10250                 .mixers = { alc889_acer_aspire_8930g_mixer,
10251                                 alc883_chmode_mixer },
10252                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10253                                 alc889_acer_aspire_8930g_verbs,
10254                                 alc889_eapd_verbs},
10255                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10256                 .dac_nids = alc883_dac_nids,
10257                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10258                 .adc_nids = alc889_adc_nids,
10259                 .capsrc_nids = alc889_capsrc_nids,
10260                 .dig_out_nid = ALC883_DIGOUT_NID,
10261                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10262                 .channel_mode = alc883_3ST_6ch_modes,
10263                 .need_dac_fix = 1,
10264                 .const_channel_count = 6,
10265                 .num_mux_defs =
10266                         ARRAY_SIZE(alc889_capture_sources),
10267                 .input_mux = alc889_capture_sources,
10268                 .unsol_event = alc_automute_amp_unsol_event,
10269                 .setup = alc889_acer_aspire_8930g_setup,
10270                 .init_hook = alc_automute_amp,
10271 #ifdef CONFIG_SND_HDA_POWER_SAVE
10272                 .power_hook = alc_power_eapd,
10273 #endif
10274         },
10275         [ALC888_ACER_ASPIRE_7730G] = {
10276                 .mixers = { alc883_3ST_6ch_mixer,
10277                                 alc883_chmode_mixer },
10278                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10279                                 alc888_acer_aspire_7730G_verbs },
10280                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10281                 .dac_nids = alc883_dac_nids,
10282                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10283                 .adc_nids = alc883_adc_nids_rev,
10284                 .capsrc_nids = alc883_capsrc_nids_rev,
10285                 .dig_out_nid = ALC883_DIGOUT_NID,
10286                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10287                 .channel_mode = alc883_3ST_6ch_modes,
10288                 .need_dac_fix = 1,
10289                 .const_channel_count = 6,
10290                 .input_mux = &alc883_capture_source,
10291                 .unsol_event = alc_automute_amp_unsol_event,
10292                 .setup = alc888_acer_aspire_6530g_setup,
10293                 .init_hook = alc_automute_amp,
10294         },
10295         [ALC883_MEDION] = {
10296                 .mixers = { alc883_fivestack_mixer,
10297                             alc883_chmode_mixer },
10298                 .init_verbs = { alc883_init_verbs,
10299                                 alc883_medion_eapd_verbs },
10300                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10301                 .dac_nids = alc883_dac_nids,
10302                 .adc_nids = alc883_adc_nids_alt,
10303                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10304                 .capsrc_nids = alc883_capsrc_nids,
10305                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10306                 .channel_mode = alc883_sixstack_modes,
10307                 .input_mux = &alc883_capture_source,
10308         },
10309         [ALC883_MEDION_MD2] = {
10310                 .mixers = { alc883_medion_md2_mixer},
10311                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
10312                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10313                 .dac_nids = alc883_dac_nids,
10314                 .dig_out_nid = ALC883_DIGOUT_NID,
10315                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10316                 .channel_mode = alc883_3ST_2ch_modes,
10317                 .input_mux = &alc883_capture_source,
10318                 .unsol_event = alc_automute_amp_unsol_event,
10319                 .setup = alc883_medion_md2_setup,
10320                 .init_hook = alc_automute_amp,
10321         },
10322         [ALC883_MEDION_WIM2160] = {
10323                 .mixers = { alc883_medion_wim2160_mixer },
10324                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10325                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10326                 .dac_nids = alc883_dac_nids,
10327                 .dig_out_nid = ALC883_DIGOUT_NID,
10328                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10329                 .adc_nids = alc883_adc_nids,
10330                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10331                 .channel_mode = alc883_3ST_2ch_modes,
10332                 .input_mux = &alc883_capture_source,
10333                 .unsol_event = alc_automute_amp_unsol_event,
10334                 .setup = alc883_medion_wim2160_setup,
10335                 .init_hook = alc_automute_amp,
10336         },
10337         [ALC883_LAPTOP_EAPD] = {
10338                 .mixers = { alc883_base_mixer },
10339                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10340                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10341                 .dac_nids = alc883_dac_nids,
10342                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10343                 .channel_mode = alc883_3ST_2ch_modes,
10344                 .input_mux = &alc883_capture_source,
10345         },
10346         [ALC883_CLEVO_M540R] = {
10347                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10348                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10349                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10350                 .dac_nids = alc883_dac_nids,
10351                 .dig_out_nid = ALC883_DIGOUT_NID,
10352                 .dig_in_nid = ALC883_DIGIN_NID,
10353                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10354                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10355                 .need_dac_fix = 1,
10356                 .input_mux = &alc883_capture_source,
10357                 /* This machine has the hardware HP auto-muting, thus
10358                  * we need no software mute via unsol event
10359                  */
10360         },
10361         [ALC883_CLEVO_M720] = {
10362                 .mixers = { alc883_clevo_m720_mixer },
10363                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10364                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10365                 .dac_nids = alc883_dac_nids,
10366                 .dig_out_nid = ALC883_DIGOUT_NID,
10367                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10368                 .channel_mode = alc883_3ST_2ch_modes,
10369                 .input_mux = &alc883_capture_source,
10370                 .unsol_event = alc883_clevo_m720_unsol_event,
10371                 .setup = alc883_clevo_m720_setup,
10372                 .init_hook = alc883_clevo_m720_init_hook,
10373         },
10374         [ALC883_LENOVO_101E_2ch] = {
10375                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10376                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10377                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10378                 .dac_nids = alc883_dac_nids,
10379                 .adc_nids = alc883_adc_nids_alt,
10380                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10381                 .capsrc_nids = alc883_capsrc_nids,
10382                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10383                 .channel_mode = alc883_3ST_2ch_modes,
10384                 .input_mux = &alc883_lenovo_101e_capture_source,
10385                 .unsol_event = alc883_lenovo_101e_unsol_event,
10386                 .init_hook = alc883_lenovo_101e_all_automute,
10387         },
10388         [ALC883_LENOVO_NB0763] = {
10389                 .mixers = { alc883_lenovo_nb0763_mixer },
10390                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10391                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10392                 .dac_nids = alc883_dac_nids,
10393                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10394                 .channel_mode = alc883_3ST_2ch_modes,
10395                 .need_dac_fix = 1,
10396                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10397                 .unsol_event = alc_automute_amp_unsol_event,
10398                 .setup = alc883_medion_md2_setup,
10399                 .init_hook = alc_automute_amp,
10400         },
10401         [ALC888_LENOVO_MS7195_DIG] = {
10402                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10403                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10404                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10405                 .dac_nids = alc883_dac_nids,
10406                 .dig_out_nid = ALC883_DIGOUT_NID,
10407                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10408                 .channel_mode = alc883_3ST_6ch_modes,
10409                 .need_dac_fix = 1,
10410                 .input_mux = &alc883_capture_source,
10411                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10412                 .init_hook = alc888_lenovo_ms7195_front_automute,
10413         },
10414         [ALC883_HAIER_W66] = {
10415                 .mixers = { alc883_targa_2ch_mixer},
10416                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10417                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10418                 .dac_nids = alc883_dac_nids,
10419                 .dig_out_nid = ALC883_DIGOUT_NID,
10420                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10421                 .channel_mode = alc883_3ST_2ch_modes,
10422                 .input_mux = &alc883_capture_source,
10423                 .unsol_event = alc_automute_amp_unsol_event,
10424                 .setup = alc883_haier_w66_setup,
10425                 .init_hook = alc_automute_amp,
10426         },
10427         [ALC888_3ST_HP] = {
10428                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10429                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10430                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10431                 .dac_nids = alc883_dac_nids,
10432                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10433                 .channel_mode = alc888_3st_hp_modes,
10434                 .need_dac_fix = 1,
10435                 .input_mux = &alc883_capture_source,
10436                 .unsol_event = alc_automute_amp_unsol_event,
10437                 .setup = alc888_3st_hp_setup,
10438                 .init_hook = alc_automute_amp,
10439         },
10440         [ALC888_6ST_DELL] = {
10441                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10442                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10443                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10444                 .dac_nids = alc883_dac_nids,
10445                 .dig_out_nid = ALC883_DIGOUT_NID,
10446                 .dig_in_nid = ALC883_DIGIN_NID,
10447                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10448                 .channel_mode = alc883_sixstack_modes,
10449                 .input_mux = &alc883_capture_source,
10450                 .unsol_event = alc_automute_amp_unsol_event,
10451                 .setup = alc888_6st_dell_setup,
10452                 .init_hook = alc_automute_amp,
10453         },
10454         [ALC883_MITAC] = {
10455                 .mixers = { alc883_mitac_mixer },
10456                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10457                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10458                 .dac_nids = alc883_dac_nids,
10459                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10460                 .channel_mode = alc883_3ST_2ch_modes,
10461                 .input_mux = &alc883_capture_source,
10462                 .unsol_event = alc_automute_amp_unsol_event,
10463                 .setup = alc883_mitac_setup,
10464                 .init_hook = alc_automute_amp,
10465         },
10466         [ALC883_FUJITSU_PI2515] = {
10467                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10468                 .init_verbs = { alc883_init_verbs,
10469                                 alc883_2ch_fujitsu_pi2515_verbs},
10470                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10471                 .dac_nids = alc883_dac_nids,
10472                 .dig_out_nid = ALC883_DIGOUT_NID,
10473                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10474                 .channel_mode = alc883_3ST_2ch_modes,
10475                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10476                 .unsol_event = alc_automute_amp_unsol_event,
10477                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10478                 .init_hook = alc_automute_amp,
10479         },
10480         [ALC888_FUJITSU_XA3530] = {
10481                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10482                 .init_verbs = { alc883_init_verbs,
10483                         alc888_fujitsu_xa3530_verbs },
10484                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10485                 .dac_nids = alc883_dac_nids,
10486                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10487                 .adc_nids = alc883_adc_nids_rev,
10488                 .capsrc_nids = alc883_capsrc_nids_rev,
10489                 .dig_out_nid = ALC883_DIGOUT_NID,
10490                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10491                 .channel_mode = alc888_4ST_8ch_intel_modes,
10492                 .num_mux_defs =
10493                         ARRAY_SIZE(alc888_2_capture_sources),
10494                 .input_mux = alc888_2_capture_sources,
10495                 .unsol_event = alc_automute_amp_unsol_event,
10496                 .setup = alc888_fujitsu_xa3530_setup,
10497                 .init_hook = alc_automute_amp,
10498         },
10499         [ALC888_LENOVO_SKY] = {
10500                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10501                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10502                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10503                 .dac_nids = alc883_dac_nids,
10504                 .dig_out_nid = ALC883_DIGOUT_NID,
10505                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10506                 .channel_mode = alc883_sixstack_modes,
10507                 .need_dac_fix = 1,
10508                 .input_mux = &alc883_lenovo_sky_capture_source,
10509                 .unsol_event = alc_automute_amp_unsol_event,
10510                 .setup = alc888_lenovo_sky_setup,
10511                 .init_hook = alc_automute_amp,
10512         },
10513         [ALC888_ASUS_M90V] = {
10514                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10515                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10516                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10517                 .dac_nids = alc883_dac_nids,
10518                 .dig_out_nid = ALC883_DIGOUT_NID,
10519                 .dig_in_nid = ALC883_DIGIN_NID,
10520                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10521                 .channel_mode = alc883_3ST_6ch_modes,
10522                 .need_dac_fix = 1,
10523                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10524                 .unsol_event = alc_sku_unsol_event,
10525                 .setup = alc883_mode2_setup,
10526                 .init_hook = alc_inithook,
10527         },
10528         [ALC888_ASUS_EEE1601] = {
10529                 .mixers = { alc883_asus_eee1601_mixer },
10530                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10531                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10532                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10533                 .dac_nids = alc883_dac_nids,
10534                 .dig_out_nid = ALC883_DIGOUT_NID,
10535                 .dig_in_nid = ALC883_DIGIN_NID,
10536                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10537                 .channel_mode = alc883_3ST_2ch_modes,
10538                 .need_dac_fix = 1,
10539                 .input_mux = &alc883_asus_eee1601_capture_source,
10540                 .unsol_event = alc_sku_unsol_event,
10541                 .init_hook = alc883_eee1601_inithook,
10542         },
10543         [ALC1200_ASUS_P5Q] = {
10544                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10545                 .init_verbs = { alc883_init_verbs },
10546                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10547                 .dac_nids = alc883_dac_nids,
10548                 .dig_out_nid = ALC1200_DIGOUT_NID,
10549                 .dig_in_nid = ALC883_DIGIN_NID,
10550                 .slave_dig_outs = alc1200_slave_dig_outs,
10551                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10552                 .channel_mode = alc883_sixstack_modes,
10553                 .input_mux = &alc883_capture_source,
10554         },
10555         [ALC889A_MB31] = {
10556                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10557                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10558                         alc880_gpio1_init_verbs },
10559                 .adc_nids = alc883_adc_nids,
10560                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10561                 .capsrc_nids = alc883_capsrc_nids,
10562                 .dac_nids = alc883_dac_nids,
10563                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10564                 .channel_mode = alc889A_mb31_6ch_modes,
10565                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10566                 .input_mux = &alc889A_mb31_capture_source,
10567                 .dig_out_nid = ALC883_DIGOUT_NID,
10568                 .unsol_event = alc889A_mb31_unsol_event,
10569                 .init_hook = alc889A_mb31_automute,
10570         },
10571         [ALC883_SONY_VAIO_TT] = {
10572                 .mixers = { alc883_vaiott_mixer },
10573                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10574                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10575                 .dac_nids = alc883_dac_nids,
10576                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10577                 .channel_mode = alc883_3ST_2ch_modes,
10578                 .input_mux = &alc883_capture_source,
10579                 .unsol_event = alc_automute_amp_unsol_event,
10580                 .setup = alc883_vaiott_setup,
10581                 .init_hook = alc_automute_amp,
10582         },
10583 };
10584
10585
10586 /*
10587  * Pin config fixes
10588  */
10589 enum {
10590         PINFIX_ABIT_AW9D_MAX,
10591         PINFIX_PB_M5210,
10592 };
10593
10594 static const struct alc_fixup alc882_fixups[] = {
10595         [PINFIX_ABIT_AW9D_MAX] = {
10596                 .pins = (const struct alc_pincfg[]) {
10597                         { 0x15, 0x01080104 }, /* side */
10598                         { 0x16, 0x01011012 }, /* rear */
10599                         { 0x17, 0x01016011 }, /* clfe */
10600                         { }
10601                 }
10602         },
10603         [PINFIX_PB_M5210] = {
10604                 .verbs = (const struct hda_verb[]) {
10605                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10606                         {}
10607                 }
10608         },
10609 };
10610
10611 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10612         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10613         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10614         {}
10615 };
10616
10617 /*
10618  * BIOS auto configuration
10619  */
10620 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10621                                                 const struct auto_pin_cfg *cfg)
10622 {
10623         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10624 }
10625
10626 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10627                                               hda_nid_t nid, int pin_type,
10628                                               hda_nid_t dac)
10629 {
10630         int idx;
10631
10632         /* set as output */
10633         alc_set_pin_output(codec, nid, pin_type);
10634
10635         if (dac == 0x25)
10636                 idx = 4;
10637         else if (dac >= 0x02 && dac <= 0x05)
10638                 idx = dac - 2;
10639         else
10640                 return;
10641         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10642 }
10643
10644 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10645 {
10646         struct alc_spec *spec = codec->spec;
10647         int i;
10648
10649         for (i = 0; i <= HDA_SIDE; i++) {
10650                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10651                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10652                 if (nid)
10653                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10654                                         spec->multiout.dac_nids[i]);
10655         }
10656 }
10657
10658 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10659 {
10660         struct alc_spec *spec = codec->spec;
10661         hda_nid_t pin, dac;
10662         int i;
10663
10664         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10665                 pin = spec->autocfg.hp_pins[i];
10666                 if (!pin)
10667                         break;
10668                 dac = spec->multiout.hp_nid;
10669                 if (!dac)
10670                         dac = spec->multiout.dac_nids[0]; /* to front */
10671                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10672         }
10673         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10674                 pin = spec->autocfg.speaker_pins[i];
10675                 if (!pin)
10676                         break;
10677                 dac = spec->multiout.extra_out_nid[0];
10678                 if (!dac)
10679                         dac = spec->multiout.dac_nids[0]; /* to front */
10680                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10681         }
10682 }
10683
10684 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10685 {
10686         struct alc_spec *spec = codec->spec;
10687         struct auto_pin_cfg *cfg = &spec->autocfg;
10688         int i;
10689
10690         for (i = 0; i < cfg->num_inputs; i++) {
10691                 hda_nid_t nid = cfg->inputs[i].pin;
10692                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10693                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10694                         snd_hda_codec_write(codec, nid, 0,
10695                                             AC_VERB_SET_AMP_GAIN_MUTE,
10696                                             AMP_OUT_MUTE);
10697         }
10698 }
10699
10700 static void alc882_auto_init_input_src(struct hda_codec *codec)
10701 {
10702         struct alc_spec *spec = codec->spec;
10703         int c;
10704
10705         for (c = 0; c < spec->num_adc_nids; c++) {
10706                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10707                 hda_nid_t nid = spec->capsrc_nids[c];
10708                 unsigned int mux_idx;
10709                 const struct hda_input_mux *imux;
10710                 int conns, mute, idx, item;
10711
10712                 conns = snd_hda_get_connections(codec, nid, conn_list,
10713                                                 ARRAY_SIZE(conn_list));
10714                 if (conns < 0)
10715                         continue;
10716                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10717                 imux = &spec->input_mux[mux_idx];
10718                 if (!imux->num_items && mux_idx > 0)
10719                         imux = &spec->input_mux[0];
10720                 for (idx = 0; idx < conns; idx++) {
10721                         /* if the current connection is the selected one,
10722                          * unmute it as default - otherwise mute it
10723                          */
10724                         mute = AMP_IN_MUTE(idx);
10725                         for (item = 0; item < imux->num_items; item++) {
10726                                 if (imux->items[item].index == idx) {
10727                                         if (spec->cur_mux[c] == item)
10728                                                 mute = AMP_IN_UNMUTE(idx);
10729                                         break;
10730                                 }
10731                         }
10732                         /* check if we have a selector or mixer
10733                          * we could check for the widget type instead, but
10734                          * just check for Amp-In presence (in case of mixer
10735                          * without amp-in there is something wrong, this
10736                          * function shouldn't be used or capsrc nid is wrong)
10737                          */
10738                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10739                                 snd_hda_codec_write(codec, nid, 0,
10740                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10741                                                     mute);
10742                         else if (mute != AMP_IN_MUTE(idx))
10743                                 snd_hda_codec_write(codec, nid, 0,
10744                                                     AC_VERB_SET_CONNECT_SEL,
10745                                                     idx);
10746                 }
10747         }
10748 }
10749
10750 /* add mic boosts if needed */
10751 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10752 {
10753         struct alc_spec *spec = codec->spec;
10754         struct auto_pin_cfg *cfg = &spec->autocfg;
10755         int i, err;
10756         hda_nid_t nid;
10757
10758         for (i = 0; i < cfg->num_inputs; i++) {
10759                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
10760                         break;
10761                 nid = cfg->inputs[i].pin;
10762                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10763                         char label[32];
10764                         snprintf(label, sizeof(label), "%s Boost",
10765                                  hda_get_autocfg_input_label(codec, cfg, i));
10766                         err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0,
10767                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10768                         if (err < 0)
10769                                 return err;
10770                 }
10771         }
10772         return 0;
10773 }
10774
10775 /* almost identical with ALC880 parser... */
10776 static int alc882_parse_auto_config(struct hda_codec *codec)
10777 {
10778         struct alc_spec *spec = codec->spec;
10779         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10780         int err;
10781
10782         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10783                                            alc882_ignore);
10784         if (err < 0)
10785                 return err;
10786         if (!spec->autocfg.line_outs)
10787                 return 0; /* can't find valid BIOS pin config */
10788
10789         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10790         if (err < 0)
10791                 return err;
10792         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10793         if (err < 0)
10794                 return err;
10795         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10796                                            "Headphone");
10797         if (err < 0)
10798                 return err;
10799         err = alc880_auto_create_extra_out(spec,
10800                                            spec->autocfg.speaker_pins[0],
10801                                            "Speaker");
10802         if (err < 0)
10803                 return err;
10804         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10805         if (err < 0)
10806                 return err;
10807
10808         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10809
10810         alc_auto_parse_digital(codec);
10811
10812         if (spec->kctls.list)
10813                 add_mixer(spec, spec->kctls.list);
10814
10815         add_verb(spec, alc883_auto_init_verbs);
10816         /* if ADC 0x07 is available, initialize it, too */
10817         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10818                 add_verb(spec, alc882_adc1_init_verbs);
10819
10820         spec->num_mux_defs = 1;
10821         spec->input_mux = &spec->private_imux[0];
10822
10823         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10824
10825         err = alc_auto_add_mic_boost(codec);
10826         if (err < 0)
10827                 return err;
10828
10829         return 1; /* config found */
10830 }
10831
10832 /* additional initialization for auto-configuration model */
10833 static void alc882_auto_init(struct hda_codec *codec)
10834 {
10835         struct alc_spec *spec = codec->spec;
10836         alc882_auto_init_multi_out(codec);
10837         alc882_auto_init_hp_out(codec);
10838         alc882_auto_init_analog_input(codec);
10839         alc882_auto_init_input_src(codec);
10840         alc_auto_init_digital(codec);
10841         if (spec->unsol_event)
10842                 alc_inithook(codec);
10843 }
10844
10845 static int patch_alc882(struct hda_codec *codec)
10846 {
10847         struct alc_spec *spec;
10848         int err, board_config;
10849
10850         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10851         if (spec == NULL)
10852                 return -ENOMEM;
10853
10854         codec->spec = spec;
10855
10856         alc_auto_parse_customize_define(codec);
10857
10858         switch (codec->vendor_id) {
10859         case 0x10ec0882:
10860         case 0x10ec0885:
10861                 break;
10862         default:
10863                 /* ALC883 and variants */
10864                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10865                 break;
10866         }
10867
10868         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10869                                                   alc882_models,
10870                                                   alc882_cfg_tbl);
10871
10872         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10873                 board_config = snd_hda_check_board_codec_sid_config(codec,
10874                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10875
10876         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10877                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10878                        codec->chip_name);
10879                 board_config = ALC882_AUTO;
10880         }
10881
10882         if (board_config == ALC882_AUTO)
10883                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10884
10885         if (board_config == ALC882_AUTO) {
10886                 /* automatic parse from the BIOS config */
10887                 err = alc882_parse_auto_config(codec);
10888                 if (err < 0) {
10889                         alc_free(codec);
10890                         return err;
10891                 } else if (!err) {
10892                         printk(KERN_INFO
10893                                "hda_codec: Cannot set up configuration "
10894                                "from BIOS.  Using base mode...\n");
10895                         board_config = ALC882_3ST_DIG;
10896                 }
10897         }
10898
10899         if (has_cdefine_beep(codec)) {
10900                 err = snd_hda_attach_beep_device(codec, 0x1);
10901                 if (err < 0) {
10902                         alc_free(codec);
10903                         return err;
10904                 }
10905         }
10906
10907         if (board_config != ALC882_AUTO)
10908                 setup_preset(codec, &alc882_presets[board_config]);
10909
10910         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10911         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10912         /* FIXME: setup DAC5 */
10913         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10914         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10915
10916         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10917         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10918
10919         if (!spec->adc_nids && spec->input_mux) {
10920                 int i, j;
10921                 spec->num_adc_nids = 0;
10922                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10923                         const struct hda_input_mux *imux = spec->input_mux;
10924                         hda_nid_t cap;
10925                         hda_nid_t items[16];
10926                         hda_nid_t nid = alc882_adc_nids[i];
10927                         unsigned int wcap = get_wcaps(codec, nid);
10928                         /* get type */
10929                         wcap = get_wcaps_type(wcap);
10930                         if (wcap != AC_WID_AUD_IN)
10931                                 continue;
10932                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10933                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10934                         if (err < 0)
10935                                 continue;
10936                         err = snd_hda_get_connections(codec, cap, items,
10937                                                       ARRAY_SIZE(items));
10938                         if (err < 0)
10939                                 continue;
10940                         for (j = 0; j < imux->num_items; j++)
10941                                 if (imux->items[j].index >= err)
10942                                         break;
10943                         if (j < imux->num_items)
10944                                 continue;
10945                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10946                         spec->num_adc_nids++;
10947                 }
10948                 spec->adc_nids = spec->private_adc_nids;
10949                 spec->capsrc_nids = spec->private_capsrc_nids;
10950         }
10951
10952         set_capture_mixer(codec);
10953
10954         if (has_cdefine_beep(codec))
10955                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10956
10957         if (board_config == ALC882_AUTO)
10958                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
10959
10960         spec->vmaster_nid = 0x0c;
10961
10962         codec->patch_ops = alc_patch_ops;
10963         if (board_config == ALC882_AUTO)
10964                 spec->init_hook = alc882_auto_init;
10965 #ifdef CONFIG_SND_HDA_POWER_SAVE
10966         if (!spec->loopback.amplist)
10967                 spec->loopback.amplist = alc882_loopbacks;
10968 #endif
10969
10970         return 0;
10971 }
10972
10973
10974 /*
10975  * ALC262 support
10976  */
10977
10978 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10979 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10980
10981 #define alc262_dac_nids         alc260_dac_nids
10982 #define alc262_adc_nids         alc882_adc_nids
10983 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10984 #define alc262_capsrc_nids      alc882_capsrc_nids
10985 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10986
10987 #define alc262_modes            alc260_modes
10988 #define alc262_capture_source   alc882_capture_source
10989
10990 static hda_nid_t alc262_dmic_adc_nids[1] = {
10991         /* ADC0 */
10992         0x09
10993 };
10994
10995 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10996
10997 static struct snd_kcontrol_new alc262_base_mixer[] = {
10998         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10999         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11000         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11001         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11002         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11003         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11004         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11005         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11006         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11007         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11008         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11009         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11010         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11011         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11012         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11013         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11014         { } /* end */
11015 };
11016
11017 /* update HP, line and mono-out pins according to the master switch */
11018 static void alc262_hp_master_update(struct hda_codec *codec)
11019 {
11020         struct alc_spec *spec = codec->spec;
11021         int val = spec->master_sw;
11022
11023         /* HP & line-out */
11024         snd_hda_codec_write_cache(codec, 0x1b, 0,
11025                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11026                                   val ? PIN_HP : 0);
11027         snd_hda_codec_write_cache(codec, 0x15, 0,
11028                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11029                                   val ? PIN_HP : 0);
11030         /* mono (speaker) depending on the HP jack sense */
11031         val = val && !spec->jack_present;
11032         snd_hda_codec_write_cache(codec, 0x16, 0,
11033                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11034                                   val ? PIN_OUT : 0);
11035 }
11036
11037 static void alc262_hp_bpc_automute(struct hda_codec *codec)
11038 {
11039         struct alc_spec *spec = codec->spec;
11040
11041         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11042         alc262_hp_master_update(codec);
11043 }
11044
11045 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11046 {
11047         if ((res >> 26) != ALC880_HP_EVENT)
11048                 return;
11049         alc262_hp_bpc_automute(codec);
11050 }
11051
11052 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11053 {
11054         struct alc_spec *spec = codec->spec;
11055
11056         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11057         alc262_hp_master_update(codec);
11058 }
11059
11060 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11061                                            unsigned int res)
11062 {
11063         if ((res >> 26) != ALC880_HP_EVENT)
11064                 return;
11065         alc262_hp_wildwest_automute(codec);
11066 }
11067
11068 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11069
11070 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11071                                    struct snd_ctl_elem_value *ucontrol)
11072 {
11073         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11074         struct alc_spec *spec = codec->spec;
11075         int val = !!*ucontrol->value.integer.value;
11076
11077         if (val == spec->master_sw)
11078                 return 0;
11079         spec->master_sw = val;
11080         alc262_hp_master_update(codec);
11081         return 1;
11082 }
11083
11084 #define ALC262_HP_MASTER_SWITCH                                 \
11085         {                                                       \
11086                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11087                 .name = "Master Playback Switch",               \
11088                 .info = snd_ctl_boolean_mono_info,              \
11089                 .get = alc262_hp_master_sw_get,                 \
11090                 .put = alc262_hp_master_sw_put,                 \
11091         }, \
11092         {                                                       \
11093                 .iface = NID_MAPPING,                           \
11094                 .name = "Master Playback Switch",               \
11095                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11096         }
11097
11098
11099 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11100         ALC262_HP_MASTER_SWITCH,
11101         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11102         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11103         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11104         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11105                               HDA_OUTPUT),
11106         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11107                             HDA_OUTPUT),
11108         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11109         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11110         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11111         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11112         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11113         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11114         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11115         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11116         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11117         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11118         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11119         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11120         { } /* end */
11121 };
11122
11123 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11124         ALC262_HP_MASTER_SWITCH,
11125         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11126         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11127         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11128         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11129         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11130                               HDA_OUTPUT),
11131         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11132                             HDA_OUTPUT),
11133         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11134         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11135         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
11136         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11137         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11138         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11139         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11140         { } /* end */
11141 };
11142
11143 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11144         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11145         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11146         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
11147         { } /* end */
11148 };
11149
11150 /* mute/unmute internal speaker according to the hp jack and mute state */
11151 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11152 {
11153         struct alc_spec *spec = codec->spec;
11154
11155         spec->autocfg.hp_pins[0] = 0x15;
11156         spec->autocfg.speaker_pins[0] = 0x14;
11157 }
11158
11159 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11160         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11161         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11162         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11163         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11164         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11165         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11166         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11167         { } /* end */
11168 };
11169
11170 static struct hda_verb alc262_hp_t5735_verbs[] = {
11171         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11172         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11173
11174         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11175         { }
11176 };
11177
11178 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11179         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11180         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11181         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11182         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11183         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11184         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11185         { } /* end */
11186 };
11187
11188 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11189         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11190         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11191         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11192         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11193         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11194         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11195         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11196         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11197         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11198         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11199         {}
11200 };
11201
11202 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11203         .num_items = 1,
11204         .items = {
11205                 { "Line", 0x1 },
11206         },
11207 };
11208
11209 /* bind hp and internal speaker mute (with plug check) as master switch */
11210 static void alc262_hippo_master_update(struct hda_codec *codec)
11211 {
11212         struct alc_spec *spec = codec->spec;
11213         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11214         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11215         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11216         unsigned int mute;
11217
11218         /* HP */
11219         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11220         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11221                                  HDA_AMP_MUTE, mute);
11222         /* mute internal speaker per jack sense */
11223         if (spec->jack_present)
11224                 mute = HDA_AMP_MUTE;
11225         if (line_nid)
11226                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11227                                          HDA_AMP_MUTE, mute);
11228         if (speaker_nid && speaker_nid != line_nid)
11229                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11230                                          HDA_AMP_MUTE, mute);
11231 }
11232
11233 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11234
11235 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11236                                       struct snd_ctl_elem_value *ucontrol)
11237 {
11238         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11239         struct alc_spec *spec = codec->spec;
11240         int val = !!*ucontrol->value.integer.value;
11241
11242         if (val == spec->master_sw)
11243                 return 0;
11244         spec->master_sw = val;
11245         alc262_hippo_master_update(codec);
11246         return 1;
11247 }
11248
11249 #define ALC262_HIPPO_MASTER_SWITCH                              \
11250         {                                                       \
11251                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11252                 .name = "Master Playback Switch",               \
11253                 .info = snd_ctl_boolean_mono_info,              \
11254                 .get = alc262_hippo_master_sw_get,              \
11255                 .put = alc262_hippo_master_sw_put,              \
11256         },                                                      \
11257         {                                                       \
11258                 .iface = NID_MAPPING,                           \
11259                 .name = "Master Playback Switch",               \
11260                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11261                              (SUBDEV_SPEAKER(0) << 16), \
11262         }
11263
11264 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11265         ALC262_HIPPO_MASTER_SWITCH,
11266         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11267         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11268         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11269         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11270         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11272         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11273         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11274         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11275         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11276         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11277         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11278         { } /* end */
11279 };
11280
11281 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11282         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11283         ALC262_HIPPO_MASTER_SWITCH,
11284         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11285         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11286         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11287         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11288         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11289         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11290         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11291         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11292         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11293         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11294         { } /* end */
11295 };
11296
11297 /* mute/unmute internal speaker according to the hp jack and mute state */
11298 static void alc262_hippo_automute(struct hda_codec *codec)
11299 {
11300         struct alc_spec *spec = codec->spec;
11301         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11302
11303         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11304         alc262_hippo_master_update(codec);
11305 }
11306
11307 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11308 {
11309         if ((res >> 26) != ALC880_HP_EVENT)
11310                 return;
11311         alc262_hippo_automute(codec);
11312 }
11313
11314 static void alc262_hippo_setup(struct hda_codec *codec)
11315 {
11316         struct alc_spec *spec = codec->spec;
11317
11318         spec->autocfg.hp_pins[0] = 0x15;
11319         spec->autocfg.speaker_pins[0] = 0x14;
11320 }
11321
11322 static void alc262_hippo1_setup(struct hda_codec *codec)
11323 {
11324         struct alc_spec *spec = codec->spec;
11325
11326         spec->autocfg.hp_pins[0] = 0x1b;
11327         spec->autocfg.speaker_pins[0] = 0x14;
11328 }
11329
11330
11331 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11332         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11333         ALC262_HIPPO_MASTER_SWITCH,
11334         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11335         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11336         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11337         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11338         { } /* end */
11339 };
11340
11341 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11342         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11343         ALC262_HIPPO_MASTER_SWITCH,
11344         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11345         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11346         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11347         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11348         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11349         { } /* end */
11350 };
11351
11352 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11353         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11354         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11355         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11356         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, 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         { } /* end */
11366 };
11367
11368 static struct hda_verb alc262_tyan_verbs[] = {
11369         /* Headphone automute */
11370         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11371         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11372         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11373
11374         /* P11 AUX_IN, white 4-pin connector */
11375         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11376         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11377         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11378         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11379
11380         {}
11381 };
11382
11383 /* unsolicited event for HP jack sensing */
11384 static void alc262_tyan_setup(struct hda_codec *codec)
11385 {
11386         struct alc_spec *spec = codec->spec;
11387
11388         spec->autocfg.hp_pins[0] = 0x1b;
11389         spec->autocfg.speaker_pins[0] = 0x15;
11390 }
11391
11392
11393 #define alc262_capture_mixer            alc882_capture_mixer
11394 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11395
11396 /*
11397  * generic initialization of ADC, input mixers and output mixers
11398  */
11399 static struct hda_verb alc262_init_verbs[] = {
11400         /*
11401          * Unmute ADC0-2 and set the default input to mic-in
11402          */
11403         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11404         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11405         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11406         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11407         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11408         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11409
11410         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11411          * mixer widget
11412          * Note: PASD motherboards uses the Line In 2 as the input for
11413          * front panel mic (mic 2)
11414          */
11415         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11416         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11417         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11418         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11419         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11420         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11421
11422         /*
11423          * Set up output mixers (0x0c - 0x0e)
11424          */
11425         /* set vol=0 to output mixers */
11426         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11427         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11428         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11429         /* set up input amps for analog loopback */
11430         /* Amp Indices: DAC = 0, mixer = 1 */
11431         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11432         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11433         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11434         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11435         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11436         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11437
11438         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11439         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11440         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11441         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11442         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11443         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11444
11445         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11446         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11447         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11448         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11449         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11450
11451         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11452         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11453
11454         /* FIXME: use matrix-type input source selection */
11455         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11456         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11457         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11458         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11459         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11460         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11461         /* Input mixer2 */
11462         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11463         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11464         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11465         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11466         /* Input mixer3 */
11467         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11468         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11469         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11470         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11471
11472         { }
11473 };
11474
11475 static struct hda_verb alc262_eapd_verbs[] = {
11476         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11477         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11478         { }
11479 };
11480
11481 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11482         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11483         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11484         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11485
11486         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11487         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11488         {}
11489 };
11490
11491 static struct hda_verb alc262_sony_unsol_verbs[] = {
11492         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11493         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11494         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11495
11496         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11497         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11498         {}
11499 };
11500
11501 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11502         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11503         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11504         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11505         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11506         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11507         { } /* end */
11508 };
11509
11510 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11511         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11512         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11513         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11514         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11515         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11516         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11517         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11518         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11519         {}
11520 };
11521
11522 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11523 {
11524         struct alc_spec *spec = codec->spec;
11525
11526         spec->autocfg.hp_pins[0] = 0x15;
11527         spec->autocfg.speaker_pins[0] = 0x14;
11528         spec->ext_mic.pin = 0x18;
11529         spec->ext_mic.mux_idx = 0;
11530         spec->int_mic.pin = 0x12;
11531         spec->int_mic.mux_idx = 9;
11532         spec->auto_mic = 1;
11533 }
11534
11535 /*
11536  * nec model
11537  *  0x15 = headphone
11538  *  0x16 = internal speaker
11539  *  0x18 = external mic
11540  */
11541
11542 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11543         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11544         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11545
11546         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11547         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11548         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11549
11550         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11551         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11552         { } /* end */
11553 };
11554
11555 static struct hda_verb alc262_nec_verbs[] = {
11556         /* Unmute Speaker */
11557         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11558
11559         /* Headphone */
11560         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11561         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11562
11563         /* External mic to headphone */
11564         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11565         /* External mic to speaker */
11566         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11567         {}
11568 };
11569
11570 /*
11571  * fujitsu model
11572  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11573  *  0x1b = port replicator headphone out
11574  */
11575
11576 #define ALC_HP_EVENT    0x37
11577
11578 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11579         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11580         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11581         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11582         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11583         {}
11584 };
11585
11586 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11587         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11588         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11589         {}
11590 };
11591
11592 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11593         /* Front Mic pin: input vref at 50% */
11594         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11595         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11596         {}
11597 };
11598
11599 static struct hda_input_mux alc262_fujitsu_capture_source = {
11600         .num_items = 3,
11601         .items = {
11602                 { "Mic", 0x0 },
11603                 { "Int Mic", 0x1 },
11604                 { "CD", 0x4 },
11605         },
11606 };
11607
11608 static struct hda_input_mux alc262_HP_capture_source = {
11609         .num_items = 5,
11610         .items = {
11611                 { "Mic", 0x0 },
11612                 { "Front Mic", 0x1 },
11613                 { "Line", 0x2 },
11614                 { "CD", 0x4 },
11615                 { "AUX IN", 0x6 },
11616         },
11617 };
11618
11619 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11620         .num_items = 4,
11621         .items = {
11622                 { "Mic", 0x0 },
11623                 { "Front Mic", 0x2 },
11624                 { "Line", 0x1 },
11625                 { "CD", 0x4 },
11626         },
11627 };
11628
11629 /* mute/unmute internal speaker according to the hp jacks and mute state */
11630 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11631 {
11632         struct alc_spec *spec = codec->spec;
11633         unsigned int mute;
11634
11635         if (force || !spec->sense_updated) {
11636                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11637                                      snd_hda_jack_detect(codec, 0x1b);
11638                 spec->sense_updated = 1;
11639         }
11640         /* unmute internal speaker only if both HPs are unplugged and
11641          * master switch is on
11642          */
11643         if (spec->jack_present)
11644                 mute = HDA_AMP_MUTE;
11645         else
11646                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11647         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11648                                  HDA_AMP_MUTE, mute);
11649 }
11650
11651 /* unsolicited event for HP jack sensing */
11652 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11653                                        unsigned int res)
11654 {
11655         if ((res >> 26) != ALC_HP_EVENT)
11656                 return;
11657         alc262_fujitsu_automute(codec, 1);
11658 }
11659
11660 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11661 {
11662         alc262_fujitsu_automute(codec, 1);
11663 }
11664
11665 /* bind volumes of both NID 0x0c and 0x0d */
11666 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11667         .ops = &snd_hda_bind_vol,
11668         .values = {
11669                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11670                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11671                 0
11672         },
11673 };
11674
11675 /* mute/unmute internal speaker according to the hp jack and mute state */
11676 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11677 {
11678         struct alc_spec *spec = codec->spec;
11679         unsigned int mute;
11680
11681         if (force || !spec->sense_updated) {
11682                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11683                 spec->sense_updated = 1;
11684         }
11685         if (spec->jack_present) {
11686                 /* mute internal speaker */
11687                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11688                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11689                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11690                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11691         } else {
11692                 /* unmute internal speaker if necessary */
11693                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11694                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11695                                          HDA_AMP_MUTE, mute);
11696                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11697                                          HDA_AMP_MUTE, mute);
11698         }
11699 }
11700
11701 /* unsolicited event for HP jack sensing */
11702 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11703                                        unsigned int res)
11704 {
11705         if ((res >> 26) != ALC_HP_EVENT)
11706                 return;
11707         alc262_lenovo_3000_automute(codec, 1);
11708 }
11709
11710 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11711                                   int dir, int idx, long *valp)
11712 {
11713         int i, change = 0;
11714
11715         for (i = 0; i < 2; i++, valp++)
11716                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11717                                                    HDA_AMP_MUTE,
11718                                                    *valp ? 0 : HDA_AMP_MUTE);
11719         return change;
11720 }
11721
11722 /* bind hp and internal speaker mute (with plug check) */
11723 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11724                                          struct snd_ctl_elem_value *ucontrol)
11725 {
11726         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11727         long *valp = ucontrol->value.integer.value;
11728         int change;
11729
11730         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11731         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11732         if (change)
11733                 alc262_fujitsu_automute(codec, 0);
11734         return change;
11735 }
11736
11737 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11738         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11739         {
11740                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11741                 .name = "Master Playback Switch",
11742                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11743                 .info = snd_hda_mixer_amp_switch_info,
11744                 .get = snd_hda_mixer_amp_switch_get,
11745                 .put = alc262_fujitsu_master_sw_put,
11746                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11747         },
11748         {
11749                 .iface = NID_MAPPING,
11750                 .name = "Master Playback Switch",
11751                 .private_value = 0x1b,
11752         },
11753         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11754         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11755         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11756         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11757         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11758         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11759         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11760         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11761         { } /* end */
11762 };
11763
11764 /* bind hp and internal speaker mute (with plug check) */
11765 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11766                                          struct snd_ctl_elem_value *ucontrol)
11767 {
11768         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11769         long *valp = ucontrol->value.integer.value;
11770         int change;
11771
11772         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11773         if (change)
11774                 alc262_lenovo_3000_automute(codec, 0);
11775         return change;
11776 }
11777
11778 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11779         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11780         {
11781                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11782                 .name = "Master Playback Switch",
11783                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11784                 .info = snd_hda_mixer_amp_switch_info,
11785                 .get = snd_hda_mixer_amp_switch_get,
11786                 .put = alc262_lenovo_3000_master_sw_put,
11787                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11788         },
11789         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11790         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11791         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11792         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11794         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11795         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11796         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11797         { } /* end */
11798 };
11799
11800 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11801         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11802         ALC262_HIPPO_MASTER_SWITCH,
11803         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11805         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11806         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11807         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11808         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11809         { } /* end */
11810 };
11811
11812 /* additional init verbs for Benq laptops */
11813 static struct hda_verb alc262_EAPD_verbs[] = {
11814         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11815         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11816         {}
11817 };
11818
11819 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11820         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11821         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11822
11823         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11824         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11825         {}
11826 };
11827
11828 /* Samsung Q1 Ultra Vista model setup */
11829 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11830         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11831         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11832         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11833         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11834         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11835         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11836         { } /* end */
11837 };
11838
11839 static struct hda_verb alc262_ultra_verbs[] = {
11840         /* output mixer */
11841         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11842         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11843         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11844         /* speaker */
11845         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11846         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11847         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11848         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11849         /* HP */
11850         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11851         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11852         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11853         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11854         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11855         /* internal mic */
11856         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11857         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11858         /* ADC, choose mic */
11859         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11860         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11861         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11862         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11863         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11864         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11865         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11866         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11867         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11868         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11869         {}
11870 };
11871
11872 /* mute/unmute internal speaker according to the hp jack and mute state */
11873 static void alc262_ultra_automute(struct hda_codec *codec)
11874 {
11875         struct alc_spec *spec = codec->spec;
11876         unsigned int mute;
11877
11878         mute = 0;
11879         /* auto-mute only when HP is used as HP */
11880         if (!spec->cur_mux[0]) {
11881                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11882                 if (spec->jack_present)
11883                         mute = HDA_AMP_MUTE;
11884         }
11885         /* mute/unmute internal speaker */
11886         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11887                                  HDA_AMP_MUTE, mute);
11888         /* mute/unmute HP */
11889         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11890                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11891 }
11892
11893 /* unsolicited event for HP jack sensing */
11894 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11895                                        unsigned int res)
11896 {
11897         if ((res >> 26) != ALC880_HP_EVENT)
11898                 return;
11899         alc262_ultra_automute(codec);
11900 }
11901
11902 static struct hda_input_mux alc262_ultra_capture_source = {
11903         .num_items = 2,
11904         .items = {
11905                 { "Mic", 0x1 },
11906                 { "Headphone", 0x7 },
11907         },
11908 };
11909
11910 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11911                                      struct snd_ctl_elem_value *ucontrol)
11912 {
11913         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11914         struct alc_spec *spec = codec->spec;
11915         int ret;
11916
11917         ret = alc_mux_enum_put(kcontrol, ucontrol);
11918         if (!ret)
11919                 return 0;
11920         /* reprogram the HP pin as mic or HP according to the input source */
11921         snd_hda_codec_write_cache(codec, 0x15, 0,
11922                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11923                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11924         alc262_ultra_automute(codec); /* mute/unmute HP */
11925         return ret;
11926 }
11927
11928 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11929         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11930         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11931         {
11932                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11933                 .name = "Capture Source",
11934                 .info = alc_mux_enum_info,
11935                 .get = alc_mux_enum_get,
11936                 .put = alc262_ultra_mux_enum_put,
11937         },
11938         {
11939                 .iface = NID_MAPPING,
11940                 .name = "Capture Source",
11941                 .private_value = 0x15,
11942         },
11943         { } /* end */
11944 };
11945
11946 /* We use two mixers depending on the output pin; 0x16 is a mono output
11947  * and thus it's bound with a different mixer.
11948  * This function returns which mixer amp should be used.
11949  */
11950 static int alc262_check_volbit(hda_nid_t nid)
11951 {
11952         if (!nid)
11953                 return 0;
11954         else if (nid == 0x16)
11955                 return 2;
11956         else
11957                 return 1;
11958 }
11959
11960 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11961                                   const char *pfx, int *vbits, int idx)
11962 {
11963         unsigned long val;
11964         int vbit;
11965
11966         vbit = alc262_check_volbit(nid);
11967         if (!vbit)
11968                 return 0;
11969         if (*vbits & vbit) /* a volume control for this mixer already there */
11970                 return 0;
11971         *vbits |= vbit;
11972         if (vbit == 2)
11973                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11974         else
11975                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11976         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
11977 }
11978
11979 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11980                                  const char *pfx, int idx)
11981 {
11982         unsigned long val;
11983
11984         if (!nid)
11985                 return 0;
11986         if (nid == 0x16)
11987                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11988         else
11989                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11990         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
11991 }
11992
11993 /* add playback controls from the parsed DAC table */
11994 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11995                                              const struct auto_pin_cfg *cfg)
11996 {
11997         const char *pfx;
11998         int vbits;
11999         int i, err;
12000
12001         spec->multiout.num_dacs = 1;    /* only use one dac */
12002         spec->multiout.dac_nids = spec->private_dac_nids;
12003         spec->multiout.dac_nids[0] = 2;
12004
12005         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
12006                 pfx = "Master";
12007         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12008                 pfx = "Speaker";
12009         else if (cfg->line_out_type == AUTO_PIN_HP_OUT)
12010                 pfx = "Headphone";
12011         else
12012                 pfx = "Front";
12013         for (i = 0; i < 2; i++) {
12014                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12015                 if (err < 0)
12016                         return err;
12017                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12018                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12019                                                     "Speaker", i);
12020                         if (err < 0)
12021                                 return err;
12022                 }
12023                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12024                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12025                                                     "Headphone", i);
12026                         if (err < 0)
12027                                 return err;
12028                 }
12029         }
12030
12031         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12032                 alc262_check_volbit(cfg->speaker_pins[0]) |
12033                 alc262_check_volbit(cfg->hp_pins[0]);
12034         if (vbits == 1 || vbits == 2)
12035                 pfx = "Master"; /* only one mixer is used */
12036         vbits = 0;
12037         for (i = 0; i < 2; i++) {
12038                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12039                                              &vbits, i);
12040                 if (err < 0)
12041                         return err;
12042                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12043                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12044                                                      "Speaker", &vbits, i);
12045                         if (err < 0)
12046                                 return err;
12047                 }
12048                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12049                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12050                                                      "Headphone", &vbits, i);
12051                         if (err < 0)
12052                                 return err;
12053                 }
12054         }
12055         return 0;
12056 }
12057
12058 #define alc262_auto_create_input_ctls \
12059         alc882_auto_create_input_ctls
12060
12061 /*
12062  * generic initialization of ADC, input mixers and output mixers
12063  */
12064 static struct hda_verb alc262_volume_init_verbs[] = {
12065         /*
12066          * Unmute ADC0-2 and set the default input to mic-in
12067          */
12068         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12069         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12070         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12071         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12072         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12073         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12074
12075         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12076          * mixer widget
12077          * Note: PASD motherboards uses the Line In 2 as the input for
12078          * front panel mic (mic 2)
12079          */
12080         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12081         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12082         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12083         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12084         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12085         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12086
12087         /*
12088          * Set up output mixers (0x0c - 0x0f)
12089          */
12090         /* set vol=0 to output mixers */
12091         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12092         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12093         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12094
12095         /* set up input amps for analog loopback */
12096         /* Amp Indices: DAC = 0, mixer = 1 */
12097         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12098         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12099         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12100         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12101         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12102         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12103
12104         /* FIXME: use matrix-type input source selection */
12105         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12106         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12107         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12108         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12109         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12110         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12111         /* Input mixer2 */
12112         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12113         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12114         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12115         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12116         /* Input mixer3 */
12117         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12118         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12119         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12120         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12121
12122         { }
12123 };
12124
12125 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12126         /*
12127          * Unmute ADC0-2 and set the default input to mic-in
12128          */
12129         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12130         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12131         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12132         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12133         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12134         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12135
12136         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12137          * mixer widget
12138          * Note: PASD motherboards uses the Line In 2 as the input for
12139          * front panel mic (mic 2)
12140          */
12141         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12142         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12143         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12144         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12145         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12146         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12147         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12148         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12149
12150         /*
12151          * Set up output mixers (0x0c - 0x0e)
12152          */
12153         /* set vol=0 to output mixers */
12154         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12155         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12156         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12157
12158         /* set up input amps for analog loopback */
12159         /* Amp Indices: DAC = 0, mixer = 1 */
12160         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12161         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12162         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12163         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12164         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12165         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12166
12167         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12168         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12169         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12170
12171         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12172         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12173
12174         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12175         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12176
12177         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12178         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12179         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12180         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12181         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12182
12183         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12184         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12185         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12186         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12187         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12188         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12189
12190
12191         /* FIXME: use matrix-type input source selection */
12192         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12193         /* Input mixer1: only unmute Mic */
12194         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12195         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12196         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12197         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12198         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12199         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12200         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12201         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12202         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12203         /* Input mixer2 */
12204         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12205         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12206         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12207         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12208         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12209         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12210         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12211         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12212         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12213         /* Input mixer3 */
12214         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12215         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12216         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12217         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12218         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12219         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12220         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12221         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12222         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12223
12224         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12225
12226         { }
12227 };
12228
12229 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12230         /*
12231          * Unmute ADC0-2 and set the default input to mic-in
12232          */
12233         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12234         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12235         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12236         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12237         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12238         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12239
12240         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12241          * mixer widget
12242          * Note: PASD motherboards uses the Line In 2 as the input for front
12243          * panel mic (mic 2)
12244          */
12245         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12246         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12247         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12248         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12249         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12250         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12251         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12252         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12253         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12254         /*
12255          * Set up output mixers (0x0c - 0x0e)
12256          */
12257         /* set vol=0 to output mixers */
12258         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12259         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12260         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12261
12262         /* set up input amps for analog loopback */
12263         /* Amp Indices: DAC = 0, mixer = 1 */
12264         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12265         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12266         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12267         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12268         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12269         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12270
12271
12272         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12273         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12274         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12275         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12276         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12277         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12278         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12279
12280         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12281         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12282
12283         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12284         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12285
12286         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12287         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12288         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12289         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12290         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12291         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12292
12293         /* FIXME: use matrix-type input source selection */
12294         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12295         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12296         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12297         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12298         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12299         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12300         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12301         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12302         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12303         /* Input mixer2 */
12304         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12305         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12306         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12307         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12308         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12309         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12310         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12311         /* Input mixer3 */
12312         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12313         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12314         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12315         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12316         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12317         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12318         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12319
12320         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12321
12322         { }
12323 };
12324
12325 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12326
12327         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12328         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12329         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12330
12331         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12332         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12333         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12334         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12335
12336         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12337         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12338         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12339         {}
12340 };
12341
12342 /*
12343  * Pin config fixes
12344  */
12345 enum {
12346         PINFIX_FSC_H270,
12347 };
12348
12349 static const struct alc_fixup alc262_fixups[] = {
12350         [PINFIX_FSC_H270] = {
12351                 .pins = (const struct alc_pincfg[]) {
12352                         { 0x14, 0x99130110 }, /* speaker */
12353                         { 0x15, 0x0221142f }, /* front HP */
12354                         { 0x1b, 0x0121141f }, /* rear HP */
12355                         { }
12356                 }
12357         },
12358         [PINFIX_PB_M5210] = {
12359                 .verbs = (const struct hda_verb[]) {
12360                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
12361                         {}
12362                 }
12363         },
12364 };
12365
12366 static struct snd_pci_quirk alc262_fixup_tbl[] = {
12367         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12368         {}
12369 };
12370
12371
12372 #ifdef CONFIG_SND_HDA_POWER_SAVE
12373 #define alc262_loopbacks        alc880_loopbacks
12374 #endif
12375
12376 /* pcm configuration: identical with ALC880 */
12377 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12378 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12379 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12380 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12381
12382 /*
12383  * BIOS auto configuration
12384  */
12385 static int alc262_parse_auto_config(struct hda_codec *codec)
12386 {
12387         struct alc_spec *spec = codec->spec;
12388         int err;
12389         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12390
12391         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12392                                            alc262_ignore);
12393         if (err < 0)
12394                 return err;
12395         if (!spec->autocfg.line_outs) {
12396                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12397                         spec->multiout.max_channels = 2;
12398                         spec->no_analog = 1;
12399                         goto dig_only;
12400                 }
12401                 return 0; /* can't find valid BIOS pin config */
12402         }
12403         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12404         if (err < 0)
12405                 return err;
12406         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12407         if (err < 0)
12408                 return err;
12409
12410         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12411
12412  dig_only:
12413         alc_auto_parse_digital(codec);
12414
12415         if (spec->kctls.list)
12416                 add_mixer(spec, spec->kctls.list);
12417
12418         add_verb(spec, alc262_volume_init_verbs);
12419         spec->num_mux_defs = 1;
12420         spec->input_mux = &spec->private_imux[0];
12421
12422         err = alc_auto_add_mic_boost(codec);
12423         if (err < 0)
12424                 return err;
12425
12426         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12427
12428         return 1;
12429 }
12430
12431 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12432 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12433 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12434 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12435
12436
12437 /* init callback for auto-configuration model -- overriding the default init */
12438 static void alc262_auto_init(struct hda_codec *codec)
12439 {
12440         struct alc_spec *spec = codec->spec;
12441         alc262_auto_init_multi_out(codec);
12442         alc262_auto_init_hp_out(codec);
12443         alc262_auto_init_analog_input(codec);
12444         alc262_auto_init_input_src(codec);
12445         alc_auto_init_digital(codec);
12446         if (spec->unsol_event)
12447                 alc_inithook(codec);
12448 }
12449
12450 /*
12451  * configuration and preset
12452  */
12453 static const char *alc262_models[ALC262_MODEL_LAST] = {
12454         [ALC262_BASIC]          = "basic",
12455         [ALC262_HIPPO]          = "hippo",
12456         [ALC262_HIPPO_1]        = "hippo_1",
12457         [ALC262_FUJITSU]        = "fujitsu",
12458         [ALC262_HP_BPC]         = "hp-bpc",
12459         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12460         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12461         [ALC262_HP_RP5700]      = "hp-rp5700",
12462         [ALC262_BENQ_ED8]       = "benq",
12463         [ALC262_BENQ_T31]       = "benq-t31",
12464         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12465         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12466         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12467         [ALC262_ULTRA]          = "ultra",
12468         [ALC262_LENOVO_3000]    = "lenovo-3000",
12469         [ALC262_NEC]            = "nec",
12470         [ALC262_TYAN]           = "tyan",
12471         [ALC262_AUTO]           = "auto",
12472 };
12473
12474 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12475         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12476         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12477         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12478                            ALC262_HP_BPC),
12479         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12480                            ALC262_HP_BPC),
12481         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12482                            ALC262_HP_BPC),
12483         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12484         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12485         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12486         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12487         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12488         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12489         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12490         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12491         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12492         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12493         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12494         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12495                       ALC262_HP_TC_T5735),
12496         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12497         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12498         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12499         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12500         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12501         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12502         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12503         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12504 #if 0 /* disable the quirk since model=auto works better in recent versions */
12505         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12506                            ALC262_SONY_ASSAMD),
12507 #endif
12508         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12509                       ALC262_TOSHIBA_RX1),
12510         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12511         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12512         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12513         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12514         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12515                            ALC262_ULTRA),
12516         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12517         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12518         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12519         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12520         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12521         {}
12522 };
12523
12524 static struct alc_config_preset alc262_presets[] = {
12525         [ALC262_BASIC] = {
12526                 .mixers = { alc262_base_mixer },
12527                 .init_verbs = { alc262_init_verbs },
12528                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12529                 .dac_nids = alc262_dac_nids,
12530                 .hp_nid = 0x03,
12531                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12532                 .channel_mode = alc262_modes,
12533                 .input_mux = &alc262_capture_source,
12534         },
12535         [ALC262_HIPPO] = {
12536                 .mixers = { alc262_hippo_mixer },
12537                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12538                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12539                 .dac_nids = alc262_dac_nids,
12540                 .hp_nid = 0x03,
12541                 .dig_out_nid = ALC262_DIGOUT_NID,
12542                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12543                 .channel_mode = alc262_modes,
12544                 .input_mux = &alc262_capture_source,
12545                 .unsol_event = alc262_hippo_unsol_event,
12546                 .setup = alc262_hippo_setup,
12547                 .init_hook = alc262_hippo_automute,
12548         },
12549         [ALC262_HIPPO_1] = {
12550                 .mixers = { alc262_hippo1_mixer },
12551                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12552                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12553                 .dac_nids = alc262_dac_nids,
12554                 .hp_nid = 0x02,
12555                 .dig_out_nid = ALC262_DIGOUT_NID,
12556                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12557                 .channel_mode = alc262_modes,
12558                 .input_mux = &alc262_capture_source,
12559                 .unsol_event = alc262_hippo_unsol_event,
12560                 .setup = alc262_hippo1_setup,
12561                 .init_hook = alc262_hippo_automute,
12562         },
12563         [ALC262_FUJITSU] = {
12564                 .mixers = { alc262_fujitsu_mixer },
12565                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12566                                 alc262_fujitsu_unsol_verbs },
12567                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12568                 .dac_nids = alc262_dac_nids,
12569                 .hp_nid = 0x03,
12570                 .dig_out_nid = ALC262_DIGOUT_NID,
12571                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12572                 .channel_mode = alc262_modes,
12573                 .input_mux = &alc262_fujitsu_capture_source,
12574                 .unsol_event = alc262_fujitsu_unsol_event,
12575                 .init_hook = alc262_fujitsu_init_hook,
12576         },
12577         [ALC262_HP_BPC] = {
12578                 .mixers = { alc262_HP_BPC_mixer },
12579                 .init_verbs = { alc262_HP_BPC_init_verbs },
12580                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12581                 .dac_nids = alc262_dac_nids,
12582                 .hp_nid = 0x03,
12583                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12584                 .channel_mode = alc262_modes,
12585                 .input_mux = &alc262_HP_capture_source,
12586                 .unsol_event = alc262_hp_bpc_unsol_event,
12587                 .init_hook = alc262_hp_bpc_automute,
12588         },
12589         [ALC262_HP_BPC_D7000_WF] = {
12590                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12591                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12592                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12593                 .dac_nids = alc262_dac_nids,
12594                 .hp_nid = 0x03,
12595                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12596                 .channel_mode = alc262_modes,
12597                 .input_mux = &alc262_HP_D7000_capture_source,
12598                 .unsol_event = alc262_hp_wildwest_unsol_event,
12599                 .init_hook = alc262_hp_wildwest_automute,
12600         },
12601         [ALC262_HP_BPC_D7000_WL] = {
12602                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12603                             alc262_HP_BPC_WildWest_option_mixer },
12604                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12605                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12606                 .dac_nids = alc262_dac_nids,
12607                 .hp_nid = 0x03,
12608                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12609                 .channel_mode = alc262_modes,
12610                 .input_mux = &alc262_HP_D7000_capture_source,
12611                 .unsol_event = alc262_hp_wildwest_unsol_event,
12612                 .init_hook = alc262_hp_wildwest_automute,
12613         },
12614         [ALC262_HP_TC_T5735] = {
12615                 .mixers = { alc262_hp_t5735_mixer },
12616                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12617                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12618                 .dac_nids = alc262_dac_nids,
12619                 .hp_nid = 0x03,
12620                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12621                 .channel_mode = alc262_modes,
12622                 .input_mux = &alc262_capture_source,
12623                 .unsol_event = alc_sku_unsol_event,
12624                 .setup = alc262_hp_t5735_setup,
12625                 .init_hook = alc_inithook,
12626         },
12627         [ALC262_HP_RP5700] = {
12628                 .mixers = { alc262_hp_rp5700_mixer },
12629                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12630                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12631                 .dac_nids = alc262_dac_nids,
12632                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12633                 .channel_mode = alc262_modes,
12634                 .input_mux = &alc262_hp_rp5700_capture_source,
12635         },
12636         [ALC262_BENQ_ED8] = {
12637                 .mixers = { alc262_base_mixer },
12638                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12639                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12640                 .dac_nids = alc262_dac_nids,
12641                 .hp_nid = 0x03,
12642                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12643                 .channel_mode = alc262_modes,
12644                 .input_mux = &alc262_capture_source,
12645         },
12646         [ALC262_SONY_ASSAMD] = {
12647                 .mixers = { alc262_sony_mixer },
12648                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12649                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12650                 .dac_nids = alc262_dac_nids,
12651                 .hp_nid = 0x02,
12652                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12653                 .channel_mode = alc262_modes,
12654                 .input_mux = &alc262_capture_source,
12655                 .unsol_event = alc262_hippo_unsol_event,
12656                 .setup = alc262_hippo_setup,
12657                 .init_hook = alc262_hippo_automute,
12658         },
12659         [ALC262_BENQ_T31] = {
12660                 .mixers = { alc262_benq_t31_mixer },
12661                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12662                                 alc_hp15_unsol_verbs },
12663                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12664                 .dac_nids = alc262_dac_nids,
12665                 .hp_nid = 0x03,
12666                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12667                 .channel_mode = alc262_modes,
12668                 .input_mux = &alc262_capture_source,
12669                 .unsol_event = alc262_hippo_unsol_event,
12670                 .setup = alc262_hippo_setup,
12671                 .init_hook = alc262_hippo_automute,
12672         },
12673         [ALC262_ULTRA] = {
12674                 .mixers = { alc262_ultra_mixer },
12675                 .cap_mixer = alc262_ultra_capture_mixer,
12676                 .init_verbs = { alc262_ultra_verbs },
12677                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12678                 .dac_nids = alc262_dac_nids,
12679                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12680                 .channel_mode = alc262_modes,
12681                 .input_mux = &alc262_ultra_capture_source,
12682                 .adc_nids = alc262_adc_nids, /* ADC0 */
12683                 .capsrc_nids = alc262_capsrc_nids,
12684                 .num_adc_nids = 1, /* single ADC */
12685                 .unsol_event = alc262_ultra_unsol_event,
12686                 .init_hook = alc262_ultra_automute,
12687         },
12688         [ALC262_LENOVO_3000] = {
12689                 .mixers = { alc262_lenovo_3000_mixer },
12690                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12691                                 alc262_lenovo_3000_unsol_verbs,
12692                                 alc262_lenovo_3000_init_verbs },
12693                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12694                 .dac_nids = alc262_dac_nids,
12695                 .hp_nid = 0x03,
12696                 .dig_out_nid = ALC262_DIGOUT_NID,
12697                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12698                 .channel_mode = alc262_modes,
12699                 .input_mux = &alc262_fujitsu_capture_source,
12700                 .unsol_event = alc262_lenovo_3000_unsol_event,
12701         },
12702         [ALC262_NEC] = {
12703                 .mixers = { alc262_nec_mixer },
12704                 .init_verbs = { alc262_nec_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         },
12712         [ALC262_TOSHIBA_S06] = {
12713                 .mixers = { alc262_toshiba_s06_mixer },
12714                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12715                                                         alc262_eapd_verbs },
12716                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12717                 .capsrc_nids = alc262_dmic_capsrc_nids,
12718                 .dac_nids = alc262_dac_nids,
12719                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12720                 .num_adc_nids = 1, /* single ADC */
12721                 .dig_out_nid = ALC262_DIGOUT_NID,
12722                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12723                 .channel_mode = alc262_modes,
12724                 .unsol_event = alc_sku_unsol_event,
12725                 .setup = alc262_toshiba_s06_setup,
12726                 .init_hook = alc_inithook,
12727         },
12728         [ALC262_TOSHIBA_RX1] = {
12729                 .mixers = { alc262_toshiba_rx1_mixer },
12730                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12731                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12732                 .dac_nids = alc262_dac_nids,
12733                 .hp_nid = 0x03,
12734                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12735                 .channel_mode = alc262_modes,
12736                 .input_mux = &alc262_capture_source,
12737                 .unsol_event = alc262_hippo_unsol_event,
12738                 .setup = alc262_hippo_setup,
12739                 .init_hook = alc262_hippo_automute,
12740         },
12741         [ALC262_TYAN] = {
12742                 .mixers = { alc262_tyan_mixer },
12743                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12744                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12745                 .dac_nids = alc262_dac_nids,
12746                 .hp_nid = 0x02,
12747                 .dig_out_nid = ALC262_DIGOUT_NID,
12748                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12749                 .channel_mode = alc262_modes,
12750                 .input_mux = &alc262_capture_source,
12751                 .unsol_event = alc_automute_amp_unsol_event,
12752                 .setup = alc262_tyan_setup,
12753                 .init_hook = alc_automute_amp,
12754         },
12755 };
12756
12757 static int patch_alc262(struct hda_codec *codec)
12758 {
12759         struct alc_spec *spec;
12760         int board_config;
12761         int err;
12762
12763         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12764         if (spec == NULL)
12765                 return -ENOMEM;
12766
12767         codec->spec = spec;
12768 #if 0
12769         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12770          * under-run
12771          */
12772         {
12773         int tmp;
12774         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12775         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12776         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12777         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12778         }
12779 #endif
12780         alc_auto_parse_customize_define(codec);
12781
12782         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12783
12784         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12785                                                   alc262_models,
12786                                                   alc262_cfg_tbl);
12787
12788         if (board_config < 0) {
12789                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12790                        codec->chip_name);
12791                 board_config = ALC262_AUTO;
12792         }
12793
12794         if (board_config == ALC262_AUTO)
12795                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1);
12796
12797         if (board_config == ALC262_AUTO) {
12798                 /* automatic parse from the BIOS config */
12799                 err = alc262_parse_auto_config(codec);
12800                 if (err < 0) {
12801                         alc_free(codec);
12802                         return err;
12803                 } else if (!err) {
12804                         printk(KERN_INFO
12805                                "hda_codec: Cannot set up configuration "
12806                                "from BIOS.  Using base mode...\n");
12807                         board_config = ALC262_BASIC;
12808                 }
12809         }
12810
12811         if (!spec->no_analog && has_cdefine_beep(codec)) {
12812                 err = snd_hda_attach_beep_device(codec, 0x1);
12813                 if (err < 0) {
12814                         alc_free(codec);
12815                         return err;
12816                 }
12817         }
12818
12819         if (board_config != ALC262_AUTO)
12820                 setup_preset(codec, &alc262_presets[board_config]);
12821
12822         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12823         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12824
12825         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12826         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12827
12828         if (!spec->adc_nids && spec->input_mux) {
12829                 int i;
12830                 /* check whether the digital-mic has to be supported */
12831                 for (i = 0; i < spec->input_mux->num_items; i++) {
12832                         if (spec->input_mux->items[i].index >= 9)
12833                                 break;
12834                 }
12835                 if (i < spec->input_mux->num_items) {
12836                         /* use only ADC0 */
12837                         spec->adc_nids = alc262_dmic_adc_nids;
12838                         spec->num_adc_nids = 1;
12839                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12840                 } else {
12841                         /* all analog inputs */
12842                         /* check whether NID 0x07 is valid */
12843                         unsigned int wcap = get_wcaps(codec, 0x07);
12844
12845                         /* get type */
12846                         wcap = get_wcaps_type(wcap);
12847                         if (wcap != AC_WID_AUD_IN) {
12848                                 spec->adc_nids = alc262_adc_nids_alt;
12849                                 spec->num_adc_nids =
12850                                         ARRAY_SIZE(alc262_adc_nids_alt);
12851                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12852                         } else {
12853                                 spec->adc_nids = alc262_adc_nids;
12854                                 spec->num_adc_nids =
12855                                         ARRAY_SIZE(alc262_adc_nids);
12856                                 spec->capsrc_nids = alc262_capsrc_nids;
12857                         }
12858                 }
12859         }
12860         if (!spec->cap_mixer && !spec->no_analog)
12861                 set_capture_mixer(codec);
12862         if (!spec->no_analog && has_cdefine_beep(codec))
12863                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12864
12865         if (board_config == ALC262_AUTO)
12866                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0);
12867
12868         spec->vmaster_nid = 0x0c;
12869
12870         codec->patch_ops = alc_patch_ops;
12871         if (board_config == ALC262_AUTO)
12872                 spec->init_hook = alc262_auto_init;
12873 #ifdef CONFIG_SND_HDA_POWER_SAVE
12874         if (!spec->loopback.amplist)
12875                 spec->loopback.amplist = alc262_loopbacks;
12876 #endif
12877
12878         return 0;
12879 }
12880
12881 /*
12882  *  ALC268 channel source setting (2 channel)
12883  */
12884 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12885 #define alc268_modes            alc260_modes
12886
12887 static hda_nid_t alc268_dac_nids[2] = {
12888         /* front, hp */
12889         0x02, 0x03
12890 };
12891
12892 static hda_nid_t alc268_adc_nids[2] = {
12893         /* ADC0-1 */
12894         0x08, 0x07
12895 };
12896
12897 static hda_nid_t alc268_adc_nids_alt[1] = {
12898         /* ADC0 */
12899         0x08
12900 };
12901
12902 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12903
12904 static struct snd_kcontrol_new alc268_base_mixer[] = {
12905         /* output mixer control */
12906         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12907         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12908         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12909         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12910         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12911         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12912         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12913         { }
12914 };
12915
12916 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12917         /* output mixer control */
12918         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12919         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12920         ALC262_HIPPO_MASTER_SWITCH,
12921         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12922         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12923         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12924         { }
12925 };
12926
12927 /* bind Beep switches of both NID 0x0f and 0x10 */
12928 static struct hda_bind_ctls alc268_bind_beep_sw = {
12929         .ops = &snd_hda_bind_sw,
12930         .values = {
12931                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12932                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12933                 0
12934         },
12935 };
12936
12937 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12938         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12939         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12940         { }
12941 };
12942
12943 static struct hda_verb alc268_eapd_verbs[] = {
12944         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12945         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12946         { }
12947 };
12948
12949 /* Toshiba specific */
12950 static struct hda_verb alc268_toshiba_verbs[] = {
12951         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12952         { } /* end */
12953 };
12954
12955 /* Acer specific */
12956 /* bind volumes of both NID 0x02 and 0x03 */
12957 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12958         .ops = &snd_hda_bind_vol,
12959         .values = {
12960                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12961                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12962                 0
12963         },
12964 };
12965
12966 /* mute/unmute internal speaker according to the hp jack and mute state */
12967 static void alc268_acer_automute(struct hda_codec *codec, int force)
12968 {
12969         struct alc_spec *spec = codec->spec;
12970         unsigned int mute;
12971
12972         if (force || !spec->sense_updated) {
12973                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12974                 spec->sense_updated = 1;
12975         }
12976         if (spec->jack_present)
12977                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12978         else /* unmute internal speaker if necessary */
12979                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12980         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12981                                  HDA_AMP_MUTE, mute);
12982 }
12983
12984
12985 /* bind hp and internal speaker mute (with plug check) */
12986 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12987                                      struct snd_ctl_elem_value *ucontrol)
12988 {
12989         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12990         long *valp = ucontrol->value.integer.value;
12991         int change;
12992
12993         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12994         if (change)
12995                 alc268_acer_automute(codec, 0);
12996         return change;
12997 }
12998
12999 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13000         /* output mixer control */
13001         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13002         {
13003                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13004                 .name = "Master Playback Switch",
13005                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13006                 .info = snd_hda_mixer_amp_switch_info,
13007                 .get = snd_hda_mixer_amp_switch_get,
13008                 .put = alc268_acer_master_sw_put,
13009                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13010         },
13011         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13012         { }
13013 };
13014
13015 static struct snd_kcontrol_new alc268_acer_mixer[] = {
13016         /* output mixer control */
13017         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13018         {
13019                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13020                 .name = "Master Playback Switch",
13021                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13022                 .info = snd_hda_mixer_amp_switch_info,
13023                 .get = snd_hda_mixer_amp_switch_get,
13024                 .put = alc268_acer_master_sw_put,
13025                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13026         },
13027         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13028         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13029         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13030         { }
13031 };
13032
13033 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13034         /* output mixer control */
13035         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13036         {
13037                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13038                 .name = "Master Playback Switch",
13039                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13040                 .info = snd_hda_mixer_amp_switch_info,
13041                 .get = snd_hda_mixer_amp_switch_get,
13042                 .put = alc268_acer_master_sw_put,
13043                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13044         },
13045         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13046         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13047         { }
13048 };
13049
13050 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13051         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13052         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13053         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13054         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13055         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13056         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13057         { }
13058 };
13059
13060 static struct hda_verb alc268_acer_verbs[] = {
13061         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13062         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13063         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13064         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13065         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13066         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13067         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13068         { }
13069 };
13070
13071 /* unsolicited event for HP jack sensing */
13072 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
13073 #define alc268_toshiba_setup            alc262_hippo_setup
13074 #define alc268_toshiba_automute         alc262_hippo_automute
13075
13076 static void alc268_acer_unsol_event(struct hda_codec *codec,
13077                                        unsigned int res)
13078 {
13079         if ((res >> 26) != ALC880_HP_EVENT)
13080                 return;
13081         alc268_acer_automute(codec, 1);
13082 }
13083
13084 static void alc268_acer_init_hook(struct hda_codec *codec)
13085 {
13086         alc268_acer_automute(codec, 1);
13087 }
13088
13089 /* toggle speaker-output according to the hp-jack state */
13090 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13091 {
13092         unsigned int present;
13093         unsigned char bits;
13094
13095         present = snd_hda_jack_detect(codec, 0x15);
13096         bits = present ? HDA_AMP_MUTE : 0;
13097         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13098                                  HDA_AMP_MUTE, bits);
13099         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13100                                  HDA_AMP_MUTE, bits);
13101 }
13102
13103 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13104                                     unsigned int res)
13105 {
13106         switch (res >> 26) {
13107         case ALC880_HP_EVENT:
13108                 alc268_aspire_one_speaker_automute(codec);
13109                 break;
13110         case ALC880_MIC_EVENT:
13111                 alc_mic_automute(codec);
13112                 break;
13113         }
13114 }
13115
13116 static void alc268_acer_lc_setup(struct hda_codec *codec)
13117 {
13118         struct alc_spec *spec = codec->spec;
13119         spec->ext_mic.pin = 0x18;
13120         spec->ext_mic.mux_idx = 0;
13121         spec->int_mic.pin = 0x12;
13122         spec->int_mic.mux_idx = 6;
13123         spec->auto_mic = 1;
13124 }
13125
13126 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13127 {
13128         alc268_aspire_one_speaker_automute(codec);
13129         alc_mic_automute(codec);
13130 }
13131
13132 static struct snd_kcontrol_new alc268_dell_mixer[] = {
13133         /* output mixer control */
13134         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13135         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13136         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13137         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13138         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13139         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13140         { }
13141 };
13142
13143 static struct hda_verb alc268_dell_verbs[] = {
13144         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13145         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13146         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13147         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13148         { }
13149 };
13150
13151 /* mute/unmute internal speaker according to the hp jack and mute state */
13152 static void alc268_dell_setup(struct hda_codec *codec)
13153 {
13154         struct alc_spec *spec = codec->spec;
13155
13156         spec->autocfg.hp_pins[0] = 0x15;
13157         spec->autocfg.speaker_pins[0] = 0x14;
13158         spec->ext_mic.pin = 0x18;
13159         spec->ext_mic.mux_idx = 0;
13160         spec->int_mic.pin = 0x19;
13161         spec->int_mic.mux_idx = 1;
13162         spec->auto_mic = 1;
13163 }
13164
13165 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13166         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13167         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13168         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13169         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13170         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13171         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13172         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13173         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13174         { }
13175 };
13176
13177 static struct hda_verb alc267_quanta_il1_verbs[] = {
13178         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13179         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13180         { }
13181 };
13182
13183 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13184 {
13185         struct alc_spec *spec = codec->spec;
13186         spec->autocfg.hp_pins[0] = 0x15;
13187         spec->autocfg.speaker_pins[0] = 0x14;
13188         spec->ext_mic.pin = 0x18;
13189         spec->ext_mic.mux_idx = 0;
13190         spec->int_mic.pin = 0x19;
13191         spec->int_mic.mux_idx = 1;
13192         spec->auto_mic = 1;
13193 }
13194
13195 /*
13196  * generic initialization of ADC, input mixers and output mixers
13197  */
13198 static struct hda_verb alc268_base_init_verbs[] = {
13199         /* Unmute DAC0-1 and set vol = 0 */
13200         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13201         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13202
13203         /*
13204          * Set up output mixers (0x0c - 0x0e)
13205          */
13206         /* set vol=0 to output mixers */
13207         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13208         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13209
13210         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13211         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13212
13213         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13214         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13215         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13216         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13217         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13218         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13219         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13220         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13221
13222         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13223         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13224         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13225         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13226         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13227
13228         /* set PCBEEP vol = 0, mute connections */
13229         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13230         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13231         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13232
13233         /* Unmute Selector 23h,24h and set the default input to mic-in */
13234
13235         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13236         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13237         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13238         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13239
13240         { }
13241 };
13242
13243 /*
13244  * generic initialization of ADC, input mixers and output mixers
13245  */
13246 static struct hda_verb alc268_volume_init_verbs[] = {
13247         /* set output DAC */
13248         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13249         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13250
13251         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13252         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13253         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13254         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13255         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13256
13257         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13258         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13259         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13260
13261         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13262         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13263
13264         /* set PCBEEP vol = 0, mute connections */
13265         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13266         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13267         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13268
13269         { }
13270 };
13271
13272 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13273         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13274         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13275         { } /* end */
13276 };
13277
13278 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13279         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13280         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13281         _DEFINE_CAPSRC(1),
13282         { } /* end */
13283 };
13284
13285 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13286         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13287         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13288         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13289         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13290         _DEFINE_CAPSRC(2),
13291         { } /* end */
13292 };
13293
13294 static struct hda_input_mux alc268_capture_source = {
13295         .num_items = 4,
13296         .items = {
13297                 { "Mic", 0x0 },
13298                 { "Front Mic", 0x1 },
13299                 { "Line", 0x2 },
13300                 { "CD", 0x3 },
13301         },
13302 };
13303
13304 static struct hda_input_mux alc268_acer_capture_source = {
13305         .num_items = 3,
13306         .items = {
13307                 { "Mic", 0x0 },
13308                 { "Internal Mic", 0x1 },
13309                 { "Line", 0x2 },
13310         },
13311 };
13312
13313 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13314         .num_items = 3,
13315         .items = {
13316                 { "Mic", 0x0 },
13317                 { "Internal Mic", 0x6 },
13318                 { "Line", 0x2 },
13319         },
13320 };
13321
13322 #ifdef CONFIG_SND_DEBUG
13323 static struct snd_kcontrol_new alc268_test_mixer[] = {
13324         /* Volume widgets */
13325         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13326         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13327         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13328         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13329         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13330         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13331         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13332         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13333         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13334         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13335         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13336         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13337         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13338         /* The below appears problematic on some hardwares */
13339         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13340         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13341         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13342         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13343         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13344
13345         /* Modes for retasking pin widgets */
13346         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13347         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13348         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13349         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13350
13351         /* Controls for GPIO pins, assuming they are configured as outputs */
13352         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13353         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13354         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13355         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13356
13357         /* Switches to allow the digital SPDIF output pin to be enabled.
13358          * The ALC268 does not have an SPDIF input.
13359          */
13360         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13361
13362         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13363          * this output to turn on an external amplifier.
13364          */
13365         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13366         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13367
13368         { } /* end */
13369 };
13370 #endif
13371
13372 /* create input playback/capture controls for the given pin */
13373 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13374                                     const char *ctlname, int idx)
13375 {
13376         hda_nid_t dac;
13377         int err;
13378
13379         switch (nid) {
13380         case 0x14:
13381         case 0x16:
13382                 dac = 0x02;
13383                 break;
13384         case 0x15:
13385         case 0x1a: /* ALC259/269 only */
13386         case 0x1b: /* ALC259/269 only */
13387         case 0x21: /* ALC269vb has this pin, too */
13388                 dac = 0x03;
13389                 break;
13390         default:
13391                 snd_printd(KERN_WARNING "hda_codec: "
13392                            "ignoring pin 0x%x as unknown\n", nid);
13393                 return 0;
13394         }
13395         if (spec->multiout.dac_nids[0] != dac &&
13396             spec->multiout.dac_nids[1] != dac) {
13397                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13398                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13399                                                       HDA_OUTPUT));
13400                 if (err < 0)
13401                         return err;
13402                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13403         }
13404
13405         if (nid != 0x16)
13406                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13407                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13408         else /* mono */
13409                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13410                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13411         if (err < 0)
13412                 return err;
13413         return 0;
13414 }
13415
13416 /* add playback controls from the parsed DAC table */
13417 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13418                                              const struct auto_pin_cfg *cfg)
13419 {
13420         hda_nid_t nid;
13421         int err;
13422
13423         spec->multiout.dac_nids = spec->private_dac_nids;
13424
13425         nid = cfg->line_out_pins[0];
13426         if (nid) {
13427                 const char *name;
13428                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13429                         name = "Speaker";
13430                 else
13431                         name = "Front";
13432                 err = alc268_new_analog_output(spec, nid, name, 0);
13433                 if (err < 0)
13434                         return err;
13435         }
13436
13437         nid = cfg->speaker_pins[0];
13438         if (nid == 0x1d) {
13439                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13440                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13441                 if (err < 0)
13442                         return err;
13443         } else if (nid) {
13444                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13445                 if (err < 0)
13446                         return err;
13447         }
13448         nid = cfg->hp_pins[0];
13449         if (nid) {
13450                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13451                 if (err < 0)
13452                         return err;
13453         }
13454
13455         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13456         if (nid == 0x16) {
13457                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13458                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13459                 if (err < 0)
13460                         return err;
13461         }
13462         return 0;
13463 }
13464
13465 /* create playback/capture controls for input pins */
13466 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13467                                                 const struct auto_pin_cfg *cfg)
13468 {
13469         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13470 }
13471
13472 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13473                                               hda_nid_t nid, int pin_type)
13474 {
13475         int idx;
13476
13477         alc_set_pin_output(codec, nid, pin_type);
13478         if (nid == 0x14 || nid == 0x16)
13479                 idx = 0;
13480         else
13481                 idx = 1;
13482         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13483 }
13484
13485 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13486 {
13487         struct alc_spec *spec = codec->spec;
13488         int i;
13489
13490         for (i = 0; i < spec->autocfg.line_outs; i++) {
13491                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13492                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13493                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13494         }
13495 }
13496
13497 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13498 {
13499         struct alc_spec *spec = codec->spec;
13500         hda_nid_t pin;
13501         int i;
13502
13503         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13504                 pin = spec->autocfg.hp_pins[i];
13505                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13506         }
13507         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13508                 pin = spec->autocfg.speaker_pins[i];
13509                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13510         }
13511         if (spec->autocfg.mono_out_pin)
13512                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13513                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13514 }
13515
13516 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13517 {
13518         struct alc_spec *spec = codec->spec;
13519         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13520         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13521         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13522         unsigned int    dac_vol1, dac_vol2;
13523
13524         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13525                 snd_hda_codec_write(codec, speaker_nid, 0,
13526                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13527                 /* mute mixer inputs from 0x1d */
13528                 snd_hda_codec_write(codec, 0x0f, 0,
13529                                     AC_VERB_SET_AMP_GAIN_MUTE,
13530                                     AMP_IN_UNMUTE(1));
13531                 snd_hda_codec_write(codec, 0x10, 0,
13532                                     AC_VERB_SET_AMP_GAIN_MUTE,
13533                                     AMP_IN_UNMUTE(1));
13534         } else {
13535                 /* unmute mixer inputs from 0x1d */
13536                 snd_hda_codec_write(codec, 0x0f, 0,
13537                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13538                 snd_hda_codec_write(codec, 0x10, 0,
13539                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13540         }
13541
13542         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13543         if (line_nid == 0x14)
13544                 dac_vol2 = AMP_OUT_ZERO;
13545         else if (line_nid == 0x15)
13546                 dac_vol1 = AMP_OUT_ZERO;
13547         if (hp_nid == 0x14)
13548                 dac_vol2 = AMP_OUT_ZERO;
13549         else if (hp_nid == 0x15)
13550                 dac_vol1 = AMP_OUT_ZERO;
13551         if (line_nid != 0x16 || hp_nid != 0x16 ||
13552             spec->autocfg.line_out_pins[1] != 0x16 ||
13553             spec->autocfg.line_out_pins[2] != 0x16)
13554                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13555
13556         snd_hda_codec_write(codec, 0x02, 0,
13557                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13558         snd_hda_codec_write(codec, 0x03, 0,
13559                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13560 }
13561
13562 /* pcm configuration: identical with ALC880 */
13563 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13564 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13565 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13566 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13567
13568 /*
13569  * BIOS auto configuration
13570  */
13571 static int alc268_parse_auto_config(struct hda_codec *codec)
13572 {
13573         struct alc_spec *spec = codec->spec;
13574         int err;
13575         static hda_nid_t alc268_ignore[] = { 0 };
13576
13577         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13578                                            alc268_ignore);
13579         if (err < 0)
13580                 return err;
13581         if (!spec->autocfg.line_outs) {
13582                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13583                         spec->multiout.max_channels = 2;
13584                         spec->no_analog = 1;
13585                         goto dig_only;
13586                 }
13587                 return 0; /* can't find valid BIOS pin config */
13588         }
13589         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13590         if (err < 0)
13591                 return err;
13592         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13593         if (err < 0)
13594                 return err;
13595
13596         spec->multiout.max_channels = 2;
13597
13598  dig_only:
13599         /* digital only support output */
13600         alc_auto_parse_digital(codec);
13601         if (spec->kctls.list)
13602                 add_mixer(spec, spec->kctls.list);
13603
13604         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13605                 add_mixer(spec, alc268_beep_mixer);
13606
13607         add_verb(spec, alc268_volume_init_verbs);
13608         spec->num_mux_defs = 2;
13609         spec->input_mux = &spec->private_imux[0];
13610
13611         err = alc_auto_add_mic_boost(codec);
13612         if (err < 0)
13613                 return err;
13614
13615         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13616
13617         return 1;
13618 }
13619
13620 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13621
13622 /* init callback for auto-configuration model -- overriding the default init */
13623 static void alc268_auto_init(struct hda_codec *codec)
13624 {
13625         struct alc_spec *spec = codec->spec;
13626         alc268_auto_init_multi_out(codec);
13627         alc268_auto_init_hp_out(codec);
13628         alc268_auto_init_mono_speaker_out(codec);
13629         alc268_auto_init_analog_input(codec);
13630         alc_auto_init_digital(codec);
13631         if (spec->unsol_event)
13632                 alc_inithook(codec);
13633 }
13634
13635 /*
13636  * configuration and preset
13637  */
13638 static const char *alc268_models[ALC268_MODEL_LAST] = {
13639         [ALC267_QUANTA_IL1]     = "quanta-il1",
13640         [ALC268_3ST]            = "3stack",
13641         [ALC268_TOSHIBA]        = "toshiba",
13642         [ALC268_ACER]           = "acer",
13643         [ALC268_ACER_DMIC]      = "acer-dmic",
13644         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13645         [ALC268_DELL]           = "dell",
13646         [ALC268_ZEPTO]          = "zepto",
13647 #ifdef CONFIG_SND_DEBUG
13648         [ALC268_TEST]           = "test",
13649 #endif
13650         [ALC268_AUTO]           = "auto",
13651 };
13652
13653 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13654         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13655         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13656         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13657         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13658         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13659         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13660                                                 ALC268_ACER_ASPIRE_ONE),
13661         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13662         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13663                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13664         /* almost compatible with toshiba but with optional digital outs;
13665          * auto-probing seems working fine
13666          */
13667         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13668                            ALC268_AUTO),
13669         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13670         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13671         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13672         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13673         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13674         {}
13675 };
13676
13677 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13678 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13679         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13680         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13681         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13682                            ALC268_TOSHIBA),
13683         {}
13684 };
13685
13686 static struct alc_config_preset alc268_presets[] = {
13687         [ALC267_QUANTA_IL1] = {
13688                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13689                             alc268_capture_nosrc_mixer },
13690                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13691                                 alc267_quanta_il1_verbs },
13692                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13693                 .dac_nids = alc268_dac_nids,
13694                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13695                 .adc_nids = alc268_adc_nids_alt,
13696                 .hp_nid = 0x03,
13697                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13698                 .channel_mode = alc268_modes,
13699                 .unsol_event = alc_sku_unsol_event,
13700                 .setup = alc267_quanta_il1_setup,
13701                 .init_hook = alc_inithook,
13702         },
13703         [ALC268_3ST] = {
13704                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13705                             alc268_beep_mixer },
13706                 .init_verbs = { alc268_base_init_verbs },
13707                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13708                 .dac_nids = alc268_dac_nids,
13709                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13710                 .adc_nids = alc268_adc_nids_alt,
13711                 .capsrc_nids = alc268_capsrc_nids,
13712                 .hp_nid = 0x03,
13713                 .dig_out_nid = ALC268_DIGOUT_NID,
13714                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13715                 .channel_mode = alc268_modes,
13716                 .input_mux = &alc268_capture_source,
13717         },
13718         [ALC268_TOSHIBA] = {
13719                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13720                             alc268_beep_mixer },
13721                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13722                                 alc268_toshiba_verbs },
13723                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13724                 .dac_nids = alc268_dac_nids,
13725                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13726                 .adc_nids = alc268_adc_nids_alt,
13727                 .capsrc_nids = alc268_capsrc_nids,
13728                 .hp_nid = 0x03,
13729                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13730                 .channel_mode = alc268_modes,
13731                 .input_mux = &alc268_capture_source,
13732                 .unsol_event = alc268_toshiba_unsol_event,
13733                 .setup = alc268_toshiba_setup,
13734                 .init_hook = alc268_toshiba_automute,
13735         },
13736         [ALC268_ACER] = {
13737                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13738                             alc268_beep_mixer },
13739                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13740                                 alc268_acer_verbs },
13741                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13742                 .dac_nids = alc268_dac_nids,
13743                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13744                 .adc_nids = alc268_adc_nids_alt,
13745                 .capsrc_nids = alc268_capsrc_nids,
13746                 .hp_nid = 0x02,
13747                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13748                 .channel_mode = alc268_modes,
13749                 .input_mux = &alc268_acer_capture_source,
13750                 .unsol_event = alc268_acer_unsol_event,
13751                 .init_hook = alc268_acer_init_hook,
13752         },
13753         [ALC268_ACER_DMIC] = {
13754                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13755                             alc268_beep_mixer },
13756                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13757                                 alc268_acer_verbs },
13758                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13759                 .dac_nids = alc268_dac_nids,
13760                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13761                 .adc_nids = alc268_adc_nids_alt,
13762                 .capsrc_nids = alc268_capsrc_nids,
13763                 .hp_nid = 0x02,
13764                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13765                 .channel_mode = alc268_modes,
13766                 .input_mux = &alc268_acer_dmic_capture_source,
13767                 .unsol_event = alc268_acer_unsol_event,
13768                 .init_hook = alc268_acer_init_hook,
13769         },
13770         [ALC268_ACER_ASPIRE_ONE] = {
13771                 .mixers = { alc268_acer_aspire_one_mixer,
13772                             alc268_beep_mixer,
13773                             alc268_capture_nosrc_mixer },
13774                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13775                                 alc268_acer_aspire_one_verbs },
13776                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13777                 .dac_nids = alc268_dac_nids,
13778                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13779                 .adc_nids = alc268_adc_nids_alt,
13780                 .capsrc_nids = alc268_capsrc_nids,
13781                 .hp_nid = 0x03,
13782                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13783                 .channel_mode = alc268_modes,
13784                 .unsol_event = alc268_acer_lc_unsol_event,
13785                 .setup = alc268_acer_lc_setup,
13786                 .init_hook = alc268_acer_lc_init_hook,
13787         },
13788         [ALC268_DELL] = {
13789                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13790                             alc268_capture_nosrc_mixer },
13791                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13792                                 alc268_dell_verbs },
13793                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13794                 .dac_nids = alc268_dac_nids,
13795                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13796                 .adc_nids = alc268_adc_nids_alt,
13797                 .capsrc_nids = alc268_capsrc_nids,
13798                 .hp_nid = 0x02,
13799                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13800                 .channel_mode = alc268_modes,
13801                 .unsol_event = alc_sku_unsol_event,
13802                 .setup = alc268_dell_setup,
13803                 .init_hook = alc_inithook,
13804         },
13805         [ALC268_ZEPTO] = {
13806                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13807                             alc268_beep_mixer },
13808                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13809                                 alc268_toshiba_verbs },
13810                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13811                 .dac_nids = alc268_dac_nids,
13812                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13813                 .adc_nids = alc268_adc_nids_alt,
13814                 .capsrc_nids = alc268_capsrc_nids,
13815                 .hp_nid = 0x03,
13816                 .dig_out_nid = ALC268_DIGOUT_NID,
13817                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13818                 .channel_mode = alc268_modes,
13819                 .input_mux = &alc268_capture_source,
13820                 .setup = alc268_toshiba_setup,
13821                 .init_hook = alc268_toshiba_automute,
13822         },
13823 #ifdef CONFIG_SND_DEBUG
13824         [ALC268_TEST] = {
13825                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13826                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13827                                 alc268_volume_init_verbs },
13828                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13829                 .dac_nids = alc268_dac_nids,
13830                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13831                 .adc_nids = alc268_adc_nids_alt,
13832                 .capsrc_nids = alc268_capsrc_nids,
13833                 .hp_nid = 0x03,
13834                 .dig_out_nid = ALC268_DIGOUT_NID,
13835                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13836                 .channel_mode = alc268_modes,
13837                 .input_mux = &alc268_capture_source,
13838         },
13839 #endif
13840 };
13841
13842 static int patch_alc268(struct hda_codec *codec)
13843 {
13844         struct alc_spec *spec;
13845         int board_config;
13846         int i, has_beep, err;
13847
13848         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13849         if (spec == NULL)
13850                 return -ENOMEM;
13851
13852         codec->spec = spec;
13853
13854         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13855                                                   alc268_models,
13856                                                   alc268_cfg_tbl);
13857
13858         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13859                 board_config = snd_hda_check_board_codec_sid_config(codec,
13860                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13861
13862         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13863                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13864                        codec->chip_name);
13865                 board_config = ALC268_AUTO;
13866         }
13867
13868         if (board_config == ALC268_AUTO) {
13869                 /* automatic parse from the BIOS config */
13870                 err = alc268_parse_auto_config(codec);
13871                 if (err < 0) {
13872                         alc_free(codec);
13873                         return err;
13874                 } else if (!err) {
13875                         printk(KERN_INFO
13876                                "hda_codec: Cannot set up configuration "
13877                                "from BIOS.  Using base mode...\n");
13878                         board_config = ALC268_3ST;
13879                 }
13880         }
13881
13882         if (board_config != ALC268_AUTO)
13883                 setup_preset(codec, &alc268_presets[board_config]);
13884
13885         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13886         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13887         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13888
13889         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13890
13891         has_beep = 0;
13892         for (i = 0; i < spec->num_mixers; i++) {
13893                 if (spec->mixers[i] == alc268_beep_mixer) {
13894                         has_beep = 1;
13895                         break;
13896                 }
13897         }
13898
13899         if (has_beep) {
13900                 err = snd_hda_attach_beep_device(codec, 0x1);
13901                 if (err < 0) {
13902                         alc_free(codec);
13903                         return err;
13904                 }
13905                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13906                         /* override the amp caps for beep generator */
13907                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13908                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13909                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13910                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13911                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13912         }
13913
13914         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13915                 /* check whether NID 0x07 is valid */
13916                 unsigned int wcap = get_wcaps(codec, 0x07);
13917                 int i;
13918
13919                 spec->capsrc_nids = alc268_capsrc_nids;
13920                 /* get type */
13921                 wcap = get_wcaps_type(wcap);
13922                 if (spec->auto_mic ||
13923                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13924                         spec->adc_nids = alc268_adc_nids_alt;
13925                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13926                         if (spec->auto_mic)
13927                                 fixup_automic_adc(codec);
13928                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13929                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13930                         else
13931                                 add_mixer(spec, alc268_capture_alt_mixer);
13932                 } else {
13933                         spec->adc_nids = alc268_adc_nids;
13934                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13935                         add_mixer(spec, alc268_capture_mixer);
13936                 }
13937                 /* set default input source */
13938                 for (i = 0; i < spec->num_adc_nids; i++)
13939                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13940                                 0, AC_VERB_SET_CONNECT_SEL,
13941                                 i < spec->num_mux_defs ?
13942                                 spec->input_mux[i].items[0].index :
13943                                 spec->input_mux->items[0].index);
13944         }
13945
13946         spec->vmaster_nid = 0x02;
13947
13948         codec->patch_ops = alc_patch_ops;
13949         if (board_config == ALC268_AUTO)
13950                 spec->init_hook = alc268_auto_init;
13951
13952         return 0;
13953 }
13954
13955 /*
13956  *  ALC269 channel source setting (2 channel)
13957  */
13958 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13959
13960 #define alc269_dac_nids         alc260_dac_nids
13961
13962 static hda_nid_t alc269_adc_nids[1] = {
13963         /* ADC1 */
13964         0x08,
13965 };
13966
13967 static hda_nid_t alc269_capsrc_nids[1] = {
13968         0x23,
13969 };
13970
13971 static hda_nid_t alc269vb_adc_nids[1] = {
13972         /* ADC1 */
13973         0x09,
13974 };
13975
13976 static hda_nid_t alc269vb_capsrc_nids[1] = {
13977         0x22,
13978 };
13979
13980 static hda_nid_t alc269_adc_candidates[] = {
13981         0x08, 0x09, 0x07,
13982 };
13983
13984 #define alc269_modes            alc260_modes
13985 #define alc269_capture_source   alc880_lg_lw_capture_source
13986
13987 static struct snd_kcontrol_new alc269_base_mixer[] = {
13988         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13989         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13990         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13991         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13992         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13993         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13994         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13995         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13996         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13997         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13998         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13999         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14000         { } /* end */
14001 };
14002
14003 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14004         /* output mixer control */
14005         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14006         {
14007                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14008                 .name = "Master Playback Switch",
14009                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14010                 .info = snd_hda_mixer_amp_switch_info,
14011                 .get = snd_hda_mixer_amp_switch_get,
14012                 .put = alc268_acer_master_sw_put,
14013                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14014         },
14015         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14016         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14017         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14018         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14019         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14020         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14021         { }
14022 };
14023
14024 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14025         /* output mixer control */
14026         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14027         {
14028                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14029                 .name = "Master Playback Switch",
14030                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14031                 .info = snd_hda_mixer_amp_switch_info,
14032                 .get = snd_hda_mixer_amp_switch_get,
14033                 .put = alc268_acer_master_sw_put,
14034                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14035         },
14036         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14037         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14038         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14039         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14040         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14041         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14042         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14043         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14044         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
14045         { }
14046 };
14047
14048 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14049         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14050         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14051         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14052         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14053         { } /* end */
14054 };
14055
14056 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14057         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14058         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14059         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14060         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14061         { } /* end */
14062 };
14063
14064 static struct snd_kcontrol_new alc269_asus_mixer[] = {
14065         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14066         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14067         { } /* end */
14068 };
14069
14070 /* capture mixer elements */
14071 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14072         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14073         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14074         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14075         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14076         { } /* end */
14077 };
14078
14079 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14080         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14081         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14082         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14083         { } /* end */
14084 };
14085
14086 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14087         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14088         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14089         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14090         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14091         { } /* end */
14092 };
14093
14094 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14095         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14096         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14097         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14098         { } /* end */
14099 };
14100
14101 /* FSC amilo */
14102 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14103
14104 static struct hda_verb alc269_quanta_fl1_verbs[] = {
14105         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14106         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14107         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14108         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14109         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14110         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14111         { }
14112 };
14113
14114 static struct hda_verb alc269_lifebook_verbs[] = {
14115         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14116         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14117         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14118         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14119         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14120         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14121         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14122         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14123         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14124         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14125         { }
14126 };
14127
14128 /* toggle speaker-output according to the hp-jack state */
14129 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14130 {
14131         unsigned int present;
14132         unsigned char bits;
14133
14134         present = snd_hda_jack_detect(codec, 0x15);
14135         bits = present ? HDA_AMP_MUTE : 0;
14136         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14137                                  HDA_AMP_MUTE, bits);
14138         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14139                                  HDA_AMP_MUTE, bits);
14140
14141         snd_hda_codec_write(codec, 0x20, 0,
14142                         AC_VERB_SET_COEF_INDEX, 0x0c);
14143         snd_hda_codec_write(codec, 0x20, 0,
14144                         AC_VERB_SET_PROC_COEF, 0x680);
14145
14146         snd_hda_codec_write(codec, 0x20, 0,
14147                         AC_VERB_SET_COEF_INDEX, 0x0c);
14148         snd_hda_codec_write(codec, 0x20, 0,
14149                         AC_VERB_SET_PROC_COEF, 0x480);
14150 }
14151
14152 /* toggle speaker-output according to the hp-jacks state */
14153 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14154 {
14155         unsigned int present;
14156         unsigned char bits;
14157
14158         /* Check laptop headphone socket */
14159         present = snd_hda_jack_detect(codec, 0x15);
14160
14161         /* Check port replicator headphone socket */
14162         present |= snd_hda_jack_detect(codec, 0x1a);
14163
14164         bits = present ? HDA_AMP_MUTE : 0;
14165         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14166                                  HDA_AMP_MUTE, bits);
14167         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14168                                  HDA_AMP_MUTE, bits);
14169
14170         snd_hda_codec_write(codec, 0x20, 0,
14171                         AC_VERB_SET_COEF_INDEX, 0x0c);
14172         snd_hda_codec_write(codec, 0x20, 0,
14173                         AC_VERB_SET_PROC_COEF, 0x680);
14174
14175         snd_hda_codec_write(codec, 0x20, 0,
14176                         AC_VERB_SET_COEF_INDEX, 0x0c);
14177         snd_hda_codec_write(codec, 0x20, 0,
14178                         AC_VERB_SET_PROC_COEF, 0x480);
14179 }
14180
14181 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14182 {
14183         unsigned int present_laptop;
14184         unsigned int present_dock;
14185
14186         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14187         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14188
14189         /* Laptop mic port overrides dock mic port, design decision */
14190         if (present_dock)
14191                 snd_hda_codec_write(codec, 0x23, 0,
14192                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14193         if (present_laptop)
14194                 snd_hda_codec_write(codec, 0x23, 0,
14195                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14196         if (!present_dock && !present_laptop)
14197                 snd_hda_codec_write(codec, 0x23, 0,
14198                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14199 }
14200
14201 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14202                                     unsigned int res)
14203 {
14204         switch (res >> 26) {
14205         case ALC880_HP_EVENT:
14206                 alc269_quanta_fl1_speaker_automute(codec);
14207                 break;
14208         case ALC880_MIC_EVENT:
14209                 alc_mic_automute(codec);
14210                 break;
14211         }
14212 }
14213
14214 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14215                                         unsigned int res)
14216 {
14217         if ((res >> 26) == ALC880_HP_EVENT)
14218                 alc269_lifebook_speaker_automute(codec);
14219         if ((res >> 26) == ALC880_MIC_EVENT)
14220                 alc269_lifebook_mic_autoswitch(codec);
14221 }
14222
14223 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14224 {
14225         struct alc_spec *spec = codec->spec;
14226         spec->autocfg.hp_pins[0] = 0x15;
14227         spec->autocfg.speaker_pins[0] = 0x14;
14228         spec->ext_mic.pin = 0x18;
14229         spec->ext_mic.mux_idx = 0;
14230         spec->int_mic.pin = 0x19;
14231         spec->int_mic.mux_idx = 1;
14232         spec->auto_mic = 1;
14233 }
14234
14235 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14236 {
14237         alc269_quanta_fl1_speaker_automute(codec);
14238         alc_mic_automute(codec);
14239 }
14240
14241 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14242 {
14243         alc269_lifebook_speaker_automute(codec);
14244         alc269_lifebook_mic_autoswitch(codec);
14245 }
14246
14247 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14248         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14249         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14250         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14251         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14252         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14253         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14254         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14255         {}
14256 };
14257
14258 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14259         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14260         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14261         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14262         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14263         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14264         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14265         {}
14266 };
14267
14268 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14269         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14270         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14271         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14272         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14273         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14274         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14275         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14276         {}
14277 };
14278
14279 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14280         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14281         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14282         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14283         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14284         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14285         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14286         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14287         {}
14288 };
14289
14290 static struct hda_verb alc271_acer_dmic_verbs[] = {
14291         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14292         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14293         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14294         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14295         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14296         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14297         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14298         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14299         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14300         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14301         { }
14302 };
14303
14304 /* toggle speaker-output according to the hp-jack state */
14305 static void alc269_speaker_automute(struct hda_codec *codec)
14306 {
14307         struct alc_spec *spec = codec->spec;
14308         unsigned int nid = spec->autocfg.hp_pins[0];
14309         unsigned int present;
14310         unsigned char bits;
14311
14312         present = snd_hda_jack_detect(codec, nid);
14313         bits = present ? HDA_AMP_MUTE : 0;
14314         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14315                                  HDA_AMP_MUTE, bits);
14316         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14317                                  HDA_AMP_MUTE, bits);
14318 }
14319
14320 /* unsolicited event for HP jack sensing */
14321 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14322                                      unsigned int res)
14323 {
14324         switch (res >> 26) {
14325         case ALC880_HP_EVENT:
14326                 alc269_speaker_automute(codec);
14327                 break;
14328         case ALC880_MIC_EVENT:
14329                 alc_mic_automute(codec);
14330                 break;
14331         }
14332 }
14333
14334 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14335 {
14336         struct alc_spec *spec = codec->spec;
14337         spec->autocfg.hp_pins[0] = 0x15;
14338         spec->autocfg.speaker_pins[0] = 0x14;
14339         spec->ext_mic.pin = 0x18;
14340         spec->ext_mic.mux_idx = 0;
14341         spec->int_mic.pin = 0x19;
14342         spec->int_mic.mux_idx = 1;
14343         spec->auto_mic = 1;
14344 }
14345
14346 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14347 {
14348         struct alc_spec *spec = codec->spec;
14349         spec->autocfg.hp_pins[0] = 0x15;
14350         spec->autocfg.speaker_pins[0] = 0x14;
14351         spec->ext_mic.pin = 0x18;
14352         spec->ext_mic.mux_idx = 0;
14353         spec->int_mic.pin = 0x12;
14354         spec->int_mic.mux_idx = 5;
14355         spec->auto_mic = 1;
14356 }
14357
14358 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14359 {
14360         struct alc_spec *spec = codec->spec;
14361         spec->autocfg.hp_pins[0] = 0x21;
14362         spec->autocfg.speaker_pins[0] = 0x14;
14363         spec->ext_mic.pin = 0x18;
14364         spec->ext_mic.mux_idx = 0;
14365         spec->int_mic.pin = 0x19;
14366         spec->int_mic.mux_idx = 1;
14367         spec->auto_mic = 1;
14368 }
14369
14370 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14371 {
14372         struct alc_spec *spec = codec->spec;
14373         spec->autocfg.hp_pins[0] = 0x21;
14374         spec->autocfg.speaker_pins[0] = 0x14;
14375         spec->ext_mic.pin = 0x18;
14376         spec->ext_mic.mux_idx = 0;
14377         spec->int_mic.pin = 0x12;
14378         spec->int_mic.mux_idx = 6;
14379         spec->auto_mic = 1;
14380 }
14381
14382 static void alc269_laptop_inithook(struct hda_codec *codec)
14383 {
14384         alc269_speaker_automute(codec);
14385         alc_mic_automute(codec);
14386 }
14387
14388 /*
14389  * generic initialization of ADC, input mixers and output mixers
14390  */
14391 static struct hda_verb alc269_init_verbs[] = {
14392         /*
14393          * Unmute ADC0 and set the default input to mic-in
14394          */
14395         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14396
14397         /*
14398          * Set up output mixers (0x02 - 0x03)
14399          */
14400         /* set vol=0 to output mixers */
14401         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14402         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14403
14404         /* set up input amps for analog loopback */
14405         /* Amp Indices: DAC = 0, mixer = 1 */
14406         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14407         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14408         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14409         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14410         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14411         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14412
14413         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14414         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14415         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14416         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14417         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14418         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14419         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14420
14421         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14422         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14423
14424         /* FIXME: use Mux-type input source selection */
14425         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14426         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14427         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14428
14429         /* set EAPD */
14430         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14431         { }
14432 };
14433
14434 static struct hda_verb alc269vb_init_verbs[] = {
14435         /*
14436          * Unmute ADC0 and set the default input to mic-in
14437          */
14438         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14439
14440         /*
14441          * Set up output mixers (0x02 - 0x03)
14442          */
14443         /* set vol=0 to output mixers */
14444         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14445         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14446
14447         /* set up input amps for analog loopback */
14448         /* Amp Indices: DAC = 0, mixer = 1 */
14449         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14450         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14451         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14452         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14453         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14454         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14455
14456         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14457         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14458         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14459         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14460         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14461         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14462         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14463
14464         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14465         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14466
14467         /* FIXME: use Mux-type input source selection */
14468         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14469         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14470         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14471
14472         /* set EAPD */
14473         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14474         { }
14475 };
14476
14477 #define alc269_auto_create_multi_out_ctls \
14478         alc268_auto_create_multi_out_ctls
14479 #define alc269_auto_create_input_ctls \
14480         alc268_auto_create_input_ctls
14481
14482 #ifdef CONFIG_SND_HDA_POWER_SAVE
14483 #define alc269_loopbacks        alc880_loopbacks
14484 #endif
14485
14486 /* pcm configuration: identical with ALC880 */
14487 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14488 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14489 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14490 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14491
14492 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14493         .substreams = 1,
14494         .channels_min = 2,
14495         .channels_max = 8,
14496         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14497         /* NID is set in alc_build_pcms */
14498         .ops = {
14499                 .open = alc880_playback_pcm_open,
14500                 .prepare = alc880_playback_pcm_prepare,
14501                 .cleanup = alc880_playback_pcm_cleanup
14502         },
14503 };
14504
14505 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14506         .substreams = 1,
14507         .channels_min = 2,
14508         .channels_max = 2,
14509         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14510         /* NID is set in alc_build_pcms */
14511 };
14512
14513 #ifdef CONFIG_SND_HDA_POWER_SAVE
14514 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14515 {
14516         switch (codec->subsystem_id) {
14517         case 0x103c1586:
14518                 return 1;
14519         }
14520         return 0;
14521 }
14522
14523 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14524 {
14525         /* update mute-LED according to the speaker mute state */
14526         if (nid == 0x01 || nid == 0x14) {
14527                 int pinval;
14528                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14529                     HDA_AMP_MUTE)
14530                         pinval = 0x24;
14531                 else
14532                         pinval = 0x20;
14533                 /* mic2 vref pin is used for mute LED control */
14534                 snd_hda_codec_update_cache(codec, 0x19, 0,
14535                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14536                                            pinval);
14537         }
14538         return alc_check_power_status(codec, nid);
14539 }
14540 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14541
14542 static int alc275_setup_dual_adc(struct hda_codec *codec)
14543 {
14544         struct alc_spec *spec = codec->spec;
14545
14546         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14547                 return 0;
14548         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14549             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14550                 if (spec->ext_mic.pin <= 0x12) {
14551                         spec->private_adc_nids[0] = 0x08;
14552                         spec->private_adc_nids[1] = 0x11;
14553                         spec->private_capsrc_nids[0] = 0x23;
14554                         spec->private_capsrc_nids[1] = 0x22;
14555                 } else {
14556                         spec->private_adc_nids[0] = 0x11;
14557                         spec->private_adc_nids[1] = 0x08;
14558                         spec->private_capsrc_nids[0] = 0x22;
14559                         spec->private_capsrc_nids[1] = 0x23;
14560                 }
14561                 spec->adc_nids = spec->private_adc_nids;
14562                 spec->capsrc_nids = spec->private_capsrc_nids;
14563                 spec->num_adc_nids = 2;
14564                 spec->dual_adc_switch = 1;
14565                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14566                             spec->adc_nids[0], spec->adc_nids[1]);
14567                 return 1;
14568         }
14569         return 0;
14570 }
14571
14572 /* different alc269-variants */
14573 enum {
14574         ALC269_TYPE_NORMAL,
14575         ALC269_TYPE_ALC259,
14576         ALC269_TYPE_ALC271X,
14577 };
14578
14579 /*
14580  * BIOS auto configuration
14581  */
14582 static int alc269_parse_auto_config(struct hda_codec *codec)
14583 {
14584         struct alc_spec *spec = codec->spec;
14585         int err;
14586         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14587
14588         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14589                                            alc269_ignore);
14590         if (err < 0)
14591                 return err;
14592
14593         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14594         if (err < 0)
14595                 return err;
14596         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14597         if (err < 0)
14598                 return err;
14599
14600         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14601
14602         alc_auto_parse_digital(codec);
14603
14604         if (spec->kctls.list)
14605                 add_mixer(spec, spec->kctls.list);
14606
14607         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14608                 add_verb(spec, alc269vb_init_verbs);
14609                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14610         } else {
14611                 add_verb(spec, alc269_init_verbs);
14612                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14613         }
14614
14615         spec->num_mux_defs = 1;
14616         spec->input_mux = &spec->private_imux[0];
14617
14618         if (!alc275_setup_dual_adc(codec))
14619                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14620                                      sizeof(alc269_adc_candidates));
14621
14622         /* set default input source */
14623         if (!spec->dual_adc_switch)
14624                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14625                                         spec->input_mux->items[0].index);
14626
14627         err = alc_auto_add_mic_boost(codec);
14628         if (err < 0)
14629                 return err;
14630
14631         if (!spec->cap_mixer && !spec->no_analog)
14632                 set_capture_mixer(codec);
14633
14634         return 1;
14635 }
14636
14637 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14638 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14639 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14640
14641
14642 /* init callback for auto-configuration model -- overriding the default init */
14643 static void alc269_auto_init(struct hda_codec *codec)
14644 {
14645         struct alc_spec *spec = codec->spec;
14646         alc269_auto_init_multi_out(codec);
14647         alc269_auto_init_hp_out(codec);
14648         alc269_auto_init_analog_input(codec);
14649         alc_auto_init_digital(codec);
14650         alc_init_jacks(codec);
14651         if (spec->unsol_event)
14652                 alc_inithook(codec);
14653 }
14654
14655 #ifdef CONFIG_SND_HDA_POWER_SAVE
14656 static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14657 {
14658         struct alc_spec *spec = codec->spec;
14659         int val;
14660
14661         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14662                 val = alc_read_coef_idx(codec, 0x04);
14663                 /* Power down output pin */
14664                 alc_write_coef_idx(codec, 0x04, val & ~(1<<11));
14665         }
14666
14667         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14668                 val = alc_read_coef_idx(codec, 0x04);
14669                 /* Power down output pin */
14670                 alc_write_coef_idx(codec, 0x04, val & ~(1<<11));
14671                 msleep(150);
14672         }
14673
14674         alc_shutup(codec);
14675         if (spec && spec->power_hook)
14676                 spec->power_hook(codec);
14677         return 0;
14678 }
14679 #endif
14680 #ifdef SND_HDA_NEEDS_RESUME
14681 static int alc269_resume(struct hda_codec *codec)
14682 {
14683         int val;
14684
14685         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14686                 val = alc_read_coef_idx(codec, 0x04);
14687                 /* Power down output pin */
14688                 alc_write_coef_idx(codec, 0x04, val & ~(1<<11));
14689                 msleep(150);
14690         }
14691
14692         codec->patch_ops.init(codec);
14693
14694         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14695                 val = alc_read_coef_idx(codec, 0x04);
14696                 /* Power up output pin */
14697                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
14698                 msleep(200);
14699         }
14700
14701         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14702                 val = alc_read_coef_idx(codec, 0x04);
14703                 /* Power up output pin */
14704                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
14705         }
14706
14707         snd_hda_codec_resume_amp(codec);
14708         snd_hda_codec_resume_cache(codec);
14709 #ifdef CONFIG_SND_HDA_POWER_SAVE
14710         if (codec->patch_ops.check_power_status)
14711                 codec->patch_ops.check_power_status(codec, 0x01);
14712 #endif
14713         return 0;
14714 }
14715 #endif
14716
14717 enum {
14718         ALC269_FIXUP_SONY_VAIO,
14719 };
14720
14721 static const struct alc_fixup alc269_fixups[] = {
14722         [ALC269_FIXUP_SONY_VAIO] = {
14723                 .verbs = (const struct hda_verb[]) {
14724                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14725                         {}
14726                 }
14727         },
14728 };
14729
14730 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14731         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14732         SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14733         {}
14734 };
14735
14736
14737 /*
14738  * configuration and preset
14739  */
14740 static const char *alc269_models[ALC269_MODEL_LAST] = {
14741         [ALC269_BASIC]                  = "basic",
14742         [ALC269_QUANTA_FL1]             = "quanta",
14743         [ALC269_AMIC]                   = "laptop-amic",
14744         [ALC269_DMIC]                   = "laptop-dmic",
14745         [ALC269_FUJITSU]                = "fujitsu",
14746         [ALC269_LIFEBOOK]               = "lifebook",
14747         [ALC269_AUTO]                   = "auto",
14748 };
14749
14750 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14751         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14752         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14753         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14754                       ALC269_AMIC),
14755         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14756         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14757         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14758         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14759         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14760         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14761         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14762         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14763         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14764         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14765         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14766         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14767         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14768         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14769         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14770         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14771         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14772         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14773         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14774         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14775         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14776         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14777         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14778         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14779         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14780         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14781         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14782         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14783         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14784         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14785         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14786         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14787         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14788         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14789         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14790         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14791         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14792                       ALC269_DMIC),
14793         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14794                       ALC269_DMIC),
14795         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14796         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14797         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14798         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14799         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14800         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14801         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14802         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14803         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14804         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14805         {}
14806 };
14807
14808 static struct alc_config_preset alc269_presets[] = {
14809         [ALC269_BASIC] = {
14810                 .mixers = { alc269_base_mixer },
14811                 .init_verbs = { alc269_init_verbs },
14812                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14813                 .dac_nids = alc269_dac_nids,
14814                 .hp_nid = 0x03,
14815                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14816                 .channel_mode = alc269_modes,
14817                 .input_mux = &alc269_capture_source,
14818         },
14819         [ALC269_QUANTA_FL1] = {
14820                 .mixers = { alc269_quanta_fl1_mixer },
14821                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14822                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14823                 .dac_nids = alc269_dac_nids,
14824                 .hp_nid = 0x03,
14825                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14826                 .channel_mode = alc269_modes,
14827                 .input_mux = &alc269_capture_source,
14828                 .unsol_event = alc269_quanta_fl1_unsol_event,
14829                 .setup = alc269_quanta_fl1_setup,
14830                 .init_hook = alc269_quanta_fl1_init_hook,
14831         },
14832         [ALC269_AMIC] = {
14833                 .mixers = { alc269_laptop_mixer },
14834                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14835                 .init_verbs = { alc269_init_verbs,
14836                                 alc269_laptop_amic_init_verbs },
14837                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14838                 .dac_nids = alc269_dac_nids,
14839                 .hp_nid = 0x03,
14840                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14841                 .channel_mode = alc269_modes,
14842                 .unsol_event = alc269_laptop_unsol_event,
14843                 .setup = alc269_laptop_amic_setup,
14844                 .init_hook = alc269_laptop_inithook,
14845         },
14846         [ALC269_DMIC] = {
14847                 .mixers = { alc269_laptop_mixer },
14848                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14849                 .init_verbs = { alc269_init_verbs,
14850                                 alc269_laptop_dmic_init_verbs },
14851                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14852                 .dac_nids = alc269_dac_nids,
14853                 .hp_nid = 0x03,
14854                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14855                 .channel_mode = alc269_modes,
14856                 .unsol_event = alc269_laptop_unsol_event,
14857                 .setup = alc269_laptop_dmic_setup,
14858                 .init_hook = alc269_laptop_inithook,
14859         },
14860         [ALC269VB_AMIC] = {
14861                 .mixers = { alc269vb_laptop_mixer },
14862                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14863                 .init_verbs = { alc269vb_init_verbs,
14864                                 alc269vb_laptop_amic_init_verbs },
14865                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14866                 .dac_nids = alc269_dac_nids,
14867                 .hp_nid = 0x03,
14868                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14869                 .channel_mode = alc269_modes,
14870                 .unsol_event = alc269_laptop_unsol_event,
14871                 .setup = alc269vb_laptop_amic_setup,
14872                 .init_hook = alc269_laptop_inithook,
14873         },
14874         [ALC269VB_DMIC] = {
14875                 .mixers = { alc269vb_laptop_mixer },
14876                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14877                 .init_verbs = { alc269vb_init_verbs,
14878                                 alc269vb_laptop_dmic_init_verbs },
14879                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14880                 .dac_nids = alc269_dac_nids,
14881                 .hp_nid = 0x03,
14882                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14883                 .channel_mode = alc269_modes,
14884                 .unsol_event = alc269_laptop_unsol_event,
14885                 .setup = alc269vb_laptop_dmic_setup,
14886                 .init_hook = alc269_laptop_inithook,
14887         },
14888         [ALC269_FUJITSU] = {
14889                 .mixers = { alc269_fujitsu_mixer },
14890                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14891                 .init_verbs = { alc269_init_verbs,
14892                                 alc269_laptop_dmic_init_verbs },
14893                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14894                 .dac_nids = alc269_dac_nids,
14895                 .hp_nid = 0x03,
14896                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14897                 .channel_mode = alc269_modes,
14898                 .unsol_event = alc269_laptop_unsol_event,
14899                 .setup = alc269_laptop_dmic_setup,
14900                 .init_hook = alc269_laptop_inithook,
14901         },
14902         [ALC269_LIFEBOOK] = {
14903                 .mixers = { alc269_lifebook_mixer },
14904                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14905                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14906                 .dac_nids = alc269_dac_nids,
14907                 .hp_nid = 0x03,
14908                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14909                 .channel_mode = alc269_modes,
14910                 .input_mux = &alc269_capture_source,
14911                 .unsol_event = alc269_lifebook_unsol_event,
14912                 .init_hook = alc269_lifebook_init_hook,
14913         },
14914         [ALC271_ACER] = {
14915                 .mixers = { alc269_asus_mixer },
14916                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14917                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
14918                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14919                 .dac_nids = alc269_dac_nids,
14920                 .adc_nids = alc262_dmic_adc_nids,
14921                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
14922                 .capsrc_nids = alc262_dmic_capsrc_nids,
14923                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14924                 .channel_mode = alc269_modes,
14925                 .input_mux = &alc269_capture_source,
14926                 .dig_out_nid = ALC880_DIGOUT_NID,
14927                 .unsol_event = alc_sku_unsol_event,
14928                 .setup = alc269vb_laptop_dmic_setup,
14929                 .init_hook = alc_inithook,
14930         },
14931 };
14932
14933 static int alc269_fill_coef(struct hda_codec *codec)
14934 {
14935         int val;
14936
14937         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
14938                 alc_write_coef_idx(codec, 0xf, 0x960b);
14939                 alc_write_coef_idx(codec, 0xe, 0x8817);
14940         }
14941
14942         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
14943                 alc_write_coef_idx(codec, 0xf, 0x960b);
14944                 alc_write_coef_idx(codec, 0xe, 0x8814);
14945         }
14946
14947         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14948                 val = alc_read_coef_idx(codec, 0x04);
14949                 /* Power up output pin */
14950                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
14951         }
14952
14953         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14954                 val = alc_read_coef_idx(codec, 0xd);
14955                 if ((val & 0x0c00) >> 10 != 0x1) {
14956                         /* Capless ramp up clock control */
14957                         alc_write_coef_idx(codec, 0xd, val | 1<<10);
14958                 }
14959                 val = alc_read_coef_idx(codec, 0x17);
14960                 if ((val & 0x01c0) >> 6 != 0x4) {
14961                         /* Class D power on reset */
14962                         alc_write_coef_idx(codec, 0x17, val | 1<<7);
14963                 }
14964         }
14965         return 0;
14966 }
14967
14968 static int patch_alc269(struct hda_codec *codec)
14969 {
14970         struct alc_spec *spec;
14971         int board_config;
14972         int err;
14973
14974         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14975         if (spec == NULL)
14976                 return -ENOMEM;
14977
14978         codec->spec = spec;
14979
14980         alc_auto_parse_customize_define(codec);
14981
14982         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14983                 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
14984                     spec->cdefine.platform_type == 1) {
14985                         alc_codec_rename(codec, "ALC271X");
14986                         spec->codec_variant = ALC269_TYPE_ALC271X;
14987                 } else {
14988                         alc_codec_rename(codec, "ALC259");
14989                         spec->codec_variant = ALC269_TYPE_ALC259;
14990                 }
14991         } else
14992                 alc_fix_pll_init(codec, 0x20, 0x04, 15);
14993
14994         alc269_fill_coef(codec);
14995
14996         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14997                                                   alc269_models,
14998                                                   alc269_cfg_tbl);
14999
15000         if (board_config < 0) {
15001                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15002                        codec->chip_name);
15003                 board_config = ALC269_AUTO;
15004         }
15005
15006         if (board_config == ALC269_AUTO)
15007                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
15008
15009         if (board_config == ALC269_AUTO) {
15010                 /* automatic parse from the BIOS config */
15011                 err = alc269_parse_auto_config(codec);
15012                 if (err < 0) {
15013                         alc_free(codec);
15014                         return err;
15015                 } else if (!err) {
15016                         printk(KERN_INFO
15017                                "hda_codec: Cannot set up configuration "
15018                                "from BIOS.  Using base mode...\n");
15019                         board_config = ALC269_BASIC;
15020                 }
15021         }
15022
15023         if (has_cdefine_beep(codec)) {
15024                 err = snd_hda_attach_beep_device(codec, 0x1);
15025                 if (err < 0) {
15026                         alc_free(codec);
15027                         return err;
15028                 }
15029         }
15030
15031         if (board_config != ALC269_AUTO)
15032                 setup_preset(codec, &alc269_presets[board_config]);
15033
15034         if (board_config == ALC269_QUANTA_FL1) {
15035                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15036                  * fix the sample rate of analog I/O to 44.1kHz
15037                  */
15038                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15039                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15040         } else if (spec->dual_adc_switch) {
15041                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15042                 /* switch ADC dynamically */
15043                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15044         } else {
15045                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15046                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15047         }
15048         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15049         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15050
15051         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15052                 if (spec->codec_variant != ALC269_TYPE_NORMAL) {
15053                         spec->adc_nids = alc269_adc_nids;
15054                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15055                         spec->capsrc_nids = alc269_capsrc_nids;
15056                 } else {
15057                         spec->adc_nids = alc269vb_adc_nids;
15058                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15059                         spec->capsrc_nids = alc269vb_capsrc_nids;
15060                 }
15061         }
15062
15063         if (!spec->cap_mixer)
15064                 set_capture_mixer(codec);
15065         if (has_cdefine_beep(codec))
15066                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15067
15068         if (board_config == ALC269_AUTO)
15069                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
15070
15071         spec->vmaster_nid = 0x02;
15072
15073         codec->patch_ops = alc_patch_ops;
15074 #ifdef CONFIG_SND_HDA_POWER_SAVE
15075         codec->patch_ops.suspend = alc269_suspend;
15076 #endif
15077 #ifdef SND_HDA_NEEDS_RESUME
15078         codec->patch_ops.resume = alc269_resume;
15079 #endif
15080         if (board_config == ALC269_AUTO)
15081                 spec->init_hook = alc269_auto_init;
15082 #ifdef CONFIG_SND_HDA_POWER_SAVE
15083         if (!spec->loopback.amplist)
15084                 spec->loopback.amplist = alc269_loopbacks;
15085         if (alc269_mic2_for_mute_led(codec))
15086                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15087 #endif
15088
15089         return 0;
15090 }
15091
15092 /*
15093  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15094  */
15095
15096 /*
15097  * set the path ways for 2 channel output
15098  * need to set the codec line out and mic 1 pin widgets to inputs
15099  */
15100 static struct hda_verb alc861_threestack_ch2_init[] = {
15101         /* set pin widget 1Ah (line in) for input */
15102         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15103         /* set pin widget 18h (mic1/2) for input, for mic also enable
15104          * the vref
15105          */
15106         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15107
15108         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15109 #if 0
15110         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15111         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15112 #endif
15113         { } /* end */
15114 };
15115 /*
15116  * 6ch mode
15117  * need to set the codec line out and mic 1 pin widgets to outputs
15118  */
15119 static struct hda_verb alc861_threestack_ch6_init[] = {
15120         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15121         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15122         /* set pin widget 18h (mic1) for output (CLFE)*/
15123         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15124
15125         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15126         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15127
15128         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15129 #if 0
15130         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15131         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15132 #endif
15133         { } /* end */
15134 };
15135
15136 static struct hda_channel_mode alc861_threestack_modes[2] = {
15137         { 2, alc861_threestack_ch2_init },
15138         { 6, alc861_threestack_ch6_init },
15139 };
15140 /* Set mic1 as input and unmute the mixer */
15141 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15142         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15143         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15144         { } /* end */
15145 };
15146 /* Set mic1 as output and mute mixer */
15147 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15148         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15149         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15150         { } /* end */
15151 };
15152
15153 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15154         { 2, alc861_uniwill_m31_ch2_init },
15155         { 4, alc861_uniwill_m31_ch4_init },
15156 };
15157
15158 /* Set mic1 and line-in as input and unmute the mixer */
15159 static struct hda_verb alc861_asus_ch2_init[] = {
15160         /* set pin widget 1Ah (line in) for input */
15161         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15162         /* set pin widget 18h (mic1/2) for input, for mic also enable
15163          * the vref
15164          */
15165         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15166
15167         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15168 #if 0
15169         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15170         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15171 #endif
15172         { } /* end */
15173 };
15174 /* Set mic1 nad line-in as output and mute mixer */
15175 static struct hda_verb alc861_asus_ch6_init[] = {
15176         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15177         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15178         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15179         /* set pin widget 18h (mic1) for output (CLFE)*/
15180         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15181         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15182         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15183         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15184
15185         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15186 #if 0
15187         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15188         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15189 #endif
15190         { } /* end */
15191 };
15192
15193 static struct hda_channel_mode alc861_asus_modes[2] = {
15194         { 2, alc861_asus_ch2_init },
15195         { 6, alc861_asus_ch6_init },
15196 };
15197
15198 /* patch-ALC861 */
15199
15200 static struct snd_kcontrol_new alc861_base_mixer[] = {
15201         /* output mixer control */
15202         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15203         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15204         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15205         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15206         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15207
15208         /*Input mixer control */
15209         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15210            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15211         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15212         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15213         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15214         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15215         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15216         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15217         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15218         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15219
15220         { } /* end */
15221 };
15222
15223 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15224         /* output mixer control */
15225         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15226         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15227         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15228         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15229         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15230
15231         /* Input mixer control */
15232         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15233            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15234         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15235         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15236         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15237         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15238         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15239         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15240         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15241         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15242
15243         {
15244                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15245                 .name = "Channel Mode",
15246                 .info = alc_ch_mode_info,
15247                 .get = alc_ch_mode_get,
15248                 .put = alc_ch_mode_put,
15249                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15250         },
15251         { } /* end */
15252 };
15253
15254 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15255         /* output mixer control */
15256         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15257         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15258         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15259
15260         { } /* end */
15261 };
15262
15263 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15264         /* output mixer control */
15265         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15266         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15267         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15268         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15269         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15270
15271         /* Input mixer control */
15272         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15273            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15274         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15275         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15276         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15277         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15278         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15279         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15280         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15281         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15282
15283         {
15284                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15285                 .name = "Channel Mode",
15286                 .info = alc_ch_mode_info,
15287                 .get = alc_ch_mode_get,
15288                 .put = alc_ch_mode_put,
15289                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15290         },
15291         { } /* end */
15292 };
15293
15294 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15295         /* output mixer control */
15296         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15297         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15298         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15299         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15300         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15301
15302         /* Input mixer control */
15303         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15304         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15305         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15306         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15307         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15308         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15309         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15310         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15311         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15312         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15313
15314         {
15315                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15316                 .name = "Channel Mode",
15317                 .info = alc_ch_mode_info,
15318                 .get = alc_ch_mode_get,
15319                 .put = alc_ch_mode_put,
15320                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15321         },
15322         { }
15323 };
15324
15325 /* additional mixer */
15326 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15327         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15328         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15329         { }
15330 };
15331
15332 /*
15333  * generic initialization of ADC, input mixers and output mixers
15334  */
15335 static struct hda_verb alc861_base_init_verbs[] = {
15336         /*
15337          * Unmute ADC0 and set the default input to mic-in
15338          */
15339         /* port-A for surround (rear panel) */
15340         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15341         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15342         /* port-B for mic-in (rear panel) with vref */
15343         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15344         /* port-C for line-in (rear panel) */
15345         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15346         /* port-D for Front */
15347         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15348         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15349         /* port-E for HP out (front panel) */
15350         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15351         /* route front PCM to HP */
15352         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15353         /* port-F for mic-in (front panel) with vref */
15354         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15355         /* port-G for CLFE (rear panel) */
15356         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15357         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15358         /* port-H for side (rear panel) */
15359         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15360         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15361         /* CD-in */
15362         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15363         /* route front mic to ADC1*/
15364         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15365         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15366
15367         /* Unmute DAC0~3 & spdif out*/
15368         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15369         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15370         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15371         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15373
15374         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15375         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15376         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15377         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15378         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15379
15380         /* Unmute Stereo Mixer 15 */
15381         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15382         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15383         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15384         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15385
15386         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15387         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15388         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15389         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15390         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15391         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15392         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15393         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15394         /* hp used DAC 3 (Front) */
15395         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15396         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15397
15398         { }
15399 };
15400
15401 static struct hda_verb alc861_threestack_init_verbs[] = {
15402         /*
15403          * Unmute ADC0 and set the default input to mic-in
15404          */
15405         /* port-A for surround (rear panel) */
15406         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15407         /* port-B for mic-in (rear panel) with vref */
15408         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15409         /* port-C for line-in (rear panel) */
15410         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15411         /* port-D for Front */
15412         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15413         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15414         /* port-E for HP out (front panel) */
15415         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15416         /* route front PCM to HP */
15417         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15418         /* port-F for mic-in (front panel) with vref */
15419         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15420         /* port-G for CLFE (rear panel) */
15421         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15422         /* port-H for side (rear panel) */
15423         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15424         /* CD-in */
15425         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15426         /* route front mic to ADC1*/
15427         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15428         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15429         /* Unmute DAC0~3 & spdif out*/
15430         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15431         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15432         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15433         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15434         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15435
15436         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15437         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15438         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15439         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15440         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15441
15442         /* Unmute Stereo Mixer 15 */
15443         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15444         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15445         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15446         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15447
15448         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15449         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15450         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15451         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15452         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15453         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15454         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15455         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15456         /* hp used DAC 3 (Front) */
15457         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15458         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15459         { }
15460 };
15461
15462 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15463         /*
15464          * Unmute ADC0 and set the default input to mic-in
15465          */
15466         /* port-A for surround (rear panel) */
15467         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15468         /* port-B for mic-in (rear panel) with vref */
15469         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15470         /* port-C for line-in (rear panel) */
15471         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15472         /* port-D for Front */
15473         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15474         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15475         /* port-E for HP out (front panel) */
15476         /* this has to be set to VREF80 */
15477         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15478         /* route front PCM to HP */
15479         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15480         /* port-F for mic-in (front panel) with vref */
15481         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15482         /* port-G for CLFE (rear panel) */
15483         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15484         /* port-H for side (rear panel) */
15485         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15486         /* CD-in */
15487         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15488         /* route front mic to ADC1*/
15489         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15490         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15491         /* Unmute DAC0~3 & spdif out*/
15492         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15493         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15494         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15495         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15496         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15497
15498         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15499         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15500         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15501         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15502         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15503
15504         /* Unmute Stereo Mixer 15 */
15505         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15506         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15507         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15508         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15509
15510         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15511         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15512         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15513         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15514         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15515         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15516         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15517         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15518         /* hp used DAC 3 (Front) */
15519         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15520         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15521         { }
15522 };
15523
15524 static struct hda_verb alc861_asus_init_verbs[] = {
15525         /*
15526          * Unmute ADC0 and set the default input to mic-in
15527          */
15528         /* port-A for surround (rear panel)
15529          * according to codec#0 this is the HP jack
15530          */
15531         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15532         /* route front PCM to HP */
15533         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15534         /* port-B for mic-in (rear panel) with vref */
15535         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15536         /* port-C for line-in (rear panel) */
15537         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15538         /* port-D for Front */
15539         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15540         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15541         /* port-E for HP out (front panel) */
15542         /* this has to be set to VREF80 */
15543         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15544         /* route front PCM to HP */
15545         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15546         /* port-F for mic-in (front panel) with vref */
15547         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15548         /* port-G for CLFE (rear panel) */
15549         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15550         /* port-H for side (rear panel) */
15551         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15552         /* CD-in */
15553         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15554         /* route front mic to ADC1*/
15555         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15556         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15557         /* Unmute DAC0~3 & spdif out*/
15558         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15559         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15560         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15561         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15562         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15563         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15564         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15565         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15566         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15567         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15568
15569         /* Unmute Stereo Mixer 15 */
15570         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15571         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15572         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15573         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15574
15575         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15576         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15577         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15578         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15579         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15580         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15581         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15582         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15583         /* hp used DAC 3 (Front) */
15584         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15585         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15586         { }
15587 };
15588
15589 /* additional init verbs for ASUS laptops */
15590 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15591         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15592         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15593         { }
15594 };
15595
15596 /*
15597  * generic initialization of ADC, input mixers and output mixers
15598  */
15599 static struct hda_verb alc861_auto_init_verbs[] = {
15600         /*
15601          * Unmute ADC0 and set the default input to mic-in
15602          */
15603         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15604         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15605
15606         /* Unmute DAC0~3 & spdif out*/
15607         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15608         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15609         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15610         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15611         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15612
15613         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15614         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15615         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15616         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15617         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15618
15619         /* Unmute Stereo Mixer 15 */
15620         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15621         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15622         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15623         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15624
15625         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15626         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15627         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15628         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15629         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15630         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15631         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15632         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15633
15634         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15635         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15636         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15637         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15638         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15639         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15640         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15641         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15642
15643         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15644
15645         { }
15646 };
15647
15648 static struct hda_verb alc861_toshiba_init_verbs[] = {
15649         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15650
15651         { }
15652 };
15653
15654 /* toggle speaker-output according to the hp-jack state */
15655 static void alc861_toshiba_automute(struct hda_codec *codec)
15656 {
15657         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15658
15659         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15660                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15661         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15662                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15663 }
15664
15665 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15666                                        unsigned int res)
15667 {
15668         if ((res >> 26) == ALC880_HP_EVENT)
15669                 alc861_toshiba_automute(codec);
15670 }
15671
15672 /* pcm configuration: identical with ALC880 */
15673 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15674 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15675 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15676 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15677
15678
15679 #define ALC861_DIGOUT_NID       0x07
15680
15681 static struct hda_channel_mode alc861_8ch_modes[1] = {
15682         { 8, NULL }
15683 };
15684
15685 static hda_nid_t alc861_dac_nids[4] = {
15686         /* front, surround, clfe, side */
15687         0x03, 0x06, 0x05, 0x04
15688 };
15689
15690 static hda_nid_t alc660_dac_nids[3] = {
15691         /* front, clfe, surround */
15692         0x03, 0x05, 0x06
15693 };
15694
15695 static hda_nid_t alc861_adc_nids[1] = {
15696         /* ADC0-2 */
15697         0x08,
15698 };
15699
15700 static struct hda_input_mux alc861_capture_source = {
15701         .num_items = 5,
15702         .items = {
15703                 { "Mic", 0x0 },
15704                 { "Front Mic", 0x3 },
15705                 { "Line", 0x1 },
15706                 { "CD", 0x4 },
15707                 { "Mixer", 0x5 },
15708         },
15709 };
15710
15711 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15712 {
15713         struct alc_spec *spec = codec->spec;
15714         hda_nid_t mix, srcs[5];
15715         int i, j, num;
15716
15717         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15718                 return 0;
15719         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15720         if (num < 0)
15721                 return 0;
15722         for (i = 0; i < num; i++) {
15723                 unsigned int type;
15724                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15725                 if (type != AC_WID_AUD_OUT)
15726                         continue;
15727                 for (j = 0; j < spec->multiout.num_dacs; j++)
15728                         if (spec->multiout.dac_nids[j] == srcs[i])
15729                                 break;
15730                 if (j >= spec->multiout.num_dacs)
15731                         return srcs[i];
15732         }
15733         return 0;
15734 }
15735
15736 /* fill in the dac_nids table from the parsed pin configuration */
15737 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15738                                      const struct auto_pin_cfg *cfg)
15739 {
15740         struct alc_spec *spec = codec->spec;
15741         int i;
15742         hda_nid_t nid, dac;
15743
15744         spec->multiout.dac_nids = spec->private_dac_nids;
15745         for (i = 0; i < cfg->line_outs; i++) {
15746                 nid = cfg->line_out_pins[i];
15747                 dac = alc861_look_for_dac(codec, nid);
15748                 if (!dac)
15749                         continue;
15750                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15751         }
15752         return 0;
15753 }
15754
15755 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15756                                 hda_nid_t nid, unsigned int chs)
15757 {
15758         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
15759                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15760 }
15761
15762 /* add playback controls from the parsed DAC table */
15763 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15764                                              const struct auto_pin_cfg *cfg)
15765 {
15766         struct alc_spec *spec = codec->spec;
15767         static const char *chname[4] = {
15768                 "Front", "Surround", NULL /*CLFE*/, "Side"
15769         };
15770         hda_nid_t nid;
15771         int i, err;
15772
15773         if (cfg->line_outs == 1) {
15774                 const char *pfx = NULL;
15775                 if (!cfg->hp_outs)
15776                         pfx = "Master";
15777                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15778                         pfx = "Speaker";
15779                 if (pfx) {
15780                         nid = spec->multiout.dac_nids[0];
15781                         return alc861_create_out_sw(codec, pfx, nid, 3);
15782                 }
15783         }
15784
15785         for (i = 0; i < cfg->line_outs; i++) {
15786                 nid = spec->multiout.dac_nids[i];
15787                 if (!nid)
15788                         continue;
15789                 if (i == 2) {
15790                         /* Center/LFE */
15791                         err = alc861_create_out_sw(codec, "Center", nid, 1);
15792                         if (err < 0)
15793                                 return err;
15794                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
15795                         if (err < 0)
15796                                 return err;
15797                 } else {
15798                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
15799                         if (err < 0)
15800                                 return err;
15801                 }
15802         }
15803         return 0;
15804 }
15805
15806 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15807 {
15808         struct alc_spec *spec = codec->spec;
15809         int err;
15810         hda_nid_t nid;
15811
15812         if (!pin)
15813                 return 0;
15814
15815         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15816                 nid = alc861_look_for_dac(codec, pin);
15817                 if (nid) {
15818                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15819                         if (err < 0)
15820                                 return err;
15821                         spec->multiout.hp_nid = nid;
15822                 }
15823         }
15824         return 0;
15825 }
15826
15827 /* create playback/capture controls for input pins */
15828 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15829                                                 const struct auto_pin_cfg *cfg)
15830 {
15831         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15832 }
15833
15834 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15835                                               hda_nid_t nid,
15836                                               int pin_type, hda_nid_t dac)
15837 {
15838         hda_nid_t mix, srcs[5];
15839         int i, num;
15840
15841         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15842                             pin_type);
15843         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15844                             AMP_OUT_UNMUTE);
15845         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15846                 return;
15847         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15848         if (num < 0)
15849                 return;
15850         for (i = 0; i < num; i++) {
15851                 unsigned int mute;
15852                 if (srcs[i] == dac || srcs[i] == 0x15)
15853                         mute = AMP_IN_UNMUTE(i);
15854                 else
15855                         mute = AMP_IN_MUTE(i);
15856                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15857                                     mute);
15858         }
15859 }
15860
15861 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15862 {
15863         struct alc_spec *spec = codec->spec;
15864         int i;
15865
15866         for (i = 0; i < spec->autocfg.line_outs; i++) {
15867                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15868                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15869                 if (nid)
15870                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15871                                                           spec->multiout.dac_nids[i]);
15872         }
15873 }
15874
15875 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15876 {
15877         struct alc_spec *spec = codec->spec;
15878
15879         if (spec->autocfg.hp_outs)
15880                 alc861_auto_set_output_and_unmute(codec,
15881                                                   spec->autocfg.hp_pins[0],
15882                                                   PIN_HP,
15883                                                   spec->multiout.hp_nid);
15884         if (spec->autocfg.speaker_outs)
15885                 alc861_auto_set_output_and_unmute(codec,
15886                                                   spec->autocfg.speaker_pins[0],
15887                                                   PIN_OUT,
15888                                                   spec->multiout.dac_nids[0]);
15889 }
15890
15891 static void alc861_auto_init_analog_input(struct hda_codec *codec)
15892 {
15893         struct alc_spec *spec = codec->spec;
15894         struct auto_pin_cfg *cfg = &spec->autocfg;
15895         int i;
15896
15897         for (i = 0; i < cfg->num_inputs; i++) {
15898                 hda_nid_t nid = cfg->inputs[i].pin;
15899                 if (nid >= 0x0c && nid <= 0x11)
15900                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
15901         }
15902 }
15903
15904 /* parse the BIOS configuration and set up the alc_spec */
15905 /* return 1 if successful, 0 if the proper config is not found,
15906  * or a negative error code
15907  */
15908 static int alc861_parse_auto_config(struct hda_codec *codec)
15909 {
15910         struct alc_spec *spec = codec->spec;
15911         int err;
15912         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15913
15914         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15915                                            alc861_ignore);
15916         if (err < 0)
15917                 return err;
15918         if (!spec->autocfg.line_outs)
15919                 return 0; /* can't find valid BIOS pin config */
15920
15921         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15922         if (err < 0)
15923                 return err;
15924         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15925         if (err < 0)
15926                 return err;
15927         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15928         if (err < 0)
15929                 return err;
15930         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15931         if (err < 0)
15932                 return err;
15933
15934         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15935
15936         alc_auto_parse_digital(codec);
15937
15938         if (spec->kctls.list)
15939                 add_mixer(spec, spec->kctls.list);
15940
15941         add_verb(spec, alc861_auto_init_verbs);
15942
15943         spec->num_mux_defs = 1;
15944         spec->input_mux = &spec->private_imux[0];
15945
15946         spec->adc_nids = alc861_adc_nids;
15947         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15948         set_capture_mixer(codec);
15949
15950         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15951
15952         return 1;
15953 }
15954
15955 /* additional initialization for auto-configuration model */
15956 static void alc861_auto_init(struct hda_codec *codec)
15957 {
15958         struct alc_spec *spec = codec->spec;
15959         alc861_auto_init_multi_out(codec);
15960         alc861_auto_init_hp_out(codec);
15961         alc861_auto_init_analog_input(codec);
15962         alc_auto_init_digital(codec);
15963         if (spec->unsol_event)
15964                 alc_inithook(codec);
15965 }
15966
15967 #ifdef CONFIG_SND_HDA_POWER_SAVE
15968 static struct hda_amp_list alc861_loopbacks[] = {
15969         { 0x15, HDA_INPUT, 0 },
15970         { 0x15, HDA_INPUT, 1 },
15971         { 0x15, HDA_INPUT, 2 },
15972         { 0x15, HDA_INPUT, 3 },
15973         { } /* end */
15974 };
15975 #endif
15976
15977
15978 /*
15979  * configuration and preset
15980  */
15981 static const char *alc861_models[ALC861_MODEL_LAST] = {
15982         [ALC861_3ST]            = "3stack",
15983         [ALC660_3ST]            = "3stack-660",
15984         [ALC861_3ST_DIG]        = "3stack-dig",
15985         [ALC861_6ST_DIG]        = "6stack-dig",
15986         [ALC861_UNIWILL_M31]    = "uniwill-m31",
15987         [ALC861_TOSHIBA]        = "toshiba",
15988         [ALC861_ASUS]           = "asus",
15989         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
15990         [ALC861_AUTO]           = "auto",
15991 };
15992
15993 static struct snd_pci_quirk alc861_cfg_tbl[] = {
15994         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15995         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15996         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15997         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15998         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15999         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16000         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16001         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16002          *        Any other models that need this preset?
16003          */
16004         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16005         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16006         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16007         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16008         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16009         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16010         /* FIXME: the below seems conflict */
16011         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16012         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16013         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16014         {}
16015 };
16016
16017 static struct alc_config_preset alc861_presets[] = {
16018         [ALC861_3ST] = {
16019                 .mixers = { alc861_3ST_mixer },
16020                 .init_verbs = { alc861_threestack_init_verbs },
16021                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16022                 .dac_nids = alc861_dac_nids,
16023                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16024                 .channel_mode = alc861_threestack_modes,
16025                 .need_dac_fix = 1,
16026                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16027                 .adc_nids = alc861_adc_nids,
16028                 .input_mux = &alc861_capture_source,
16029         },
16030         [ALC861_3ST_DIG] = {
16031                 .mixers = { alc861_base_mixer },
16032                 .init_verbs = { alc861_threestack_init_verbs },
16033                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16034                 .dac_nids = alc861_dac_nids,
16035                 .dig_out_nid = ALC861_DIGOUT_NID,
16036                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16037                 .channel_mode = alc861_threestack_modes,
16038                 .need_dac_fix = 1,
16039                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16040                 .adc_nids = alc861_adc_nids,
16041                 .input_mux = &alc861_capture_source,
16042         },
16043         [ALC861_6ST_DIG] = {
16044                 .mixers = { alc861_base_mixer },
16045                 .init_verbs = { alc861_base_init_verbs },
16046                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16047                 .dac_nids = alc861_dac_nids,
16048                 .dig_out_nid = ALC861_DIGOUT_NID,
16049                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16050                 .channel_mode = alc861_8ch_modes,
16051                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16052                 .adc_nids = alc861_adc_nids,
16053                 .input_mux = &alc861_capture_source,
16054         },
16055         [ALC660_3ST] = {
16056                 .mixers = { alc861_3ST_mixer },
16057                 .init_verbs = { alc861_threestack_init_verbs },
16058                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16059                 .dac_nids = alc660_dac_nids,
16060                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16061                 .channel_mode = alc861_threestack_modes,
16062                 .need_dac_fix = 1,
16063                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16064                 .adc_nids = alc861_adc_nids,
16065                 .input_mux = &alc861_capture_source,
16066         },
16067         [ALC861_UNIWILL_M31] = {
16068                 .mixers = { alc861_uniwill_m31_mixer },
16069                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16070                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16071                 .dac_nids = alc861_dac_nids,
16072                 .dig_out_nid = ALC861_DIGOUT_NID,
16073                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16074                 .channel_mode = alc861_uniwill_m31_modes,
16075                 .need_dac_fix = 1,
16076                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16077                 .adc_nids = alc861_adc_nids,
16078                 .input_mux = &alc861_capture_source,
16079         },
16080         [ALC861_TOSHIBA] = {
16081                 .mixers = { alc861_toshiba_mixer },
16082                 .init_verbs = { alc861_base_init_verbs,
16083                                 alc861_toshiba_init_verbs },
16084                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16085                 .dac_nids = alc861_dac_nids,
16086                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16087                 .channel_mode = alc883_3ST_2ch_modes,
16088                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16089                 .adc_nids = alc861_adc_nids,
16090                 .input_mux = &alc861_capture_source,
16091                 .unsol_event = alc861_toshiba_unsol_event,
16092                 .init_hook = alc861_toshiba_automute,
16093         },
16094         [ALC861_ASUS] = {
16095                 .mixers = { alc861_asus_mixer },
16096                 .init_verbs = { alc861_asus_init_verbs },
16097                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16098                 .dac_nids = alc861_dac_nids,
16099                 .dig_out_nid = ALC861_DIGOUT_NID,
16100                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16101                 .channel_mode = alc861_asus_modes,
16102                 .need_dac_fix = 1,
16103                 .hp_nid = 0x06,
16104                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16105                 .adc_nids = alc861_adc_nids,
16106                 .input_mux = &alc861_capture_source,
16107         },
16108         [ALC861_ASUS_LAPTOP] = {
16109                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16110                 .init_verbs = { alc861_asus_init_verbs,
16111                                 alc861_asus_laptop_init_verbs },
16112                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16113                 .dac_nids = alc861_dac_nids,
16114                 .dig_out_nid = ALC861_DIGOUT_NID,
16115                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16116                 .channel_mode = alc883_3ST_2ch_modes,
16117                 .need_dac_fix = 1,
16118                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16119                 .adc_nids = alc861_adc_nids,
16120                 .input_mux = &alc861_capture_source,
16121         },
16122 };
16123
16124 /* Pin config fixes */
16125 enum {
16126         PINFIX_FSC_AMILO_PI1505,
16127 };
16128
16129 static const struct alc_fixup alc861_fixups[] = {
16130         [PINFIX_FSC_AMILO_PI1505] = {
16131                 .pins = (const struct alc_pincfg[]) {
16132                         { 0x0b, 0x0221101f }, /* HP */
16133                         { 0x0f, 0x90170310 }, /* speaker */
16134                         { }
16135                 }
16136         },
16137 };
16138
16139 static struct snd_pci_quirk alc861_fixup_tbl[] = {
16140         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16141         {}
16142 };
16143
16144 static int patch_alc861(struct hda_codec *codec)
16145 {
16146         struct alc_spec *spec;
16147         int board_config;
16148         int err;
16149
16150         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16151         if (spec == NULL)
16152                 return -ENOMEM;
16153
16154         codec->spec = spec;
16155
16156         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16157                                                   alc861_models,
16158                                                   alc861_cfg_tbl);
16159
16160         if (board_config < 0) {
16161                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16162                        codec->chip_name);
16163                 board_config = ALC861_AUTO;
16164         }
16165
16166         if (board_config == ALC861_AUTO)
16167                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
16168
16169         if (board_config == ALC861_AUTO) {
16170                 /* automatic parse from the BIOS config */
16171                 err = alc861_parse_auto_config(codec);
16172                 if (err < 0) {
16173                         alc_free(codec);
16174                         return err;
16175                 } else if (!err) {
16176                         printk(KERN_INFO
16177                                "hda_codec: Cannot set up configuration "
16178                                "from BIOS.  Using base mode...\n");
16179                    board_config = ALC861_3ST_DIG;
16180                 }
16181         }
16182
16183         err = snd_hda_attach_beep_device(codec, 0x23);
16184         if (err < 0) {
16185                 alc_free(codec);
16186                 return err;
16187         }
16188
16189         if (board_config != ALC861_AUTO)
16190                 setup_preset(codec, &alc861_presets[board_config]);
16191
16192         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16193         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16194
16195         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16196         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16197
16198         if (!spec->cap_mixer)
16199                 set_capture_mixer(codec);
16200         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16201
16202         spec->vmaster_nid = 0x03;
16203
16204         if (board_config == ALC861_AUTO)
16205                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
16206
16207         codec->patch_ops = alc_patch_ops;
16208         if (board_config == ALC861_AUTO) {
16209                 spec->init_hook = alc861_auto_init;
16210 #ifdef CONFIG_SND_HDA_POWER_SAVE
16211                 spec->power_hook = alc_power_eapd;
16212 #endif
16213         }
16214 #ifdef CONFIG_SND_HDA_POWER_SAVE
16215         if (!spec->loopback.amplist)
16216                 spec->loopback.amplist = alc861_loopbacks;
16217 #endif
16218
16219         return 0;
16220 }
16221
16222 /*
16223  * ALC861-VD support
16224  *
16225  * Based on ALC882
16226  *
16227  * In addition, an independent DAC
16228  */
16229 #define ALC861VD_DIGOUT_NID     0x06
16230
16231 static hda_nid_t alc861vd_dac_nids[4] = {
16232         /* front, surr, clfe, side surr */
16233         0x02, 0x03, 0x04, 0x05
16234 };
16235
16236 /* dac_nids for ALC660vd are in a different order - according to
16237  * Realtek's driver.
16238  * This should probably result in a different mixer for 6stack models
16239  * of ALC660vd codecs, but for now there is only 3stack mixer
16240  * - and it is the same as in 861vd.
16241  * adc_nids in ALC660vd are (is) the same as in 861vd
16242  */
16243 static hda_nid_t alc660vd_dac_nids[3] = {
16244         /* front, rear, clfe, rear_surr */
16245         0x02, 0x04, 0x03
16246 };
16247
16248 static hda_nid_t alc861vd_adc_nids[1] = {
16249         /* ADC0 */
16250         0x09,
16251 };
16252
16253 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16254
16255 /* input MUX */
16256 /* FIXME: should be a matrix-type input source selection */
16257 static struct hda_input_mux alc861vd_capture_source = {
16258         .num_items = 4,
16259         .items = {
16260                 { "Mic", 0x0 },
16261                 { "Front Mic", 0x1 },
16262                 { "Line", 0x2 },
16263                 { "CD", 0x4 },
16264         },
16265 };
16266
16267 static struct hda_input_mux alc861vd_dallas_capture_source = {
16268         .num_items = 2,
16269         .items = {
16270                 { "Ext Mic", 0x0 },
16271                 { "Int Mic", 0x1 },
16272         },
16273 };
16274
16275 static struct hda_input_mux alc861vd_hp_capture_source = {
16276         .num_items = 2,
16277         .items = {
16278                 { "Front Mic", 0x0 },
16279                 { "ATAPI Mic", 0x1 },
16280         },
16281 };
16282
16283 /*
16284  * 2ch mode
16285  */
16286 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16287         { 2, NULL }
16288 };
16289
16290 /*
16291  * 6ch mode
16292  */
16293 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16294         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16295         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16296         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16297         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16298         { } /* end */
16299 };
16300
16301 /*
16302  * 8ch mode
16303  */
16304 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16305         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16306         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16307         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16308         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16309         { } /* end */
16310 };
16311
16312 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16313         { 6, alc861vd_6stack_ch6_init },
16314         { 8, alc861vd_6stack_ch8_init },
16315 };
16316
16317 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16318         {
16319                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16320                 .name = "Channel Mode",
16321                 .info = alc_ch_mode_info,
16322                 .get = alc_ch_mode_get,
16323                 .put = alc_ch_mode_put,
16324         },
16325         { } /* end */
16326 };
16327
16328 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16329  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16330  */
16331 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16332         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16333         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16334
16335         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16336         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16337
16338         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16339                                 HDA_OUTPUT),
16340         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16341                                 HDA_OUTPUT),
16342         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16343         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16344
16345         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16346         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16347
16348         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16349
16350         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16351         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16352         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16353
16354         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16355         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16356         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16357
16358         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16359         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16360
16361         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16362         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16363
16364         { } /* end */
16365 };
16366
16367 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16368         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16369         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16370
16371         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16372
16373         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16374         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16375         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16376
16377         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16378         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16379         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16380
16381         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16382         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16383
16384         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16385         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16386
16387         { } /* end */
16388 };
16389
16390 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16391         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16392         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16393         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16394
16395         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16396
16397         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16399         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16400
16401         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16402         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16403         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16404
16405         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16406         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16407
16408         { } /* end */
16409 };
16410
16411 /* Pin assignment: Speaker=0x14, HP = 0x15,
16412  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16413  */
16414 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16415         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16416         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16417         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16418         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16419         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16420         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16421         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16422         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16423         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16424         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16425         { } /* end */
16426 };
16427
16428 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16429  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16430  */
16431 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16432         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16433         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16434         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16435         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16436         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16437         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16438         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16439         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16440
16441         { } /* end */
16442 };
16443
16444 /*
16445  * generic initialization of ADC, input mixers and output mixers
16446  */
16447 static struct hda_verb alc861vd_volume_init_verbs[] = {
16448         /*
16449          * Unmute ADC0 and set the default input to mic-in
16450          */
16451         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16452         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16453
16454         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16455          * the analog-loopback mixer widget
16456          */
16457         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16458         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16459         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16460         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16461         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16462         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16463
16464         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16465         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16466         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16467         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16468         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16469
16470         /*
16471          * Set up output mixers (0x02 - 0x05)
16472          */
16473         /* set vol=0 to output mixers */
16474         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16475         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16476         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16477         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16478
16479         /* set up input amps for analog loopback */
16480         /* Amp Indices: DAC = 0, mixer = 1 */
16481         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16482         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16483         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16484         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16485         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16486         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16487         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16488         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16489
16490         { }
16491 };
16492
16493 /*
16494  * 3-stack pin configuration:
16495  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16496  */
16497 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16498         /*
16499          * Set pin mode and muting
16500          */
16501         /* set front pin widgets 0x14 for output */
16502         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16503         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16504         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16505
16506         /* Mic (rear) pin: input vref at 80% */
16507         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16508         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16509         /* Front Mic pin: input vref at 80% */
16510         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16511         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16512         /* Line In pin: input */
16513         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16514         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16515         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16516         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16517         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16518         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16519         /* CD pin widget for input */
16520         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16521
16522         { }
16523 };
16524
16525 /*
16526  * 6-stack pin configuration:
16527  */
16528 static struct hda_verb alc861vd_6stack_init_verbs[] = {
16529         /*
16530          * Set pin mode and muting
16531          */
16532         /* set front pin widgets 0x14 for output */
16533         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16534         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16535         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16536
16537         /* Rear Pin: output 1 (0x0d) */
16538         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16539         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16540         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16541         /* CLFE Pin: output 2 (0x0e) */
16542         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16543         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16544         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16545         /* Side Pin: output 3 (0x0f) */
16546         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16547         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16548         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16549
16550         /* Mic (rear) pin: input vref at 80% */
16551         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16552         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16553         /* Front Mic pin: input vref at 80% */
16554         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16555         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16556         /* Line In pin: input */
16557         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16558         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16559         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16560         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16561         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16562         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16563         /* CD pin widget for input */
16564         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16565
16566         { }
16567 };
16568
16569 static struct hda_verb alc861vd_eapd_verbs[] = {
16570         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16571         { }
16572 };
16573
16574 static struct hda_verb alc660vd_eapd_verbs[] = {
16575         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16576         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16577         { }
16578 };
16579
16580 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16583         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16584         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16585         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16586         {}
16587 };
16588
16589 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
16590 {
16591         unsigned int present;
16592         unsigned char bits;
16593
16594         present = snd_hda_jack_detect(codec, 0x18);
16595         bits = present ? HDA_AMP_MUTE : 0;
16596
16597         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
16598                                  HDA_AMP_MUTE, bits);
16599 }
16600
16601 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16602 {
16603         struct alc_spec *spec = codec->spec;
16604         spec->autocfg.hp_pins[0] = 0x1b;
16605         spec->autocfg.speaker_pins[0] = 0x14;
16606 }
16607
16608 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16609 {
16610         alc_automute_amp(codec);
16611         alc861vd_lenovo_mic_automute(codec);
16612 }
16613
16614 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16615                                         unsigned int res)
16616 {
16617         switch (res >> 26) {
16618         case ALC880_MIC_EVENT:
16619                 alc861vd_lenovo_mic_automute(codec);
16620                 break;
16621         default:
16622                 alc_automute_amp_unsol_event(codec, res);
16623                 break;
16624         }
16625 }
16626
16627 static struct hda_verb alc861vd_dallas_verbs[] = {
16628         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16629         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16630         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16631         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16632
16633         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16634         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16635         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16636         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16637         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16638         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16639         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16640         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16641
16642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16643         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16644         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16645         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16646         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16647         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16648         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16649         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16650
16651         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16652         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16653         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16654         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16655         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16656         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16657         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16658         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16659
16660         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16661         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16662         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16663         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16664
16665         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16666         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16667         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16668
16669         { } /* end */
16670 };
16671
16672 /* toggle speaker-output according to the hp-jack state */
16673 static void alc861vd_dallas_setup(struct hda_codec *codec)
16674 {
16675         struct alc_spec *spec = codec->spec;
16676
16677         spec->autocfg.hp_pins[0] = 0x15;
16678         spec->autocfg.speaker_pins[0] = 0x14;
16679 }
16680
16681 #ifdef CONFIG_SND_HDA_POWER_SAVE
16682 #define alc861vd_loopbacks      alc880_loopbacks
16683 #endif
16684
16685 /* pcm configuration: identical with ALC880 */
16686 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16687 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16688 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16689 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16690
16691 /*
16692  * configuration and preset
16693  */
16694 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16695         [ALC660VD_3ST]          = "3stack-660",
16696         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16697         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16698         [ALC861VD_3ST]          = "3stack",
16699         [ALC861VD_3ST_DIG]      = "3stack-digout",
16700         [ALC861VD_6ST_DIG]      = "6stack-digout",
16701         [ALC861VD_LENOVO]       = "lenovo",
16702         [ALC861VD_DALLAS]       = "dallas",
16703         [ALC861VD_HP]           = "hp",
16704         [ALC861VD_AUTO]         = "auto",
16705 };
16706
16707 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16708         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16709         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16710         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16711         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16712         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16713         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16714         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16715         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16716         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16717         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16718         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16719         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16720         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16721         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16722         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16723         {}
16724 };
16725
16726 static struct alc_config_preset alc861vd_presets[] = {
16727         [ALC660VD_3ST] = {
16728                 .mixers = { alc861vd_3st_mixer },
16729                 .init_verbs = { alc861vd_volume_init_verbs,
16730                                  alc861vd_3stack_init_verbs },
16731                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16732                 .dac_nids = alc660vd_dac_nids,
16733                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16734                 .channel_mode = alc861vd_3stack_2ch_modes,
16735                 .input_mux = &alc861vd_capture_source,
16736         },
16737         [ALC660VD_3ST_DIG] = {
16738                 .mixers = { alc861vd_3st_mixer },
16739                 .init_verbs = { alc861vd_volume_init_verbs,
16740                                  alc861vd_3stack_init_verbs },
16741                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16742                 .dac_nids = alc660vd_dac_nids,
16743                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16744                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16745                 .channel_mode = alc861vd_3stack_2ch_modes,
16746                 .input_mux = &alc861vd_capture_source,
16747         },
16748         [ALC861VD_3ST] = {
16749                 .mixers = { alc861vd_3st_mixer },
16750                 .init_verbs = { alc861vd_volume_init_verbs,
16751                                  alc861vd_3stack_init_verbs },
16752                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16753                 .dac_nids = alc861vd_dac_nids,
16754                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16755                 .channel_mode = alc861vd_3stack_2ch_modes,
16756                 .input_mux = &alc861vd_capture_source,
16757         },
16758         [ALC861VD_3ST_DIG] = {
16759                 .mixers = { alc861vd_3st_mixer },
16760                 .init_verbs = { alc861vd_volume_init_verbs,
16761                                  alc861vd_3stack_init_verbs },
16762                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16763                 .dac_nids = alc861vd_dac_nids,
16764                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16765                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16766                 .channel_mode = alc861vd_3stack_2ch_modes,
16767                 .input_mux = &alc861vd_capture_source,
16768         },
16769         [ALC861VD_6ST_DIG] = {
16770                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16771                 .init_verbs = { alc861vd_volume_init_verbs,
16772                                 alc861vd_6stack_init_verbs },
16773                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16774                 .dac_nids = alc861vd_dac_nids,
16775                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16776                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16777                 .channel_mode = alc861vd_6stack_modes,
16778                 .input_mux = &alc861vd_capture_source,
16779         },
16780         [ALC861VD_LENOVO] = {
16781                 .mixers = { alc861vd_lenovo_mixer },
16782                 .init_verbs = { alc861vd_volume_init_verbs,
16783                                 alc861vd_3stack_init_verbs,
16784                                 alc861vd_eapd_verbs,
16785                                 alc861vd_lenovo_unsol_verbs },
16786                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16787                 .dac_nids = alc660vd_dac_nids,
16788                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16789                 .channel_mode = alc861vd_3stack_2ch_modes,
16790                 .input_mux = &alc861vd_capture_source,
16791                 .unsol_event = alc861vd_lenovo_unsol_event,
16792                 .setup = alc861vd_lenovo_setup,
16793                 .init_hook = alc861vd_lenovo_init_hook,
16794         },
16795         [ALC861VD_DALLAS] = {
16796                 .mixers = { alc861vd_dallas_mixer },
16797                 .init_verbs = { alc861vd_dallas_verbs },
16798                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16799                 .dac_nids = alc861vd_dac_nids,
16800                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16801                 .channel_mode = alc861vd_3stack_2ch_modes,
16802                 .input_mux = &alc861vd_dallas_capture_source,
16803                 .unsol_event = alc_automute_amp_unsol_event,
16804                 .setup = alc861vd_dallas_setup,
16805                 .init_hook = alc_automute_amp,
16806         },
16807         [ALC861VD_HP] = {
16808                 .mixers = { alc861vd_hp_mixer },
16809                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16810                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16811                 .dac_nids = alc861vd_dac_nids,
16812                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16813                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16814                 .channel_mode = alc861vd_3stack_2ch_modes,
16815                 .input_mux = &alc861vd_hp_capture_source,
16816                 .unsol_event = alc_automute_amp_unsol_event,
16817                 .setup = alc861vd_dallas_setup,
16818                 .init_hook = alc_automute_amp,
16819         },
16820         [ALC660VD_ASUS_V1S] = {
16821                 .mixers = { alc861vd_lenovo_mixer },
16822                 .init_verbs = { alc861vd_volume_init_verbs,
16823                                 alc861vd_3stack_init_verbs,
16824                                 alc861vd_eapd_verbs,
16825                                 alc861vd_lenovo_unsol_verbs },
16826                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16827                 .dac_nids = alc660vd_dac_nids,
16828                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16829                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16830                 .channel_mode = alc861vd_3stack_2ch_modes,
16831                 .input_mux = &alc861vd_capture_source,
16832                 .unsol_event = alc861vd_lenovo_unsol_event,
16833                 .setup = alc861vd_lenovo_setup,
16834                 .init_hook = alc861vd_lenovo_init_hook,
16835         },
16836 };
16837
16838 /*
16839  * BIOS auto configuration
16840  */
16841 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16842                                                 const struct auto_pin_cfg *cfg)
16843 {
16844         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16845 }
16846
16847
16848 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16849                                 hda_nid_t nid, int pin_type, int dac_idx)
16850 {
16851         alc_set_pin_output(codec, nid, pin_type);
16852 }
16853
16854 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16855 {
16856         struct alc_spec *spec = codec->spec;
16857         int i;
16858
16859         for (i = 0; i <= HDA_SIDE; i++) {
16860                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16861                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16862                 if (nid)
16863                         alc861vd_auto_set_output_and_unmute(codec, nid,
16864                                                             pin_type, i);
16865         }
16866 }
16867
16868
16869 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16870 {
16871         struct alc_spec *spec = codec->spec;
16872         hda_nid_t pin;
16873
16874         pin = spec->autocfg.hp_pins[0];
16875         if (pin) /* connect to front and use dac 0 */
16876                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16877         pin = spec->autocfg.speaker_pins[0];
16878         if (pin)
16879                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16880 }
16881
16882 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16883
16884 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16885 {
16886         struct alc_spec *spec = codec->spec;
16887         struct auto_pin_cfg *cfg = &spec->autocfg;
16888         int i;
16889
16890         for (i = 0; i < cfg->num_inputs; i++) {
16891                 hda_nid_t nid = cfg->inputs[i].pin;
16892                 if (alc_is_input_pin(codec, nid)) {
16893                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16894                         if (nid != ALC861VD_PIN_CD_NID &&
16895                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16896                                 snd_hda_codec_write(codec, nid, 0,
16897                                                 AC_VERB_SET_AMP_GAIN_MUTE,
16898                                                 AMP_OUT_MUTE);
16899                 }
16900         }
16901 }
16902
16903 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
16904
16905 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
16906 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
16907
16908 /* add playback controls from the parsed DAC table */
16909 /* Based on ALC880 version. But ALC861VD has separate,
16910  * different NIDs for mute/unmute switch and volume control */
16911 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16912                                              const struct auto_pin_cfg *cfg)
16913 {
16914         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16915         hda_nid_t nid_v, nid_s;
16916         int i, err;
16917
16918         for (i = 0; i < cfg->line_outs; i++) {
16919                 if (!spec->multiout.dac_nids[i])
16920                         continue;
16921                 nid_v = alc861vd_idx_to_mixer_vol(
16922                                 alc880_dac_to_idx(
16923                                         spec->multiout.dac_nids[i]));
16924                 nid_s = alc861vd_idx_to_mixer_switch(
16925                                 alc880_dac_to_idx(
16926                                         spec->multiout.dac_nids[i]));
16927
16928                 if (i == 2) {
16929                         /* Center/LFE */
16930                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16931                                               "Center",
16932                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16933                                                               HDA_OUTPUT));
16934                         if (err < 0)
16935                                 return err;
16936                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16937                                               "LFE",
16938                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16939                                                               HDA_OUTPUT));
16940                         if (err < 0)
16941                                 return err;
16942                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16943                                              "Center",
16944                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16945                                                               HDA_INPUT));
16946                         if (err < 0)
16947                                 return err;
16948                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16949                                              "LFE",
16950                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16951                                                               HDA_INPUT));
16952                         if (err < 0)
16953                                 return err;
16954                 } else {
16955                         const char *pfx;
16956                         if (cfg->line_outs == 1 &&
16957                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16958                                 if (!cfg->hp_pins)
16959                                         pfx = "Speaker";
16960                                 else
16961                                         pfx = "PCM";
16962                         } else
16963                                 pfx = chname[i];
16964                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16965                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16966                                                               HDA_OUTPUT));
16967                         if (err < 0)
16968                                 return err;
16969                         if (cfg->line_outs == 1 &&
16970                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16971                                 pfx = "Speaker";
16972                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16973                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16974                                                               HDA_INPUT));
16975                         if (err < 0)
16976                                 return err;
16977                 }
16978         }
16979         return 0;
16980 }
16981
16982 /* add playback controls for speaker and HP outputs */
16983 /* Based on ALC880 version. But ALC861VD has separate,
16984  * different NIDs for mute/unmute switch and volume control */
16985 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16986                                         hda_nid_t pin, const char *pfx)
16987 {
16988         hda_nid_t nid_v, nid_s;
16989         int err;
16990
16991         if (!pin)
16992                 return 0;
16993
16994         if (alc880_is_fixed_pin(pin)) {
16995                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16996                 /* specify the DAC as the extra output */
16997                 if (!spec->multiout.hp_nid)
16998                         spec->multiout.hp_nid = nid_v;
16999                 else
17000                         spec->multiout.extra_out_nid[0] = nid_v;
17001                 /* control HP volume/switch on the output mixer amp */
17002                 nid_v = alc861vd_idx_to_mixer_vol(
17003                                 alc880_fixed_pin_idx(pin));
17004                 nid_s = alc861vd_idx_to_mixer_switch(
17005                                 alc880_fixed_pin_idx(pin));
17006
17007                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17008                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17009                 if (err < 0)
17010                         return err;
17011                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17012                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17013                 if (err < 0)
17014                         return err;
17015         } else if (alc880_is_multi_pin(pin)) {
17016                 /* set manual connection */
17017                 /* we have only a switch on HP-out PIN */
17018                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17019                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17020                 if (err < 0)
17021                         return err;
17022         }
17023         return 0;
17024 }
17025
17026 /* parse the BIOS configuration and set up the alc_spec
17027  * return 1 if successful, 0 if the proper config is not found,
17028  * or a negative error code
17029  * Based on ALC880 version - had to change it to override
17030  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17031 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17032 {
17033         struct alc_spec *spec = codec->spec;
17034         int err;
17035         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17036
17037         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17038                                            alc861vd_ignore);
17039         if (err < 0)
17040                 return err;
17041         if (!spec->autocfg.line_outs)
17042                 return 0; /* can't find valid BIOS pin config */
17043
17044         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17045         if (err < 0)
17046                 return err;
17047         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17048         if (err < 0)
17049                 return err;
17050         err = alc861vd_auto_create_extra_out(spec,
17051                                              spec->autocfg.speaker_pins[0],
17052                                              "Speaker");
17053         if (err < 0)
17054                 return err;
17055         err = alc861vd_auto_create_extra_out(spec,
17056                                              spec->autocfg.hp_pins[0],
17057                                              "Headphone");
17058         if (err < 0)
17059                 return err;
17060         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17061         if (err < 0)
17062                 return err;
17063
17064         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17065
17066         alc_auto_parse_digital(codec);
17067
17068         if (spec->kctls.list)
17069                 add_mixer(spec, spec->kctls.list);
17070
17071         add_verb(spec, alc861vd_volume_init_verbs);
17072
17073         spec->num_mux_defs = 1;
17074         spec->input_mux = &spec->private_imux[0];
17075
17076         err = alc_auto_add_mic_boost(codec);
17077         if (err < 0)
17078                 return err;
17079
17080         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17081
17082         return 1;
17083 }
17084
17085 /* additional initialization for auto-configuration model */
17086 static void alc861vd_auto_init(struct hda_codec *codec)
17087 {
17088         struct alc_spec *spec = codec->spec;
17089         alc861vd_auto_init_multi_out(codec);
17090         alc861vd_auto_init_hp_out(codec);
17091         alc861vd_auto_init_analog_input(codec);
17092         alc861vd_auto_init_input_src(codec);
17093         alc_auto_init_digital(codec);
17094         if (spec->unsol_event)
17095                 alc_inithook(codec);
17096 }
17097
17098 enum {
17099         ALC660VD_FIX_ASUS_GPIO1
17100 };
17101
17102 /* reset GPIO1 */
17103 static const struct alc_fixup alc861vd_fixups[] = {
17104         [ALC660VD_FIX_ASUS_GPIO1] = {
17105                 .verbs = (const struct hda_verb[]) {
17106                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17107                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17108                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17109                         { }
17110                 }
17111         },
17112 };
17113
17114 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17115         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17116         {}
17117 };
17118
17119 static int patch_alc861vd(struct hda_codec *codec)
17120 {
17121         struct alc_spec *spec;
17122         int err, board_config;
17123
17124         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17125         if (spec == NULL)
17126                 return -ENOMEM;
17127
17128         codec->spec = spec;
17129
17130         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17131                                                   alc861vd_models,
17132                                                   alc861vd_cfg_tbl);
17133
17134         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17135                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17136                        codec->chip_name);
17137                 board_config = ALC861VD_AUTO;
17138         }
17139
17140         if (board_config == ALC861VD_AUTO)
17141                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
17142
17143         if (board_config == ALC861VD_AUTO) {
17144                 /* automatic parse from the BIOS config */
17145                 err = alc861vd_parse_auto_config(codec);
17146                 if (err < 0) {
17147                         alc_free(codec);
17148                         return err;
17149                 } else if (!err) {
17150                         printk(KERN_INFO
17151                                "hda_codec: Cannot set up configuration "
17152                                "from BIOS.  Using base mode...\n");
17153                         board_config = ALC861VD_3ST;
17154                 }
17155         }
17156
17157         err = snd_hda_attach_beep_device(codec, 0x23);
17158         if (err < 0) {
17159                 alc_free(codec);
17160                 return err;
17161         }
17162
17163         if (board_config != ALC861VD_AUTO)
17164                 setup_preset(codec, &alc861vd_presets[board_config]);
17165
17166         if (codec->vendor_id == 0x10ec0660) {
17167                 /* always turn on EAPD */
17168                 add_verb(spec, alc660vd_eapd_verbs);
17169         }
17170
17171         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17172         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17173
17174         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17175         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17176
17177         if (!spec->adc_nids) {
17178                 spec->adc_nids = alc861vd_adc_nids;
17179                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17180         }
17181         if (!spec->capsrc_nids)
17182                 spec->capsrc_nids = alc861vd_capsrc_nids;
17183
17184         set_capture_mixer(codec);
17185         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17186
17187         spec->vmaster_nid = 0x02;
17188
17189         if (board_config == ALC861VD_AUTO)
17190                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
17191
17192         codec->patch_ops = alc_patch_ops;
17193
17194         if (board_config == ALC861VD_AUTO)
17195                 spec->init_hook = alc861vd_auto_init;
17196 #ifdef CONFIG_SND_HDA_POWER_SAVE
17197         if (!spec->loopback.amplist)
17198                 spec->loopback.amplist = alc861vd_loopbacks;
17199 #endif
17200
17201         return 0;
17202 }
17203
17204 /*
17205  * ALC662 support
17206  *
17207  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17208  * configuration.  Each pin widget can choose any input DACs and a mixer.
17209  * Each ADC is connected from a mixer of all inputs.  This makes possible
17210  * 6-channel independent captures.
17211  *
17212  * In addition, an independent DAC for the multi-playback (not used in this
17213  * driver yet).
17214  */
17215 #define ALC662_DIGOUT_NID       0x06
17216 #define ALC662_DIGIN_NID        0x0a
17217
17218 static hda_nid_t alc662_dac_nids[4] = {
17219         /* front, rear, clfe, rear_surr */
17220         0x02, 0x03, 0x04
17221 };
17222
17223 static hda_nid_t alc272_dac_nids[2] = {
17224         0x02, 0x03
17225 };
17226
17227 static hda_nid_t alc662_adc_nids[2] = {
17228         /* ADC1-2 */
17229         0x09, 0x08
17230 };
17231
17232 static hda_nid_t alc272_adc_nids[1] = {
17233         /* ADC1-2 */
17234         0x08,
17235 };
17236
17237 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17238 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17239
17240
17241 /* input MUX */
17242 /* FIXME: should be a matrix-type input source selection */
17243 static struct hda_input_mux alc662_capture_source = {
17244         .num_items = 4,
17245         .items = {
17246                 { "Mic", 0x0 },
17247                 { "Front Mic", 0x1 },
17248                 { "Line", 0x2 },
17249                 { "CD", 0x4 },
17250         },
17251 };
17252
17253 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17254         .num_items = 2,
17255         .items = {
17256                 { "Mic", 0x1 },
17257                 { "Line", 0x2 },
17258         },
17259 };
17260
17261 static struct hda_input_mux alc663_capture_source = {
17262         .num_items = 3,
17263         .items = {
17264                 { "Mic", 0x0 },
17265                 { "Front Mic", 0x1 },
17266                 { "Line", 0x2 },
17267         },
17268 };
17269
17270 #if 0 /* set to 1 for testing other input sources below */
17271 static struct hda_input_mux alc272_nc10_capture_source = {
17272         .num_items = 16,
17273         .items = {
17274                 { "Autoselect Mic", 0x0 },
17275                 { "Internal Mic", 0x1 },
17276                 { "In-0x02", 0x2 },
17277                 { "In-0x03", 0x3 },
17278                 { "In-0x04", 0x4 },
17279                 { "In-0x05", 0x5 },
17280                 { "In-0x06", 0x6 },
17281                 { "In-0x07", 0x7 },
17282                 { "In-0x08", 0x8 },
17283                 { "In-0x09", 0x9 },
17284                 { "In-0x0a", 0x0a },
17285                 { "In-0x0b", 0x0b },
17286                 { "In-0x0c", 0x0c },
17287                 { "In-0x0d", 0x0d },
17288                 { "In-0x0e", 0x0e },
17289                 { "In-0x0f", 0x0f },
17290         },
17291 };
17292 #endif
17293
17294 /*
17295  * 2ch mode
17296  */
17297 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17298         { 2, NULL }
17299 };
17300
17301 /*
17302  * 2ch mode
17303  */
17304 static struct hda_verb alc662_3ST_ch2_init[] = {
17305         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17306         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17307         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17308         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17309         { } /* end */
17310 };
17311
17312 /*
17313  * 6ch mode
17314  */
17315 static struct hda_verb alc662_3ST_ch6_init[] = {
17316         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17317         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17318         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17319         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17320         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17321         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17322         { } /* end */
17323 };
17324
17325 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17326         { 2, alc662_3ST_ch2_init },
17327         { 6, alc662_3ST_ch6_init },
17328 };
17329
17330 /*
17331  * 2ch mode
17332  */
17333 static struct hda_verb alc662_sixstack_ch6_init[] = {
17334         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17335         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17336         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17337         { } /* end */
17338 };
17339
17340 /*
17341  * 6ch mode
17342  */
17343 static struct hda_verb alc662_sixstack_ch8_init[] = {
17344         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17345         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17346         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17347         { } /* end */
17348 };
17349
17350 static struct hda_channel_mode alc662_5stack_modes[2] = {
17351         { 2, alc662_sixstack_ch6_init },
17352         { 6, alc662_sixstack_ch8_init },
17353 };
17354
17355 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17356  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17357  */
17358
17359 static struct snd_kcontrol_new alc662_base_mixer[] = {
17360         /* output mixer control */
17361         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17362         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17363         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17364         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17365         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17366         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17367         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17368         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17369         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17370
17371         /*Input mixer control */
17372         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17373         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17374         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17375         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17376         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17377         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17378         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17379         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17380         { } /* end */
17381 };
17382
17383 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17384         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17385         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17386         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17387         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17388         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17389         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17390         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17391         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17392         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17393         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17394         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17395         { } /* end */
17396 };
17397
17398 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17399         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17400         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17401         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17402         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17403         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17404         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17405         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17406         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17407         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17408         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17409         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17410         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17411         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17412         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17413         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17414         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17415         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17416         { } /* end */
17417 };
17418
17419 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17420         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17421         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17422         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17423         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17424         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17425         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17426         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17427         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17428         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17429         { } /* end */
17430 };
17431
17432 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17433         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17434         ALC262_HIPPO_MASTER_SWITCH,
17435
17436         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
17437         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17438         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17439
17440         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17441         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17442         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17443         { } /* end */
17444 };
17445
17446 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17447         ALC262_HIPPO_MASTER_SWITCH,
17448         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17449         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17450         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17451         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17452         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17453         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17454         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17455         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17456         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17457         { } /* end */
17458 };
17459
17460 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17461         .ops = &snd_hda_bind_vol,
17462         .values = {
17463                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17464                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17465                 0
17466         },
17467 };
17468
17469 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17470         .ops = &snd_hda_bind_sw,
17471         .values = {
17472                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17473                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17474                 0
17475         },
17476 };
17477
17478 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17479         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17480         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17481         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17482         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17483         { } /* end */
17484 };
17485
17486 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17487         .ops = &snd_hda_bind_sw,
17488         .values = {
17489                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17490                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17491                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17492                 0
17493         },
17494 };
17495
17496 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17497         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17498         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17499         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17500         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17501         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17502         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17503
17504         { } /* end */
17505 };
17506
17507 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17508         .ops = &snd_hda_bind_sw,
17509         .values = {
17510                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17511                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17512                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17513                 0
17514         },
17515 };
17516
17517 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17518         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17519         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17520         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17521         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17522         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17523         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17524         { } /* end */
17525 };
17526
17527 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17528         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17529         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17530         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17531         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17532         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17533         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17534         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17535         { } /* end */
17536 };
17537
17538 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17539         .ops = &snd_hda_bind_vol,
17540         .values = {
17541                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17542                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17543                 0
17544         },
17545 };
17546
17547 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17548         .ops = &snd_hda_bind_sw,
17549         .values = {
17550                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17551                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17552                 0
17553         },
17554 };
17555
17556 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17557         HDA_BIND_VOL("Master Playback Volume",
17558                                 &alc663_asus_two_bind_master_vol),
17559         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17560         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17561         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17562         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17563         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17564         { } /* end */
17565 };
17566
17567 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17568         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17569         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17570         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17571         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17572         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17573         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17574         { } /* end */
17575 };
17576
17577 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17578         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17579         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17580         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17581         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17582         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17583
17584         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17585         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17586         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17587         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17588         { } /* end */
17589 };
17590
17591 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17592         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17593         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17594         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17595
17596         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17597         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17598         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17599         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17600         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17601         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17602         { } /* end */
17603 };
17604
17605 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17606         .ops = &snd_hda_bind_sw,
17607         .values = {
17608                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17609                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17610                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17611                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17612                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17613                 0
17614         },
17615 };
17616
17617 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17618         .ops = &snd_hda_bind_sw,
17619         .values = {
17620                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17621                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17622                 0
17623         },
17624 };
17625
17626 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17627         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17628         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17629         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17630         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17631         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17632         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17633         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17634         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17635         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17636         { } /* end */
17637 };
17638
17639 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17640         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17641         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17642         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17643         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17644         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17645         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17646         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17647         { } /* end */
17648 };
17649
17650
17651 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17652         {
17653                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17654                 .name = "Channel Mode",
17655                 .info = alc_ch_mode_info,
17656                 .get = alc_ch_mode_get,
17657                 .put = alc_ch_mode_put,
17658         },
17659         { } /* end */
17660 };
17661
17662 static struct hda_verb alc662_init_verbs[] = {
17663         /* ADC: mute amp left and right */
17664         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17665         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17666
17667         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17668         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17669         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17670         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17671         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17672         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17673
17674         /* Front Pin: output 0 (0x0c) */
17675         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17676         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17677
17678         /* Rear Pin: output 1 (0x0d) */
17679         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17680         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17681
17682         /* CLFE Pin: output 2 (0x0e) */
17683         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17684         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17685
17686         /* Mic (rear) pin: input vref at 80% */
17687         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17688         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17689         /* Front Mic pin: input vref at 80% */
17690         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17691         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17692         /* Line In pin: input */
17693         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17694         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17695         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17696         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17697         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17698         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17699         /* CD pin widget for input */
17700         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17701
17702         /* FIXME: use matrix-type input source selection */
17703         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17704         /* Input mixer */
17705         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17706         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17707
17708         /* always trun on EAPD */
17709         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17710         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17711
17712         { }
17713 };
17714
17715 static struct hda_verb alc663_init_verbs[] = {
17716         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17717         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17718         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17719         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17720         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17721         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17722         { }
17723 };
17724
17725 static struct hda_verb alc272_init_verbs[] = {
17726         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17727         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17728         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17729         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17730         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17731         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17732         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17733         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17734         { }
17735 };
17736
17737 static struct hda_verb alc662_sue_init_verbs[] = {
17738         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17739         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17740         {}
17741 };
17742
17743 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17744         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17745         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17746         {}
17747 };
17748
17749 /* Set Unsolicited Event*/
17750 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17751         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17752         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17753         {}
17754 };
17755
17756 static struct hda_verb alc663_m51va_init_verbs[] = {
17757         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17758         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17759         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17760         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17761         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17762         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17763         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17764         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17765         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17766         {}
17767 };
17768
17769 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17770         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17771         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17772         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17773         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17774         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17775         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17776         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17777         {}
17778 };
17779
17780 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17781         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17782         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17783         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17784         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17785         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17786         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17787         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17788         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17789         {}
17790 };
17791
17792 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17793         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17794         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17795         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17796         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17797         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17798         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17799         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17800         {}
17801 };
17802
17803 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17804         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17805         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17806         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17807         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17808         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17809         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17810         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17811         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17812         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17813         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17814         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17815         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17816         {}
17817 };
17818
17819 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17820         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17821         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17822         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17823         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17824         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17825         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17826         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17828         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17829         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17830         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17831         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17832         {}
17833 };
17834
17835 static struct hda_verb alc663_g71v_init_verbs[] = {
17836         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17837         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17838         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17839
17840         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17841         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17842         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17843
17844         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17845         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17846         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17847         {}
17848 };
17849
17850 static struct hda_verb alc663_g50v_init_verbs[] = {
17851         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17852         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17853         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17854
17855         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17856         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17857         {}
17858 };
17859
17860 static struct hda_verb alc662_ecs_init_verbs[] = {
17861         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17862         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17863         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17864         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17865         {}
17866 };
17867
17868 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17869         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17870         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17871         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17872         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17873         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17874         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17875         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17876         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17877         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17878         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17879         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17880         {}
17881 };
17882
17883 static struct hda_verb alc272_dell_init_verbs[] = {
17884         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17885         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17886         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17887         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17888         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17889         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17890         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17891         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17892         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17893         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17894         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17895         {}
17896 };
17897
17898 static struct hda_verb alc663_mode7_init_verbs[] = {
17899         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17900         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17901         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17902         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17903         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17904         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17905         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
17906         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17907         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17908         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17909         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17910         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17911         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17912         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17913         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17914         {}
17915 };
17916
17917 static struct hda_verb alc663_mode8_init_verbs[] = {
17918         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
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, 0x01},
17922         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17923         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17924         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17925         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17926         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17927         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17928         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17929         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17930         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17931         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17932         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17933         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17934         {}
17935 };
17936
17937 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17938         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17939         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17940         { } /* end */
17941 };
17942
17943 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17944         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17945         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17946         { } /* end */
17947 };
17948
17949 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17950 {
17951         unsigned int present;
17952         unsigned char bits;
17953
17954         present = snd_hda_jack_detect(codec, 0x14);
17955         bits = present ? HDA_AMP_MUTE : 0;
17956
17957         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17958                                  HDA_AMP_MUTE, bits);
17959 }
17960
17961 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17962 {
17963         unsigned int present;
17964         unsigned char bits;
17965
17966         present = snd_hda_jack_detect(codec, 0x1b);
17967         bits = present ? HDA_AMP_MUTE : 0;
17968
17969         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17970                                  HDA_AMP_MUTE, bits);
17971         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17972                                  HDA_AMP_MUTE, bits);
17973 }
17974
17975 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17976                                            unsigned int res)
17977 {
17978         if ((res >> 26) == ALC880_HP_EVENT)
17979                 alc662_lenovo_101e_all_automute(codec);
17980         if ((res >> 26) == ALC880_FRONT_EVENT)
17981                 alc662_lenovo_101e_ispeaker_automute(codec);
17982 }
17983
17984 /* unsolicited event for HP jack sensing */
17985 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17986                                      unsigned int res)
17987 {
17988         if ((res >> 26) == ALC880_MIC_EVENT)
17989                 alc_mic_automute(codec);
17990         else
17991                 alc262_hippo_unsol_event(codec, res);
17992 }
17993
17994 static void alc662_eeepc_setup(struct hda_codec *codec)
17995 {
17996         struct alc_spec *spec = codec->spec;
17997
17998         alc262_hippo1_setup(codec);
17999         spec->ext_mic.pin = 0x18;
18000         spec->ext_mic.mux_idx = 0;
18001         spec->int_mic.pin = 0x19;
18002         spec->int_mic.mux_idx = 1;
18003         spec->auto_mic = 1;
18004 }
18005
18006 static void alc662_eeepc_inithook(struct hda_codec *codec)
18007 {
18008         alc262_hippo_automute(codec);
18009         alc_mic_automute(codec);
18010 }
18011
18012 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18013 {
18014         struct alc_spec *spec = codec->spec;
18015
18016         spec->autocfg.hp_pins[0] = 0x14;
18017         spec->autocfg.speaker_pins[0] = 0x1b;
18018 }
18019
18020 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
18021
18022 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18023 {
18024         unsigned int present;
18025         unsigned char bits;
18026
18027         present = snd_hda_jack_detect(codec, 0x21);
18028         bits = present ? HDA_AMP_MUTE : 0;
18029         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18030                                  HDA_AMP_MUTE, bits);
18031         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18032                                  HDA_AMP_MUTE, bits);
18033 }
18034
18035 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18036 {
18037         unsigned int present;
18038         unsigned char bits;
18039
18040         present = snd_hda_jack_detect(codec, 0x21);
18041         bits = present ? HDA_AMP_MUTE : 0;
18042         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18043                                  HDA_AMP_MUTE, bits);
18044         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18045                                  HDA_AMP_MUTE, bits);
18046         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18047                                  HDA_AMP_MUTE, bits);
18048         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18049                                  HDA_AMP_MUTE, bits);
18050 }
18051
18052 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18053 {
18054         unsigned int present;
18055         unsigned char bits;
18056
18057         present = snd_hda_jack_detect(codec, 0x15);
18058         bits = present ? HDA_AMP_MUTE : 0;
18059         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18060                                  HDA_AMP_MUTE, bits);
18061         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18062                                  HDA_AMP_MUTE, bits);
18063         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18064                                  HDA_AMP_MUTE, bits);
18065         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18066                                  HDA_AMP_MUTE, bits);
18067 }
18068
18069 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18070 {
18071         unsigned int present;
18072         unsigned char bits;
18073
18074         present = snd_hda_jack_detect(codec, 0x1b);
18075         bits = present ? 0 : PIN_OUT;
18076         snd_hda_codec_write(codec, 0x14, 0,
18077                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18078 }
18079
18080 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18081 {
18082         unsigned int present1, present2;
18083
18084         present1 = snd_hda_jack_detect(codec, 0x21);
18085         present2 = snd_hda_jack_detect(codec, 0x15);
18086
18087         if (present1 || present2) {
18088                 snd_hda_codec_write_cache(codec, 0x14, 0,
18089                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18090         } else {
18091                 snd_hda_codec_write_cache(codec, 0x14, 0,
18092                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18093         }
18094 }
18095
18096 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18097 {
18098         unsigned int present1, present2;
18099
18100         present1 = snd_hda_jack_detect(codec, 0x1b);
18101         present2 = snd_hda_jack_detect(codec, 0x15);
18102
18103         if (present1 || present2) {
18104                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18105                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18106                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18107                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18108         } else {
18109                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18110                                          HDA_AMP_MUTE, 0);
18111                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18112                                          HDA_AMP_MUTE, 0);
18113         }
18114 }
18115
18116 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18117 {
18118         unsigned int present1, present2;
18119
18120         present1 = snd_hda_codec_read(codec, 0x1b, 0,
18121                         AC_VERB_GET_PIN_SENSE, 0)
18122                         & AC_PINSENSE_PRESENCE;
18123         present2 = snd_hda_codec_read(codec, 0x21, 0,
18124                         AC_VERB_GET_PIN_SENSE, 0)
18125                         & AC_PINSENSE_PRESENCE;
18126
18127         if (present1 || present2) {
18128                 snd_hda_codec_write_cache(codec, 0x14, 0,
18129                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18130                 snd_hda_codec_write_cache(codec, 0x17, 0,
18131                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18132         } else {
18133                 snd_hda_codec_write_cache(codec, 0x14, 0,
18134                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18135                 snd_hda_codec_write_cache(codec, 0x17, 0,
18136                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18137         }
18138 }
18139
18140 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18141 {
18142         unsigned int present1, present2;
18143
18144         present1 = snd_hda_codec_read(codec, 0x21, 0,
18145                         AC_VERB_GET_PIN_SENSE, 0)
18146                         & AC_PINSENSE_PRESENCE;
18147         present2 = snd_hda_codec_read(codec, 0x15, 0,
18148                         AC_VERB_GET_PIN_SENSE, 0)
18149                         & AC_PINSENSE_PRESENCE;
18150
18151         if (present1 || present2) {
18152                 snd_hda_codec_write_cache(codec, 0x14, 0,
18153                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18154                 snd_hda_codec_write_cache(codec, 0x17, 0,
18155                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18156         } else {
18157                 snd_hda_codec_write_cache(codec, 0x14, 0,
18158                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18159                 snd_hda_codec_write_cache(codec, 0x17, 0,
18160                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18161         }
18162 }
18163
18164 static void alc663_m51va_unsol_event(struct hda_codec *codec,
18165                                            unsigned int res)
18166 {
18167         switch (res >> 26) {
18168         case ALC880_HP_EVENT:
18169                 alc663_m51va_speaker_automute(codec);
18170                 break;
18171         case ALC880_MIC_EVENT:
18172                 alc_mic_automute(codec);
18173                 break;
18174         }
18175 }
18176
18177 static void alc663_m51va_setup(struct hda_codec *codec)
18178 {
18179         struct alc_spec *spec = codec->spec;
18180         spec->ext_mic.pin = 0x18;
18181         spec->ext_mic.mux_idx = 0;
18182         spec->int_mic.pin = 0x12;
18183         spec->int_mic.mux_idx = 9;
18184         spec->auto_mic = 1;
18185 }
18186
18187 static void alc663_m51va_inithook(struct hda_codec *codec)
18188 {
18189         alc663_m51va_speaker_automute(codec);
18190         alc_mic_automute(codec);
18191 }
18192
18193 /* ***************** Mode1 ******************************/
18194 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
18195
18196 static void alc663_mode1_setup(struct hda_codec *codec)
18197 {
18198         struct alc_spec *spec = codec->spec;
18199         spec->ext_mic.pin = 0x18;
18200         spec->ext_mic.mux_idx = 0;
18201         spec->int_mic.pin = 0x19;
18202         spec->int_mic.mux_idx = 1;
18203         spec->auto_mic = 1;
18204 }
18205
18206 #define alc663_mode1_inithook           alc663_m51va_inithook
18207
18208 /* ***************** Mode2 ******************************/
18209 static void alc662_mode2_unsol_event(struct hda_codec *codec,
18210                                            unsigned int res)
18211 {
18212         switch (res >> 26) {
18213         case ALC880_HP_EVENT:
18214                 alc662_f5z_speaker_automute(codec);
18215                 break;
18216         case ALC880_MIC_EVENT:
18217                 alc_mic_automute(codec);
18218                 break;
18219         }
18220 }
18221
18222 #define alc662_mode2_setup      alc663_mode1_setup
18223
18224 static void alc662_mode2_inithook(struct hda_codec *codec)
18225 {
18226         alc662_f5z_speaker_automute(codec);
18227         alc_mic_automute(codec);
18228 }
18229 /* ***************** Mode3 ******************************/
18230 static void alc663_mode3_unsol_event(struct hda_codec *codec,
18231                                            unsigned int res)
18232 {
18233         switch (res >> 26) {
18234         case ALC880_HP_EVENT:
18235                 alc663_two_hp_m1_speaker_automute(codec);
18236                 break;
18237         case ALC880_MIC_EVENT:
18238                 alc_mic_automute(codec);
18239                 break;
18240         }
18241 }
18242
18243 #define alc663_mode3_setup      alc663_mode1_setup
18244
18245 static void alc663_mode3_inithook(struct hda_codec *codec)
18246 {
18247         alc663_two_hp_m1_speaker_automute(codec);
18248         alc_mic_automute(codec);
18249 }
18250 /* ***************** Mode4 ******************************/
18251 static void alc663_mode4_unsol_event(struct hda_codec *codec,
18252                                            unsigned int res)
18253 {
18254         switch (res >> 26) {
18255         case ALC880_HP_EVENT:
18256                 alc663_21jd_two_speaker_automute(codec);
18257                 break;
18258         case ALC880_MIC_EVENT:
18259                 alc_mic_automute(codec);
18260                 break;
18261         }
18262 }
18263
18264 #define alc663_mode4_setup      alc663_mode1_setup
18265
18266 static void alc663_mode4_inithook(struct hda_codec *codec)
18267 {
18268         alc663_21jd_two_speaker_automute(codec);
18269         alc_mic_automute(codec);
18270 }
18271 /* ***************** Mode5 ******************************/
18272 static void alc663_mode5_unsol_event(struct hda_codec *codec,
18273                                            unsigned int res)
18274 {
18275         switch (res >> 26) {
18276         case ALC880_HP_EVENT:
18277                 alc663_15jd_two_speaker_automute(codec);
18278                 break;
18279         case ALC880_MIC_EVENT:
18280                 alc_mic_automute(codec);
18281                 break;
18282         }
18283 }
18284
18285 #define alc663_mode5_setup      alc663_mode1_setup
18286
18287 static void alc663_mode5_inithook(struct hda_codec *codec)
18288 {
18289         alc663_15jd_two_speaker_automute(codec);
18290         alc_mic_automute(codec);
18291 }
18292 /* ***************** Mode6 ******************************/
18293 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18294                                            unsigned int res)
18295 {
18296         switch (res >> 26) {
18297         case ALC880_HP_EVENT:
18298                 alc663_two_hp_m2_speaker_automute(codec);
18299                 break;
18300         case ALC880_MIC_EVENT:
18301                 alc_mic_automute(codec);
18302                 break;
18303         }
18304 }
18305
18306 #define alc663_mode6_setup      alc663_mode1_setup
18307
18308 static void alc663_mode6_inithook(struct hda_codec *codec)
18309 {
18310         alc663_two_hp_m2_speaker_automute(codec);
18311         alc_mic_automute(codec);
18312 }
18313
18314 /* ***************** Mode7 ******************************/
18315 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18316                                            unsigned int res)
18317 {
18318         switch (res >> 26) {
18319         case ALC880_HP_EVENT:
18320                 alc663_two_hp_m7_speaker_automute(codec);
18321                 break;
18322         case ALC880_MIC_EVENT:
18323                 alc_mic_automute(codec);
18324                 break;
18325         }
18326 }
18327
18328 #define alc663_mode7_setup      alc663_mode1_setup
18329
18330 static void alc663_mode7_inithook(struct hda_codec *codec)
18331 {
18332         alc663_two_hp_m7_speaker_automute(codec);
18333         alc_mic_automute(codec);
18334 }
18335
18336 /* ***************** Mode8 ******************************/
18337 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18338                                            unsigned int res)
18339 {
18340         switch (res >> 26) {
18341         case ALC880_HP_EVENT:
18342                 alc663_two_hp_m8_speaker_automute(codec);
18343                 break;
18344         case ALC880_MIC_EVENT:
18345                 alc_mic_automute(codec);
18346                 break;
18347         }
18348 }
18349
18350 #define alc663_mode8_setup      alc663_m51va_setup
18351
18352 static void alc663_mode8_inithook(struct hda_codec *codec)
18353 {
18354         alc663_two_hp_m8_speaker_automute(codec);
18355         alc_mic_automute(codec);
18356 }
18357
18358 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18359 {
18360         unsigned int present;
18361         unsigned char bits;
18362
18363         present = snd_hda_jack_detect(codec, 0x21);
18364         bits = present ? HDA_AMP_MUTE : 0;
18365         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18366                                  HDA_AMP_MUTE, bits);
18367         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18368                                  HDA_AMP_MUTE, bits);
18369 }
18370
18371 static void alc663_g71v_front_automute(struct hda_codec *codec)
18372 {
18373         unsigned int present;
18374         unsigned char bits;
18375
18376         present = snd_hda_jack_detect(codec, 0x15);
18377         bits = present ? HDA_AMP_MUTE : 0;
18378         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18379                                  HDA_AMP_MUTE, bits);
18380 }
18381
18382 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18383                                            unsigned int res)
18384 {
18385         switch (res >> 26) {
18386         case ALC880_HP_EVENT:
18387                 alc663_g71v_hp_automute(codec);
18388                 break;
18389         case ALC880_FRONT_EVENT:
18390                 alc663_g71v_front_automute(codec);
18391                 break;
18392         case ALC880_MIC_EVENT:
18393                 alc_mic_automute(codec);
18394                 break;
18395         }
18396 }
18397
18398 #define alc663_g71v_setup       alc663_m51va_setup
18399
18400 static void alc663_g71v_inithook(struct hda_codec *codec)
18401 {
18402         alc663_g71v_front_automute(codec);
18403         alc663_g71v_hp_automute(codec);
18404         alc_mic_automute(codec);
18405 }
18406
18407 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18408                                            unsigned int res)
18409 {
18410         switch (res >> 26) {
18411         case ALC880_HP_EVENT:
18412                 alc663_m51va_speaker_automute(codec);
18413                 break;
18414         case ALC880_MIC_EVENT:
18415                 alc_mic_automute(codec);
18416                 break;
18417         }
18418 }
18419
18420 #define alc663_g50v_setup       alc663_m51va_setup
18421
18422 static void alc663_g50v_inithook(struct hda_codec *codec)
18423 {
18424         alc663_m51va_speaker_automute(codec);
18425         alc_mic_automute(codec);
18426 }
18427
18428 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18429         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18430         ALC262_HIPPO_MASTER_SWITCH,
18431
18432         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
18433         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18434         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18435
18436         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
18437         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18438         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18439         { } /* end */
18440 };
18441
18442 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18443         /* Master Playback automatically created from Speaker and Headphone */
18444         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18445         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18446         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18447         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18448
18449         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18450         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18451         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
18452
18453         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18454         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18455         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
18456         { } /* end */
18457 };
18458
18459 #ifdef CONFIG_SND_HDA_POWER_SAVE
18460 #define alc662_loopbacks        alc880_loopbacks
18461 #endif
18462
18463
18464 /* pcm configuration: identical with ALC880 */
18465 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18466 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18467 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18468 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18469
18470 /*
18471  * configuration and preset
18472  */
18473 static const char *alc662_models[ALC662_MODEL_LAST] = {
18474         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18475         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18476         [ALC662_3ST_6ch]        = "3stack-6ch",
18477         [ALC662_5ST_DIG]        = "6stack-dig",
18478         [ALC662_LENOVO_101E]    = "lenovo-101e",
18479         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18480         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18481         [ALC662_ECS] = "ecs",
18482         [ALC663_ASUS_M51VA] = "m51va",
18483         [ALC663_ASUS_G71V] = "g71v",
18484         [ALC663_ASUS_H13] = "h13",
18485         [ALC663_ASUS_G50V] = "g50v",
18486         [ALC663_ASUS_MODE1] = "asus-mode1",
18487         [ALC662_ASUS_MODE2] = "asus-mode2",
18488         [ALC663_ASUS_MODE3] = "asus-mode3",
18489         [ALC663_ASUS_MODE4] = "asus-mode4",
18490         [ALC663_ASUS_MODE5] = "asus-mode5",
18491         [ALC663_ASUS_MODE6] = "asus-mode6",
18492         [ALC663_ASUS_MODE7] = "asus-mode7",
18493         [ALC663_ASUS_MODE8] = "asus-mode8",
18494         [ALC272_DELL]           = "dell",
18495         [ALC272_DELL_ZM1]       = "dell-zm1",
18496         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18497         [ALC662_AUTO]           = "auto",
18498 };
18499
18500 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18501         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18502         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18503         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18504         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18505         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18506         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18507         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18508         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18509         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18510         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18511         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18512         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18513         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18514         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18515         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18516         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18517         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18518         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18519         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18520         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18521         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18522         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18523         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18524         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18525         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18526         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18527         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18528         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18529         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18530         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18531         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18532         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18533         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18534         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18535         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18536         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18537         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18538         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18539         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18540         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18541         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18542         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18543         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18544         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18545         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18546         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18547         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18548         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18549         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18550         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18551         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18552         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18553         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18554         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18555         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18556         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18557         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18558         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18559         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18560         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18561         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18562         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18563         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18564         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18565                       ALC662_3ST_6ch_DIG),
18566         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18567         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18568         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18569                       ALC662_3ST_6ch_DIG),
18570         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18571         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18572         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18573         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18574         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18575                                         ALC662_3ST_6ch_DIG),
18576         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18577                            ALC663_ASUS_H13),
18578         {}
18579 };
18580
18581 static struct alc_config_preset alc662_presets[] = {
18582         [ALC662_3ST_2ch_DIG] = {
18583                 .mixers = { alc662_3ST_2ch_mixer },
18584                 .init_verbs = { alc662_init_verbs },
18585                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18586                 .dac_nids = alc662_dac_nids,
18587                 .dig_out_nid = ALC662_DIGOUT_NID,
18588                 .dig_in_nid = ALC662_DIGIN_NID,
18589                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18590                 .channel_mode = alc662_3ST_2ch_modes,
18591                 .input_mux = &alc662_capture_source,
18592         },
18593         [ALC662_3ST_6ch_DIG] = {
18594                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18595                 .init_verbs = { alc662_init_verbs },
18596                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18597                 .dac_nids = alc662_dac_nids,
18598                 .dig_out_nid = ALC662_DIGOUT_NID,
18599                 .dig_in_nid = ALC662_DIGIN_NID,
18600                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18601                 .channel_mode = alc662_3ST_6ch_modes,
18602                 .need_dac_fix = 1,
18603                 .input_mux = &alc662_capture_source,
18604         },
18605         [ALC662_3ST_6ch] = {
18606                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18607                 .init_verbs = { alc662_init_verbs },
18608                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18609                 .dac_nids = alc662_dac_nids,
18610                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18611                 .channel_mode = alc662_3ST_6ch_modes,
18612                 .need_dac_fix = 1,
18613                 .input_mux = &alc662_capture_source,
18614         },
18615         [ALC662_5ST_DIG] = {
18616                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18617                 .init_verbs = { alc662_init_verbs },
18618                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18619                 .dac_nids = alc662_dac_nids,
18620                 .dig_out_nid = ALC662_DIGOUT_NID,
18621                 .dig_in_nid = ALC662_DIGIN_NID,
18622                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18623                 .channel_mode = alc662_5stack_modes,
18624                 .input_mux = &alc662_capture_source,
18625         },
18626         [ALC662_LENOVO_101E] = {
18627                 .mixers = { alc662_lenovo_101e_mixer },
18628                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18629                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18630                 .dac_nids = alc662_dac_nids,
18631                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18632                 .channel_mode = alc662_3ST_2ch_modes,
18633                 .input_mux = &alc662_lenovo_101e_capture_source,
18634                 .unsol_event = alc662_lenovo_101e_unsol_event,
18635                 .init_hook = alc662_lenovo_101e_all_automute,
18636         },
18637         [ALC662_ASUS_EEEPC_P701] = {
18638                 .mixers = { alc662_eeepc_p701_mixer },
18639                 .init_verbs = { alc662_init_verbs,
18640                                 alc662_eeepc_sue_init_verbs },
18641                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18642                 .dac_nids = alc662_dac_nids,
18643                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18644                 .channel_mode = alc662_3ST_2ch_modes,
18645                 .unsol_event = alc662_eeepc_unsol_event,
18646                 .setup = alc662_eeepc_setup,
18647                 .init_hook = alc662_eeepc_inithook,
18648         },
18649         [ALC662_ASUS_EEEPC_EP20] = {
18650                 .mixers = { alc662_eeepc_ep20_mixer,
18651                             alc662_chmode_mixer },
18652                 .init_verbs = { alc662_init_verbs,
18653                                 alc662_eeepc_ep20_sue_init_verbs },
18654                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18655                 .dac_nids = alc662_dac_nids,
18656                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18657                 .channel_mode = alc662_3ST_6ch_modes,
18658                 .input_mux = &alc662_lenovo_101e_capture_source,
18659                 .unsol_event = alc662_eeepc_unsol_event,
18660                 .setup = alc662_eeepc_ep20_setup,
18661                 .init_hook = alc662_eeepc_ep20_inithook,
18662         },
18663         [ALC662_ECS] = {
18664                 .mixers = { alc662_ecs_mixer },
18665                 .init_verbs = { alc662_init_verbs,
18666                                 alc662_ecs_init_verbs },
18667                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18668                 .dac_nids = alc662_dac_nids,
18669                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18670                 .channel_mode = alc662_3ST_2ch_modes,
18671                 .unsol_event = alc662_eeepc_unsol_event,
18672                 .setup = alc662_eeepc_setup,
18673                 .init_hook = alc662_eeepc_inithook,
18674         },
18675         [ALC663_ASUS_M51VA] = {
18676                 .mixers = { alc663_m51va_mixer },
18677                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18678                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18679                 .dac_nids = alc662_dac_nids,
18680                 .dig_out_nid = ALC662_DIGOUT_NID,
18681                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18682                 .channel_mode = alc662_3ST_2ch_modes,
18683                 .unsol_event = alc663_m51va_unsol_event,
18684                 .setup = alc663_m51va_setup,
18685                 .init_hook = alc663_m51va_inithook,
18686         },
18687         [ALC663_ASUS_G71V] = {
18688                 .mixers = { alc663_g71v_mixer },
18689                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18690                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18691                 .dac_nids = alc662_dac_nids,
18692                 .dig_out_nid = ALC662_DIGOUT_NID,
18693                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18694                 .channel_mode = alc662_3ST_2ch_modes,
18695                 .unsol_event = alc663_g71v_unsol_event,
18696                 .setup = alc663_g71v_setup,
18697                 .init_hook = alc663_g71v_inithook,
18698         },
18699         [ALC663_ASUS_H13] = {
18700                 .mixers = { alc663_m51va_mixer },
18701                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18702                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18703                 .dac_nids = alc662_dac_nids,
18704                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18705                 .channel_mode = alc662_3ST_2ch_modes,
18706                 .unsol_event = alc663_m51va_unsol_event,
18707                 .init_hook = alc663_m51va_inithook,
18708         },
18709         [ALC663_ASUS_G50V] = {
18710                 .mixers = { alc663_g50v_mixer },
18711                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18712                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18713                 .dac_nids = alc662_dac_nids,
18714                 .dig_out_nid = ALC662_DIGOUT_NID,
18715                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18716                 .channel_mode = alc662_3ST_6ch_modes,
18717                 .input_mux = &alc663_capture_source,
18718                 .unsol_event = alc663_g50v_unsol_event,
18719                 .setup = alc663_g50v_setup,
18720                 .init_hook = alc663_g50v_inithook,
18721         },
18722         [ALC663_ASUS_MODE1] = {
18723                 .mixers = { alc663_m51va_mixer },
18724                 .cap_mixer = alc662_auto_capture_mixer,
18725                 .init_verbs = { alc662_init_verbs,
18726                                 alc663_21jd_amic_init_verbs },
18727                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18728                 .hp_nid = 0x03,
18729                 .dac_nids = alc662_dac_nids,
18730                 .dig_out_nid = ALC662_DIGOUT_NID,
18731                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18732                 .channel_mode = alc662_3ST_2ch_modes,
18733                 .unsol_event = alc663_mode1_unsol_event,
18734                 .setup = alc663_mode1_setup,
18735                 .init_hook = alc663_mode1_inithook,
18736         },
18737         [ALC662_ASUS_MODE2] = {
18738                 .mixers = { alc662_1bjd_mixer },
18739                 .cap_mixer = alc662_auto_capture_mixer,
18740                 .init_verbs = { alc662_init_verbs,
18741                                 alc662_1bjd_amic_init_verbs },
18742                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18743                 .dac_nids = alc662_dac_nids,
18744                 .dig_out_nid = ALC662_DIGOUT_NID,
18745                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18746                 .channel_mode = alc662_3ST_2ch_modes,
18747                 .unsol_event = alc662_mode2_unsol_event,
18748                 .setup = alc662_mode2_setup,
18749                 .init_hook = alc662_mode2_inithook,
18750         },
18751         [ALC663_ASUS_MODE3] = {
18752                 .mixers = { alc663_two_hp_m1_mixer },
18753                 .cap_mixer = alc662_auto_capture_mixer,
18754                 .init_verbs = { alc662_init_verbs,
18755                                 alc663_two_hp_amic_m1_init_verbs },
18756                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18757                 .hp_nid = 0x03,
18758                 .dac_nids = alc662_dac_nids,
18759                 .dig_out_nid = ALC662_DIGOUT_NID,
18760                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18761                 .channel_mode = alc662_3ST_2ch_modes,
18762                 .unsol_event = alc663_mode3_unsol_event,
18763                 .setup = alc663_mode3_setup,
18764                 .init_hook = alc663_mode3_inithook,
18765         },
18766         [ALC663_ASUS_MODE4] = {
18767                 .mixers = { alc663_asus_21jd_clfe_mixer },
18768                 .cap_mixer = alc662_auto_capture_mixer,
18769                 .init_verbs = { alc662_init_verbs,
18770                                 alc663_21jd_amic_init_verbs},
18771                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18772                 .hp_nid = 0x03,
18773                 .dac_nids = alc662_dac_nids,
18774                 .dig_out_nid = ALC662_DIGOUT_NID,
18775                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18776                 .channel_mode = alc662_3ST_2ch_modes,
18777                 .unsol_event = alc663_mode4_unsol_event,
18778                 .setup = alc663_mode4_setup,
18779                 .init_hook = alc663_mode4_inithook,
18780         },
18781         [ALC663_ASUS_MODE5] = {
18782                 .mixers = { alc663_asus_15jd_clfe_mixer },
18783                 .cap_mixer = alc662_auto_capture_mixer,
18784                 .init_verbs = { alc662_init_verbs,
18785                                 alc663_15jd_amic_init_verbs },
18786                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18787                 .hp_nid = 0x03,
18788                 .dac_nids = alc662_dac_nids,
18789                 .dig_out_nid = ALC662_DIGOUT_NID,
18790                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18791                 .channel_mode = alc662_3ST_2ch_modes,
18792                 .unsol_event = alc663_mode5_unsol_event,
18793                 .setup = alc663_mode5_setup,
18794                 .init_hook = alc663_mode5_inithook,
18795         },
18796         [ALC663_ASUS_MODE6] = {
18797                 .mixers = { alc663_two_hp_m2_mixer },
18798                 .cap_mixer = alc662_auto_capture_mixer,
18799                 .init_verbs = { alc662_init_verbs,
18800                                 alc663_two_hp_amic_m2_init_verbs },
18801                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18802                 .hp_nid = 0x03,
18803                 .dac_nids = alc662_dac_nids,
18804                 .dig_out_nid = ALC662_DIGOUT_NID,
18805                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18806                 .channel_mode = alc662_3ST_2ch_modes,
18807                 .unsol_event = alc663_mode6_unsol_event,
18808                 .setup = alc663_mode6_setup,
18809                 .init_hook = alc663_mode6_inithook,
18810         },
18811         [ALC663_ASUS_MODE7] = {
18812                 .mixers = { alc663_mode7_mixer },
18813                 .cap_mixer = alc662_auto_capture_mixer,
18814                 .init_verbs = { alc662_init_verbs,
18815                                 alc663_mode7_init_verbs },
18816                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18817                 .hp_nid = 0x03,
18818                 .dac_nids = alc662_dac_nids,
18819                 .dig_out_nid = ALC662_DIGOUT_NID,
18820                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18821                 .channel_mode = alc662_3ST_2ch_modes,
18822                 .unsol_event = alc663_mode7_unsol_event,
18823                 .setup = alc663_mode7_setup,
18824                 .init_hook = alc663_mode7_inithook,
18825         },
18826         [ALC663_ASUS_MODE8] = {
18827                 .mixers = { alc663_mode8_mixer },
18828                 .cap_mixer = alc662_auto_capture_mixer,
18829                 .init_verbs = { alc662_init_verbs,
18830                                 alc663_mode8_init_verbs },
18831                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18832                 .hp_nid = 0x03,
18833                 .dac_nids = alc662_dac_nids,
18834                 .dig_out_nid = ALC662_DIGOUT_NID,
18835                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18836                 .channel_mode = alc662_3ST_2ch_modes,
18837                 .unsol_event = alc663_mode8_unsol_event,
18838                 .setup = alc663_mode8_setup,
18839                 .init_hook = alc663_mode8_inithook,
18840         },
18841         [ALC272_DELL] = {
18842                 .mixers = { alc663_m51va_mixer },
18843                 .cap_mixer = alc272_auto_capture_mixer,
18844                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18845                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18846                 .dac_nids = alc662_dac_nids,
18847                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18848                 .adc_nids = alc272_adc_nids,
18849                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18850                 .capsrc_nids = alc272_capsrc_nids,
18851                 .channel_mode = alc662_3ST_2ch_modes,
18852                 .unsol_event = alc663_m51va_unsol_event,
18853                 .setup = alc663_m51va_setup,
18854                 .init_hook = alc663_m51va_inithook,
18855         },
18856         [ALC272_DELL_ZM1] = {
18857                 .mixers = { alc663_m51va_mixer },
18858                 .cap_mixer = alc662_auto_capture_mixer,
18859                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18860                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18861                 .dac_nids = alc662_dac_nids,
18862                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18863                 .adc_nids = alc662_adc_nids,
18864                 .num_adc_nids = 1,
18865                 .capsrc_nids = alc662_capsrc_nids,
18866                 .channel_mode = alc662_3ST_2ch_modes,
18867                 .unsol_event = alc663_m51va_unsol_event,
18868                 .setup = alc663_m51va_setup,
18869                 .init_hook = alc663_m51va_inithook,
18870         },
18871         [ALC272_SAMSUNG_NC10] = {
18872                 .mixers = { alc272_nc10_mixer },
18873                 .init_verbs = { alc662_init_verbs,
18874                                 alc663_21jd_amic_init_verbs },
18875                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18876                 .dac_nids = alc272_dac_nids,
18877                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18878                 .channel_mode = alc662_3ST_2ch_modes,
18879                 /*.input_mux = &alc272_nc10_capture_source,*/
18880                 .unsol_event = alc663_mode4_unsol_event,
18881                 .setup = alc663_mode4_setup,
18882                 .init_hook = alc663_mode4_inithook,
18883         },
18884 };
18885
18886
18887 /*
18888  * BIOS auto configuration
18889  */
18890
18891 /* convert from MIX nid to DAC */
18892 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18893 {
18894         if (nid == 0x0f)
18895                 return 0x02;
18896         else if (nid >= 0x0c && nid <= 0x0e)
18897                 return nid - 0x0c + 0x02;
18898         else
18899                 return 0;
18900 }
18901
18902 /* get MIX nid connected to the given pin targeted to DAC */
18903 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18904                                    hda_nid_t dac)
18905 {
18906         hda_nid_t mix[4];
18907         int i, num;
18908
18909         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18910         for (i = 0; i < num; i++) {
18911                 if (alc662_mix_to_dac(mix[i]) == dac)
18912                         return mix[i];
18913         }
18914         return 0;
18915 }
18916
18917 /* look for an empty DAC slot */
18918 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18919 {
18920         struct alc_spec *spec = codec->spec;
18921         hda_nid_t srcs[5];
18922         int i, j, num;
18923
18924         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18925         if (num < 0)
18926                 return 0;
18927         for (i = 0; i < num; i++) {
18928                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18929                 if (!nid)
18930                         continue;
18931                 for (j = 0; j < spec->multiout.num_dacs; j++)
18932                         if (spec->multiout.dac_nids[j] == nid)
18933                                 break;
18934                 if (j >= spec->multiout.num_dacs)
18935                         return nid;
18936         }
18937         return 0;
18938 }
18939
18940 /* fill in the dac_nids table from the parsed pin configuration */
18941 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18942                                      const struct auto_pin_cfg *cfg)
18943 {
18944         struct alc_spec *spec = codec->spec;
18945         int i;
18946         hda_nid_t dac;
18947
18948         spec->multiout.dac_nids = spec->private_dac_nids;
18949         for (i = 0; i < cfg->line_outs; i++) {
18950                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18951                 if (!dac)
18952                         continue;
18953                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18954         }
18955         return 0;
18956 }
18957
18958 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18959                               hda_nid_t nid, unsigned int chs)
18960 {
18961         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18962                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18963 }
18964
18965 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18966                              hda_nid_t nid, unsigned int chs)
18967 {
18968         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18969                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18970 }
18971
18972 #define alc662_add_stereo_vol(spec, pfx, nid) \
18973         alc662_add_vol_ctl(spec, pfx, nid, 3)
18974 #define alc662_add_stereo_sw(spec, pfx, nid) \
18975         alc662_add_sw_ctl(spec, pfx, nid, 3)
18976
18977 /* add playback controls from the parsed DAC table */
18978 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18979                                              const struct auto_pin_cfg *cfg)
18980 {
18981         struct alc_spec *spec = codec->spec;
18982         static const char *chname[4] = {
18983                 "Front", "Surround", NULL /*CLFE*/, "Side"
18984         };
18985         hda_nid_t nid, mix;
18986         int i, err;
18987
18988         for (i = 0; i < cfg->line_outs; i++) {
18989                 nid = spec->multiout.dac_nids[i];
18990                 if (!nid)
18991                         continue;
18992                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18993                 if (!mix)
18994                         continue;
18995                 if (i == 2) {
18996                         /* Center/LFE */
18997                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18998                         if (err < 0)
18999                                 return err;
19000                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19001                         if (err < 0)
19002                                 return err;
19003                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19004                         if (err < 0)
19005                                 return err;
19006                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19007                         if (err < 0)
19008                                 return err;
19009                 } else {
19010                         const char *pfx;
19011                         if (cfg->line_outs == 1 &&
19012                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
19013                                 if (cfg->hp_outs)
19014                                         pfx = "Speaker";
19015                                 else
19016                                         pfx = "PCM";
19017                         } else
19018                                 pfx = chname[i];
19019                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19020                         if (err < 0)
19021                                 return err;
19022                         if (cfg->line_outs == 1 &&
19023                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19024                                 pfx = "Speaker";
19025                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19026                         if (err < 0)
19027                                 return err;
19028                 }
19029         }
19030         return 0;
19031 }
19032
19033 /* add playback controls for speaker and HP outputs */
19034 /* return DAC nid if any new DAC is assigned */
19035 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19036                                         const char *pfx)
19037 {
19038         struct alc_spec *spec = codec->spec;
19039         hda_nid_t nid, mix;
19040         int err;
19041
19042         if (!pin)
19043                 return 0;
19044         nid = alc662_look_for_dac(codec, pin);
19045         if (!nid) {
19046                 /* the corresponding DAC is already occupied */
19047                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19048                         return 0; /* no way */
19049                 /* create a switch only */
19050                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19051                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19052         }
19053
19054         mix = alc662_dac_to_mix(codec, pin, nid);
19055         if (!mix)
19056                 return 0;
19057         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19058         if (err < 0)
19059                 return err;
19060         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19061         if (err < 0)
19062                 return err;
19063         return nid;
19064 }
19065
19066 /* create playback/capture controls for input pins */
19067 #define alc662_auto_create_input_ctls \
19068         alc882_auto_create_input_ctls
19069
19070 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19071                                               hda_nid_t nid, int pin_type,
19072                                               hda_nid_t dac)
19073 {
19074         int i, num;
19075         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19076
19077         alc_set_pin_output(codec, nid, pin_type);
19078         /* need the manual connection? */
19079         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19080         if (num <= 1)
19081                 return;
19082         for (i = 0; i < num; i++) {
19083                 if (alc662_mix_to_dac(srcs[i]) != dac)
19084                         continue;
19085                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19086                 return;
19087         }
19088 }
19089
19090 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19091 {
19092         struct alc_spec *spec = codec->spec;
19093         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19094         int i;
19095
19096         for (i = 0; i <= HDA_SIDE; i++) {
19097                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19098                 if (nid)
19099                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19100                                         spec->multiout.dac_nids[i]);
19101         }
19102 }
19103
19104 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19105 {
19106         struct alc_spec *spec = codec->spec;
19107         hda_nid_t pin;
19108
19109         pin = spec->autocfg.hp_pins[0];
19110         if (pin)
19111                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19112                                                   spec->multiout.hp_nid);
19113         pin = spec->autocfg.speaker_pins[0];
19114         if (pin)
19115                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19116                                         spec->multiout.extra_out_nid[0]);
19117 }
19118
19119 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19120
19121 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19122 {
19123         struct alc_spec *spec = codec->spec;
19124         struct auto_pin_cfg *cfg = &spec->autocfg;
19125         int i;
19126
19127         for (i = 0; i < cfg->num_inputs; i++) {
19128                 hda_nid_t nid = cfg->inputs[i].pin;
19129                 if (alc_is_input_pin(codec, nid)) {
19130                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19131                         if (nid != ALC662_PIN_CD_NID &&
19132                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19133                                 snd_hda_codec_write(codec, nid, 0,
19134                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19135                                                     AMP_OUT_MUTE);
19136                 }
19137         }
19138 }
19139
19140 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19141
19142 static int alc662_parse_auto_config(struct hda_codec *codec)
19143 {
19144         struct alc_spec *spec = codec->spec;
19145         int err;
19146         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19147
19148         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19149                                            alc662_ignore);
19150         if (err < 0)
19151                 return err;
19152         if (!spec->autocfg.line_outs)
19153                 return 0; /* can't find valid BIOS pin config */
19154
19155         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19156         if (err < 0)
19157                 return err;
19158         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19159         if (err < 0)
19160                 return err;
19161         err = alc662_auto_create_extra_out(codec,
19162                                            spec->autocfg.speaker_pins[0],
19163                                            "Speaker");
19164         if (err < 0)
19165                 return err;
19166         if (err)
19167                 spec->multiout.extra_out_nid[0] = err;
19168         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19169                                            "Headphone");
19170         if (err < 0)
19171                 return err;
19172         if (err)
19173                 spec->multiout.hp_nid = err;
19174         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19175         if (err < 0)
19176                 return err;
19177
19178         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19179
19180         alc_auto_parse_digital(codec);
19181
19182         if (spec->kctls.list)
19183                 add_mixer(spec, spec->kctls.list);
19184
19185         spec->num_mux_defs = 1;
19186         spec->input_mux = &spec->private_imux[0];
19187
19188         add_verb(spec, alc662_init_verbs);
19189         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19190             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19191                 add_verb(spec, alc663_init_verbs);
19192
19193         if (codec->vendor_id == 0x10ec0272)
19194                 add_verb(spec, alc272_init_verbs);
19195
19196         err = alc_auto_add_mic_boost(codec);
19197         if (err < 0)
19198                 return err;
19199
19200         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19201             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19202             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19203         else
19204             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19205
19206         return 1;
19207 }
19208
19209 /* additional initialization for auto-configuration model */
19210 static void alc662_auto_init(struct hda_codec *codec)
19211 {
19212         struct alc_spec *spec = codec->spec;
19213         alc662_auto_init_multi_out(codec);
19214         alc662_auto_init_hp_out(codec);
19215         alc662_auto_init_analog_input(codec);
19216         alc662_auto_init_input_src(codec);
19217         alc_auto_init_digital(codec);
19218         if (spec->unsol_event)
19219                 alc_inithook(codec);
19220 }
19221
19222 enum {
19223         ALC662_FIXUP_IDEAPAD,
19224 };
19225
19226 static const struct alc_fixup alc662_fixups[] = {
19227         [ALC662_FIXUP_IDEAPAD] = {
19228                 .pins = (const struct alc_pincfg[]) {
19229                         { 0x17, 0x99130112 }, /* subwoofer */
19230                         { }
19231                 }
19232         },
19233 };
19234
19235 static struct snd_pci_quirk alc662_fixup_tbl[] = {
19236         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19237         {}
19238 };
19239
19240
19241
19242 static int patch_alc662(struct hda_codec *codec)
19243 {
19244         struct alc_spec *spec;
19245         int err, board_config;
19246
19247         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19248         if (!spec)
19249                 return -ENOMEM;
19250
19251         codec->spec = spec;
19252
19253         alc_auto_parse_customize_define(codec);
19254
19255         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19256
19257         if (alc_read_coef_idx(codec, 0) == 0x8020)
19258                 alc_codec_rename(codec, "ALC661");
19259         else if ((alc_read_coef_idx(codec, 0) & (1 << 14)) &&
19260                  codec->bus->pci->subsystem_vendor == 0x1025 &&
19261                  spec->cdefine.platform_type == 1)
19262                 alc_codec_rename(codec, "ALC272X");
19263
19264         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19265                                                   alc662_models,
19266                                                   alc662_cfg_tbl);
19267         if (board_config < 0) {
19268                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19269                        codec->chip_name);
19270                 board_config = ALC662_AUTO;
19271         }
19272
19273         if (board_config == ALC662_AUTO) {
19274                 alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1);
19275                 /* automatic parse from the BIOS config */
19276                 err = alc662_parse_auto_config(codec);
19277                 if (err < 0) {
19278                         alc_free(codec);
19279                         return err;
19280                 } else if (!err) {
19281                         printk(KERN_INFO
19282                                "hda_codec: Cannot set up configuration "
19283                                "from BIOS.  Using base mode...\n");
19284                         board_config = ALC662_3ST_2ch_DIG;
19285                 }
19286         }
19287
19288         if (has_cdefine_beep(codec)) {
19289                 err = snd_hda_attach_beep_device(codec, 0x1);
19290                 if (err < 0) {
19291                         alc_free(codec);
19292                         return err;
19293                 }
19294         }
19295
19296         if (board_config != ALC662_AUTO)
19297                 setup_preset(codec, &alc662_presets[board_config]);
19298
19299         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19300         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19301
19302         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19303         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19304
19305         if (!spec->adc_nids) {
19306                 spec->adc_nids = alc662_adc_nids;
19307                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19308         }
19309         if (!spec->capsrc_nids)
19310                 spec->capsrc_nids = alc662_capsrc_nids;
19311
19312         if (!spec->cap_mixer)
19313                 set_capture_mixer(codec);
19314
19315         if (has_cdefine_beep(codec)) {
19316                 switch (codec->vendor_id) {
19317                 case 0x10ec0662:
19318                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19319                         break;
19320                 case 0x10ec0272:
19321                 case 0x10ec0663:
19322                 case 0x10ec0665:
19323                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19324                         break;
19325                 case 0x10ec0273:
19326                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19327                         break;
19328                 }
19329         }
19330         spec->vmaster_nid = 0x02;
19331
19332         codec->patch_ops = alc_patch_ops;
19333         if (board_config == ALC662_AUTO) {
19334                 spec->init_hook = alc662_auto_init;
19335                 alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 0);
19336         }
19337
19338 #ifdef CONFIG_SND_HDA_POWER_SAVE
19339         if (!spec->loopback.amplist)
19340                 spec->loopback.amplist = alc662_loopbacks;
19341 #endif
19342
19343         return 0;
19344 }
19345
19346 static int patch_alc888(struct hda_codec *codec)
19347 {
19348         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19349                 kfree(codec->chip_name);
19350                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19351                 if (!codec->chip_name) {
19352                         alc_free(codec);
19353                         return -ENOMEM;
19354                 }
19355                 return patch_alc662(codec);
19356         }
19357         return patch_alc882(codec);
19358 }
19359
19360 /*
19361  * ALC680 support
19362  */
19363 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19364 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19365 #define alc680_modes            alc260_modes
19366
19367 static hda_nid_t alc680_dac_nids[3] = {
19368         /* Lout1, Lout2, hp */
19369         0x02, 0x03, 0x04
19370 };
19371
19372 static hda_nid_t alc680_adc_nids[3] = {
19373         /* ADC0-2 */
19374         /* DMIC, MIC, Line-in*/
19375         0x07, 0x08, 0x09
19376 };
19377
19378 /*
19379  * Analog capture ADC cgange
19380  */
19381 static void alc680_rec_autoswitch(struct hda_codec *codec)
19382 {
19383         struct alc_spec *spec = codec->spec;
19384         struct auto_pin_cfg *cfg = &spec->autocfg;
19385         int pin_found = 0;
19386         int type_found = AUTO_PIN_LAST;
19387         hda_nid_t nid;
19388         int i;
19389
19390         for (i = 0; i < cfg->num_inputs; i++) {
19391                 nid = cfg->inputs[i].pin;
19392                 if (!(snd_hda_query_pin_caps(codec, nid) &
19393                       AC_PINCAP_PRES_DETECT))
19394                         continue;
19395                 if (snd_hda_jack_detect(codec, nid)) {
19396                         if (cfg->inputs[i].type < type_found) {
19397                                 type_found = cfg->inputs[i].type;
19398                                 pin_found = nid;
19399                         }
19400                 }
19401         }
19402
19403         nid = 0x07;
19404         if (pin_found)
19405                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19406
19407         if (nid != spec->cur_adc)
19408                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19409         spec->cur_adc = nid;
19410         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19411                                    spec->cur_adc_format);
19412 }
19413
19414 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19415                                       struct hda_codec *codec,
19416                                       unsigned int stream_tag,
19417                                       unsigned int format,
19418                                       struct snd_pcm_substream *substream)
19419 {
19420         struct alc_spec *spec = codec->spec;
19421
19422         spec->cur_adc = 0x07;
19423         spec->cur_adc_stream_tag = stream_tag;
19424         spec->cur_adc_format = format;
19425
19426         alc680_rec_autoswitch(codec);
19427         return 0;
19428 }
19429
19430 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19431                                       struct hda_codec *codec,
19432                                       struct snd_pcm_substream *substream)
19433 {
19434         snd_hda_codec_cleanup_stream(codec, 0x07);
19435         snd_hda_codec_cleanup_stream(codec, 0x08);
19436         snd_hda_codec_cleanup_stream(codec, 0x09);
19437         return 0;
19438 }
19439
19440 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19441         .substreams = 1, /* can be overridden */
19442         .channels_min = 2,
19443         .channels_max = 2,
19444         /* NID is set in alc_build_pcms */
19445         .ops = {
19446                 .prepare = alc680_capture_pcm_prepare,
19447                 .cleanup = alc680_capture_pcm_cleanup
19448         },
19449 };
19450
19451 static struct snd_kcontrol_new alc680_base_mixer[] = {
19452         /* output mixer control */
19453         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19454         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19455         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19456         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19457         HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
19458         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
19459         HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
19460         { }
19461 };
19462
19463 static struct hda_bind_ctls alc680_bind_cap_vol = {
19464         .ops = &snd_hda_bind_vol,
19465         .values = {
19466                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19467                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19468                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19469                 0
19470         },
19471 };
19472
19473 static struct hda_bind_ctls alc680_bind_cap_switch = {
19474         .ops = &snd_hda_bind_sw,
19475         .values = {
19476                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19477                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19478                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19479                 0
19480         },
19481 };
19482
19483 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19484         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19485         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19486         { } /* end */
19487 };
19488
19489 /*
19490  * generic initialization of ADC, input mixers and output mixers
19491  */
19492 static struct hda_verb alc680_init_verbs[] = {
19493         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19494         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19495         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19496
19497         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19498         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19499         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19500         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19501         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19502         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19503
19504         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19505         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19506         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19507         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19508         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19509
19510         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19511         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19512         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19513
19514         { }
19515 };
19516
19517 /* toggle speaker-output according to the hp-jack state */
19518 static void alc680_base_setup(struct hda_codec *codec)
19519 {
19520         struct alc_spec *spec = codec->spec;
19521
19522         spec->autocfg.hp_pins[0] = 0x16;
19523         spec->autocfg.speaker_pins[0] = 0x14;
19524         spec->autocfg.speaker_pins[1] = 0x15;
19525         spec->autocfg.num_inputs = 2;
19526         spec->autocfg.inputs[0].pin = 0x18;
19527         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19528         spec->autocfg.inputs[1].pin = 0x19;
19529         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19530 }
19531
19532 static void alc680_unsol_event(struct hda_codec *codec,
19533                                            unsigned int res)
19534 {
19535         if ((res >> 26) == ALC880_HP_EVENT)
19536                 alc_automute_amp(codec);
19537         if ((res >> 26) == ALC880_MIC_EVENT)
19538                 alc680_rec_autoswitch(codec);
19539 }
19540
19541 static void alc680_inithook(struct hda_codec *codec)
19542 {
19543         alc_automute_amp(codec);
19544         alc680_rec_autoswitch(codec);
19545 }
19546
19547 /* create input playback/capture controls for the given pin */
19548 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19549                                     const char *ctlname, int idx)
19550 {
19551         hda_nid_t dac;
19552         int err;
19553
19554         switch (nid) {
19555         case 0x14:
19556                 dac = 0x02;
19557                 break;
19558         case 0x15:
19559                 dac = 0x03;
19560                 break;
19561         case 0x16:
19562                 dac = 0x04;
19563                 break;
19564         default:
19565                 return 0;
19566         }
19567         if (spec->multiout.dac_nids[0] != dac &&
19568             spec->multiout.dac_nids[1] != dac) {
19569                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19570                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19571                                                       HDA_OUTPUT));
19572                 if (err < 0)
19573                         return err;
19574
19575                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19576                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19577
19578                 if (err < 0)
19579                         return err;
19580                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19581         }
19582
19583         return 0;
19584 }
19585
19586 /* add playback controls from the parsed DAC table */
19587 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19588                                              const struct auto_pin_cfg *cfg)
19589 {
19590         hda_nid_t nid;
19591         int err;
19592
19593         spec->multiout.dac_nids = spec->private_dac_nids;
19594
19595         nid = cfg->line_out_pins[0];
19596         if (nid) {
19597                 const char *name;
19598                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19599                         name = "Speaker";
19600                 else
19601                         name = "Front";
19602                 err = alc680_new_analog_output(spec, nid, name, 0);
19603                 if (err < 0)
19604                         return err;
19605         }
19606
19607         nid = cfg->speaker_pins[0];
19608         if (nid) {
19609                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19610                 if (err < 0)
19611                         return err;
19612         }
19613         nid = cfg->hp_pins[0];
19614         if (nid) {
19615                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19616                 if (err < 0)
19617                         return err;
19618         }
19619
19620         return 0;
19621 }
19622
19623 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19624                                               hda_nid_t nid, int pin_type)
19625 {
19626         alc_set_pin_output(codec, nid, pin_type);
19627 }
19628
19629 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19630 {
19631         struct alc_spec *spec = codec->spec;
19632         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19633         if (nid) {
19634                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19635                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19636         }
19637 }
19638
19639 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19640 {
19641         struct alc_spec *spec = codec->spec;
19642         hda_nid_t pin;
19643
19644         pin = spec->autocfg.hp_pins[0];
19645         if (pin)
19646                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19647         pin = spec->autocfg.speaker_pins[0];
19648         if (pin)
19649                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19650 }
19651
19652 /* pcm configuration: identical with ALC880 */
19653 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19654 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19655 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19656 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19657 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19658
19659 /*
19660  * BIOS auto configuration
19661  */
19662 static int alc680_parse_auto_config(struct hda_codec *codec)
19663 {
19664         struct alc_spec *spec = codec->spec;
19665         int err;
19666         static hda_nid_t alc680_ignore[] = { 0 };
19667
19668         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19669                                            alc680_ignore);
19670         if (err < 0)
19671                 return err;
19672
19673         if (!spec->autocfg.line_outs) {
19674                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19675                         spec->multiout.max_channels = 2;
19676                         spec->no_analog = 1;
19677                         goto dig_only;
19678                 }
19679                 return 0; /* can't find valid BIOS pin config */
19680         }
19681         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19682         if (err < 0)
19683                 return err;
19684
19685         spec->multiout.max_channels = 2;
19686
19687  dig_only:
19688         /* digital only support output */
19689         alc_auto_parse_digital(codec);
19690         if (spec->kctls.list)
19691                 add_mixer(spec, spec->kctls.list);
19692
19693         add_verb(spec, alc680_init_verbs);
19694
19695         err = alc_auto_add_mic_boost(codec);
19696         if (err < 0)
19697                 return err;
19698
19699         return 1;
19700 }
19701
19702 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19703
19704 /* init callback for auto-configuration model -- overriding the default init */
19705 static void alc680_auto_init(struct hda_codec *codec)
19706 {
19707         struct alc_spec *spec = codec->spec;
19708         alc680_auto_init_multi_out(codec);
19709         alc680_auto_init_hp_out(codec);
19710         alc680_auto_init_analog_input(codec);
19711         alc_auto_init_digital(codec);
19712         if (spec->unsol_event)
19713                 alc_inithook(codec);
19714 }
19715
19716 /*
19717  * configuration and preset
19718  */
19719 static const char *alc680_models[ALC680_MODEL_LAST] = {
19720         [ALC680_BASE]           = "base",
19721         [ALC680_AUTO]           = "auto",
19722 };
19723
19724 static struct snd_pci_quirk alc680_cfg_tbl[] = {
19725         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19726         {}
19727 };
19728
19729 static struct alc_config_preset alc680_presets[] = {
19730         [ALC680_BASE] = {
19731                 .mixers = { alc680_base_mixer },
19732                 .cap_mixer =  alc680_master_capture_mixer,
19733                 .init_verbs = { alc680_init_verbs },
19734                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
19735                 .dac_nids = alc680_dac_nids,
19736                 .dig_out_nid = ALC680_DIGOUT_NID,
19737                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
19738                 .channel_mode = alc680_modes,
19739                 .unsol_event = alc680_unsol_event,
19740                 .setup = alc680_base_setup,
19741                 .init_hook = alc680_inithook,
19742
19743         },
19744 };
19745
19746 static int patch_alc680(struct hda_codec *codec)
19747 {
19748         struct alc_spec *spec;
19749         int board_config;
19750         int err;
19751
19752         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19753         if (spec == NULL)
19754                 return -ENOMEM;
19755
19756         codec->spec = spec;
19757
19758         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19759                                                   alc680_models,
19760                                                   alc680_cfg_tbl);
19761
19762         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19763                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19764                        codec->chip_name);
19765                 board_config = ALC680_AUTO;
19766         }
19767
19768         if (board_config == ALC680_AUTO) {
19769                 /* automatic parse from the BIOS config */
19770                 err = alc680_parse_auto_config(codec);
19771                 if (err < 0) {
19772                         alc_free(codec);
19773                         return err;
19774                 } else if (!err) {
19775                         printk(KERN_INFO
19776                                "hda_codec: Cannot set up configuration "
19777                                "from BIOS.  Using base mode...\n");
19778                         board_config = ALC680_BASE;
19779                 }
19780         }
19781
19782         if (board_config != ALC680_AUTO)
19783                 setup_preset(codec, &alc680_presets[board_config]);
19784
19785         spec->stream_analog_playback = &alc680_pcm_analog_playback;
19786         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19787         spec->stream_digital_playback = &alc680_pcm_digital_playback;
19788         spec->stream_digital_capture = &alc680_pcm_digital_capture;
19789
19790         if (!spec->adc_nids) {
19791                 spec->adc_nids = alc680_adc_nids;
19792                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19793         }
19794
19795         if (!spec->cap_mixer)
19796                 set_capture_mixer(codec);
19797
19798         spec->vmaster_nid = 0x02;
19799
19800         codec->patch_ops = alc_patch_ops;
19801         if (board_config == ALC680_AUTO)
19802                 spec->init_hook = alc680_auto_init;
19803
19804         return 0;
19805 }
19806
19807 /*
19808  * patch entries
19809  */
19810 static struct hda_codec_preset snd_hda_preset_realtek[] = {
19811         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
19812         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
19813         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
19814         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
19815         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
19816         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
19817         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
19818         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
19819         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
19820           .patch = patch_alc861 },
19821         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
19822         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
19823         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
19824         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
19825           .patch = patch_alc882 },
19826         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
19827           .patch = patch_alc662 },
19828         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
19829         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
19830         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
19831         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
19832         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
19833         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
19834         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
19835         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
19836           .patch = patch_alc882 },
19837         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
19838           .patch = patch_alc882 },
19839         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
19840         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
19841         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
19842           .patch = patch_alc882 },
19843         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
19844         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
19845         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
19846         {} /* terminator */
19847 };
19848
19849 MODULE_ALIAS("snd-hda-codec-id:10ec*");
19850
19851 MODULE_LICENSE("GPL");
19852 MODULE_DESCRIPTION("Realtek HD-audio codec");
19853
19854 static struct hda_codec_preset_list realtek_list = {
19855         .preset = snd_hda_preset_realtek,
19856         .owner = THIS_MODULE,
19857 };
19858
19859 static int __init patch_realtek_init(void)
19860 {
19861         return snd_hda_add_codec_preset(&realtek_list);
19862 }
19863
19864 static void __exit patch_realtek_exit(void)
19865 {
19866         snd_hda_delete_codec_preset(&realtek_list);
19867 }
19868
19869 module_init(patch_realtek_init)
19870 module_exit(patch_realtek_exit)