sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include <sound/jack.h>
  32 #include "hda_codec.h"
  33 #include "hda_local.h"
  34 #include "hda_beep.h"
  35
  36 #define ALC880_FRONT_EVENT              0x01
  37 #define ALC880_DCVOL_EVENT              0x02
  38 #define ALC880_HP_EVENT                 0x04
  39 #define ALC880_MIC_EVENT                0x08
  40
  41 /* ALC880 board config type */
  42 enum {
  43         ALC880_3ST,
  44         ALC880_3ST_DIG,
  45         ALC880_5ST,
  46         ALC880_5ST_DIG,
  47         ALC880_W810,
  48         ALC880_Z71V,
  49         ALC880_6ST,
  50         ALC880_6ST_DIG,
  51         ALC880_F1734,
  52         ALC880_ASUS,
  53         ALC880_ASUS_DIG,
  54         ALC880_ASUS_W1V,
  55         ALC880_ASUS_DIG2,
  56         ALC880_FUJITSU,
  57         ALC880_UNIWILL_DIG,
  58         ALC880_UNIWILL,
  59         ALC880_UNIWILL_P53,
  60         ALC880_CLEVO,
  61         ALC880_TCL_S700,
  62         ALC880_LG,
  63         ALC880_LG_LW,
  64         ALC880_MEDION_RIM,
  65 #ifdef CONFIG_SND_DEBUG
  66         ALC880_TEST,
  67 #endif
  68         ALC880_AUTO,
  69         ALC880_MODEL_LAST /* last tag */
  70 };
  71
  72 /* ALC260 models */
  73 enum {
  74         ALC260_BASIC,
  75         ALC260_HP,
  76         ALC260_HP_DC7600,
  77         ALC260_HP_3013,
  78         ALC260_FUJITSU_S702X,
  79         ALC260_ACER,
  80         ALC260_WILL,
  81         ALC260_REPLACER_672V,
  82         ALC260_FAVORIT100,
  83 #ifdef CONFIG_SND_DEBUG
  84         ALC260_TEST,
  85 #endif
  86         ALC260_AUTO,
  87         ALC260_MODEL_LAST /* last tag */
  88 };
  89
  90 /* ALC262 models */
  91 enum {
  92         ALC262_BASIC,
  93         ALC262_HIPPO,
  94         ALC262_HIPPO_1,
  95         ALC262_FUJITSU,
  96         ALC262_HP_BPC,
  97         ALC262_HP_BPC_D7000_WL,
  98         ALC262_HP_BPC_D7000_WF,
  99         ALC262_HP_TC_T5735,
 100         ALC262_HP_RP5700,
 101         ALC262_BENQ_ED8,
 102         ALC262_SONY_ASSAMD,
 103         ALC262_BENQ_T31,
 104         ALC262_ULTRA,
 105         ALC262_LENOVO_3000,
 106         ALC262_NEC,
 107         ALC262_TOSHIBA_S06,
 108         ALC262_TOSHIBA_RX1,
 109         ALC262_TYAN,
 110         ALC262_AUTO,
 111         ALC262_MODEL_LAST /* last tag */
 112 };
 113
 114 /* ALC268 models */
 115 enum {
 116         ALC267_QUANTA_IL1,
 117         ALC268_3ST,
 118         ALC268_TOSHIBA,
 119         ALC268_ACER,
 120         ALC268_ACER_DMIC,
 121         ALC268_ACER_ASPIRE_ONE,
 122         ALC268_DELL,
 123         ALC268_ZEPTO,
 124 #ifdef CONFIG_SND_DEBUG
 125         ALC268_TEST,
 126 #endif
 127         ALC268_AUTO,
 128         ALC268_MODEL_LAST /* last tag */
 129 };
 130
 131 /* ALC269 models */
 132 enum {
 133         ALC269_BASIC,
 134         ALC269_QUANTA_FL1,
 135         ALC269_AMIC,
 136         ALC269_DMIC,
 137         ALC269VB_AMIC,
 138         ALC269VB_DMIC,
 139         ALC269_FUJITSU,
 140         ALC269_LIFEBOOK,
 141         ALC271_ACER,
 142         ALC269_AUTO,
 143         ALC269_MODEL_LAST /* last tag */
 144 };
 145
 146 /* ALC861 models */
 147 enum {
 148         ALC861_3ST,
 149         ALC660_3ST,
 150         ALC861_3ST_DIG,
 151         ALC861_6ST_DIG,
 152         ALC861_UNIWILL_M31,
 153         ALC861_TOSHIBA,
 154         ALC861_ASUS,
 155         ALC861_ASUS_LAPTOP,
 156         ALC861_AUTO,
 157         ALC861_MODEL_LAST,
 158 };
 159
 160 /* ALC861-VD models */
 161 enum {
 162         ALC660VD_3ST,
 163         ALC660VD_3ST_DIG,
 164         ALC660VD_ASUS_V1S,
 165         ALC861VD_3ST,
 166         ALC861VD_3ST_DIG,
 167         ALC861VD_6ST_DIG,
 168         ALC861VD_LENOVO,
 169         ALC861VD_DALLAS,
 170         ALC861VD_HP,
 171         ALC861VD_AUTO,
 172         ALC861VD_MODEL_LAST,
 173 };
 174
 175 /* ALC662 models */
 176 enum {
 177         ALC662_3ST_2ch_DIG,
 178         ALC662_3ST_6ch_DIG,
 179         ALC662_3ST_6ch,
 180         ALC662_5ST_DIG,
 181         ALC662_LENOVO_101E,
 182         ALC662_ASUS_EEEPC_P701,
 183         ALC662_ASUS_EEEPC_EP20,
 184         ALC663_ASUS_M51VA,
 185         ALC663_ASUS_G71V,
 186         ALC663_ASUS_H13,
 187         ALC663_ASUS_G50V,
 188         ALC662_ECS,
 189         ALC663_ASUS_MODE1,
 190         ALC662_ASUS_MODE2,
 191         ALC663_ASUS_MODE3,
 192         ALC663_ASUS_MODE4,
 193         ALC663_ASUS_MODE5,
 194         ALC663_ASUS_MODE6,
 195         ALC663_ASUS_MODE7,
 196         ALC663_ASUS_MODE8,
 197         ALC272_DELL,
 198         ALC272_DELL_ZM1,
 199         ALC272_SAMSUNG_NC10,
 200         ALC662_AUTO,
 201         ALC662_MODEL_LAST,
 202 };
 203
 204 /* ALC882 models */
 205 enum {
 206         ALC882_3ST_DIG,
 207         ALC882_6ST_DIG,
 208         ALC882_ARIMA,
 209         ALC882_W2JC,
 210         ALC882_TARGA,
 211         ALC882_ASUS_A7J,
 212         ALC882_ASUS_A7M,
 213         ALC885_MACPRO,
 214         ALC885_MBA21,
 215         ALC885_MBP3,
 216         ALC885_MB5,
 217         ALC885_MACMINI3,
 218         ALC885_IMAC24,
 219         ALC885_IMAC91,
 220         ALC883_3ST_2ch_DIG,
 221         ALC883_3ST_6ch_DIG,
 222         ALC883_3ST_6ch,
 223         ALC883_6ST_DIG,
 224         ALC883_TARGA_DIG,
 225         ALC883_TARGA_2ch_DIG,
 226         ALC883_TARGA_8ch_DIG,
 227         ALC883_ACER,
 228         ALC883_ACER_ASPIRE,
 229         ALC888_ACER_ASPIRE_4930G,
 230         ALC888_ACER_ASPIRE_6530G,
 231         ALC888_ACER_ASPIRE_8930G,
 232         ALC888_ACER_ASPIRE_7730G,
 233         ALC883_MEDION,
 234         ALC883_MEDION_WIM2160,
 235         ALC883_LAPTOP_EAPD,
 236         ALC883_LENOVO_101E_2ch,
 237         ALC883_LENOVO_NB0763,
 238         ALC888_LENOVO_MS7195_DIG,
 239         ALC888_LENOVO_SKY,
 240         ALC883_HAIER_W66,
 241         ALC888_3ST_HP,
 242         ALC888_6ST_DELL,
 243         ALC883_MITAC,
 244         ALC883_CLEVO_M540R,
 245         ALC883_CLEVO_M720,
 246         ALC883_FUJITSU_PI2515,
 247         ALC888_FUJITSU_XA3530,
 248         ALC883_3ST_6ch_INTEL,
 249         ALC889A_INTEL,
 250         ALC889_INTEL,
 251         ALC888_ASUS_M90V,
 252         ALC888_ASUS_EEE1601,
 253         ALC889A_MB31,
 254         ALC1200_ASUS_P5Q,
 255         ALC883_SONY_VAIO_TT,
 256         ALC882_AUTO,
 257         ALC882_MODEL_LAST,
 258 };
 259
 260 /* ALC680 models */
 261 enum {
 262         ALC680_BASE,
 263         ALC680_AUTO,
 264         ALC680_MODEL_LAST,
 265 };
 266
 267 /* for GPIO Poll */
 268 #define GPIO_MASK       0x03
 269
 270 /* extra amp-initialization sequence types */
 271 enum {
 272         ALC_INIT_NONE,
 273         ALC_INIT_DEFAULT,
 274         ALC_INIT_GPIO1,
 275         ALC_INIT_GPIO2,
 276         ALC_INIT_GPIO3,
 277 };
 278
 279 struct alc_mic_route {
 280         hda_nid_t pin;
 281         unsigned char mux_idx;
 282         unsigned char amix_idx;
 283 };
 284
 285 struct alc_jack {
 286         hda_nid_t nid;
 287         int type;
 288         struct snd_jack *jack;
 289 };
 290
 291 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 292
 293 struct alc_customize_define {
 294         unsigned int  sku_cfg;
 295         unsigned char port_connectivity;
 296         unsigned char check_sum;
 297         unsigned char customization;
 298         unsigned char external_amp;
 299         unsigned int  enable_pcbeep:1;
 300         unsigned int  platform_type:1;
 301         unsigned int  swap:1;
 302         unsigned int  override:1;
 303         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
 304 };
 305
 306 struct alc_spec {
 307         /* codec parameterization */
 308         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 309         unsigned int num_mixers;
 310         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 311         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 312
 313         const struct hda_verb *init_verbs[10];  /* initialization verbs
 314                                                  * don't forget NULL
 315                                                  * termination!
 316                                                  */
 317         unsigned int num_init_verbs;
 318
 319         char stream_name_analog[32];    /* analog PCM stream */
 320         struct hda_pcm_stream *stream_analog_playback;
 321         struct hda_pcm_stream *stream_analog_capture;
 322         struct hda_pcm_stream *stream_analog_alt_playback;
 323         struct hda_pcm_stream *stream_analog_alt_capture;
 324
 325         char stream_name_digital[32];   /* digital PCM stream */
 326         struct hda_pcm_stream *stream_digital_playback;
 327         struct hda_pcm_stream *stream_digital_capture;
 328
 329         /* playback */
 330         struct hda_multi_out multiout;  /* playback set-up
 331                                          * max_channels, dacs must be set
 332                                          * dig_out_nid and hp_nid are optional
 333                                          */
 334         hda_nid_t alt_dac_nid;
 335         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 336         int dig_out_type;
 337
 338         /* capture */
 339         unsigned int num_adc_nids;
 340         hda_nid_t *adc_nids;
 341         hda_nid_t *capsrc_nids;
 342         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 343
 344         /* capture setup for dynamic dual-adc switch */
 345         unsigned int cur_adc_idx;
 346         hda_nid_t cur_adc;
 347         unsigned int cur_adc_stream_tag;
 348         unsigned int cur_adc_format;
 349
 350         /* capture source */
 351         unsigned int num_mux_defs;
 352         const struct hda_input_mux *input_mux;
 353         unsigned int cur_mux[3];
 354         struct alc_mic_route ext_mic;
 355         struct alc_mic_route int_mic;
 356
 357         /* channel model */
 358         const struct hda_channel_mode *channel_mode;
 359         int num_channel_mode;
 360         int need_dac_fix;
 361         int const_channel_count;
 362         int ext_channel_count;
 363
 364         /* PCM information */
 365         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 366
 367         /* jack detection */
 368         struct snd_array jacks;
 369
 370         /* dynamic controls, init_verbs and input_mux */
 371         struct auto_pin_cfg autocfg;
 372         struct alc_customize_define cdefine;
 373         struct snd_array kctls;
 374         struct hda_input_mux private_imux[3];
 375         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 376         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 377         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 378
 379         /* hooks */
 380         void (*init_hook)(struct hda_codec *codec);
 381         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 382 #ifdef CONFIG_SND_HDA_POWER_SAVE
 383         void (*power_hook)(struct hda_codec *codec);
 384 #endif
 385
 386         /* for pin sensing */
 387         unsigned int sense_updated: 1;
 388         unsigned int jack_present: 1;
 389         unsigned int master_sw: 1;
 390         unsigned int auto_mic:1;
 391
 392         /* other flags */
 393         unsigned int no_analog :1; /* digital I/O only */
 394         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 395         int init_amp;
 396         int codec_variant;      /* flag for other variants */
 397
 398         /* for virtual master */
 399         hda_nid_t vmaster_nid;
 400 #ifdef CONFIG_SND_HDA_POWER_SAVE
 401         struct hda_loopback_check loopback;
 402 #endif
 403
 404         /* for PLL fix */
 405         hda_nid_t pll_nid;
 406         unsigned int pll_coef_idx, pll_coef_bit;
 407 };
 408
 409 /*
 410  * configuration template - to be copied to the spec instance
 411  */
 412 struct alc_config_preset {
 413         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 414                                              * with spec
 415                                              */
 416         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 417         const struct hda_verb *init_verbs[5];
 418         unsigned int num_dacs;
 419         hda_nid_t *dac_nids;
 420         hda_nid_t dig_out_nid;          /* optional */
 421         hda_nid_t hp_nid;               /* optional */
 422         hda_nid_t *slave_dig_outs;
 423         unsigned int num_adc_nids;
 424         hda_nid_t *adc_nids;
 425         hda_nid_t *capsrc_nids;
 426         hda_nid_t dig_in_nid;
 427         unsigned int num_channel_mode;
 428         const struct hda_channel_mode *channel_mode;
 429         int need_dac_fix;
 430         int const_channel_count;
 431         unsigned int num_mux_defs;
 432         const struct hda_input_mux *input_mux;
 433         void (*unsol_event)(struct hda_codec *, unsigned int);
 434         void (*setup)(struct hda_codec *);
 435         void (*init_hook)(struct hda_codec *);
 436 #ifdef CONFIG_SND_HDA_POWER_SAVE
 437         struct hda_amp_list *loopbacks;
 438         void (*power_hook)(struct hda_codec *codec);
 439 #endif
 440 };
 441
 442
 443 /*
 444  * input MUX handling
 445  */
 446 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 447                              struct snd_ctl_elem_info *uinfo)
 448 {
 449         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 450         struct alc_spec *spec = codec->spec;
 451         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 452         if (mux_idx >= spec->num_mux_defs)
 453                 mux_idx = 0;
 454         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 455                 mux_idx = 0;
 456         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 457 }
 458
 459 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 460                             struct snd_ctl_elem_value *ucontrol)
 461 {
 462         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 463         struct alc_spec *spec = codec->spec;
 464         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 465
 466         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 467         return 0;
 468 }
 469
 470 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 471                             struct snd_ctl_elem_value *ucontrol)
 472 {
 473         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 474         struct alc_spec *spec = codec->spec;
 475         const struct hda_input_mux *imux;
 476         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 477         unsigned int mux_idx;
 478         hda_nid_t nid = spec->capsrc_nids ?
 479                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 480         unsigned int type;
 481
 482         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 483         imux = &spec->input_mux[mux_idx];
 484         if (!imux->num_items && mux_idx > 0)
 485                 imux = &spec->input_mux[0];
 486
 487         type = get_wcaps_type(get_wcaps(codec, nid));
 488         if (type == AC_WID_AUD_MIX) {
 489                 /* Matrix-mixer style (e.g. ALC882) */
 490                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 491                 unsigned int i, idx;
 492
 493                 idx = ucontrol->value.enumerated.item[0];
 494                 if (idx >= imux->num_items)
 495                         idx = imux->num_items - 1;
 496                 if (*cur_val == idx)
 497                         return 0;
 498                 for (i = 0; i < imux->num_items; i++) {
 499                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 500                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 501                                                  imux->items[i].index,
 502                                                  HDA_AMP_MUTE, v);
 503                 }
 504                 *cur_val = idx;
 505                 return 1;
 506         } else {
 507                 /* MUX style (e.g. ALC880) */
 508                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 509                                              &spec->cur_mux[adc_idx]);
 510         }
 511 }
 512
 513 /*
 514  * channel mode setting
 515  */
 516 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 517                             struct snd_ctl_elem_info *uinfo)
 518 {
 519         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 520         struct alc_spec *spec = codec->spec;
 521         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 522                                     spec->num_channel_mode);
 523 }
 524
 525 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 526                            struct snd_ctl_elem_value *ucontrol)
 527 {
 528         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 529         struct alc_spec *spec = codec->spec;
 530         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 531                                    spec->num_channel_mode,
 532                                    spec->ext_channel_count);
 533 }
 534
 535 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 536                            struct snd_ctl_elem_value *ucontrol)
 537 {
 538         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 539         struct alc_spec *spec = codec->spec;
 540         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 541                                       spec->num_channel_mode,
 542                                       &spec->ext_channel_count);
 543         if (err >= 0 && !spec->const_channel_count) {
 544                 spec->multiout.max_channels = spec->ext_channel_count;
 545                 if (spec->need_dac_fix)
 546                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 547         }
 548         return err;
 549 }
 550
 551 /*
 552  * Control the mode of pin widget settings via the mixer.  "pc" is used
 553  * instead of "%" to avoid consequences of accidently treating the % as
 554  * being part of a format specifier.  Maximum allowed length of a value is
 555  * 63 characters plus NULL terminator.
 556  *
 557  * Note: some retasking pin complexes seem to ignore requests for input
 558  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 559  * are requested.  Therefore order this list so that this behaviour will not
 560  * cause problems when mixer clients move through the enum sequentially.
 561  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 562  * March 2006.
 563  */
 564 static char *alc_pin_mode_names[] = {
 565         "Mic 50pc bias", "Mic 80pc bias",
 566         "Line in", "Line out", "Headphone out",
 567 };
 568 static unsigned char alc_pin_mode_values[] = {
 569         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 570 };
 571 /* The control can present all 5 options, or it can limit the options based
 572  * in the pin being assumed to be exclusively an input or an output pin.  In
 573  * addition, "input" pins may or may not process the mic bias option
 574  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 575  * accept requests for bias as of chip versions up to March 2006) and/or
 576  * wiring in the computer.
 577  */
 578 #define ALC_PIN_DIR_IN              0x00
 579 #define ALC_PIN_DIR_OUT             0x01
 580 #define ALC_PIN_DIR_INOUT           0x02
 581 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 582 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 583
 584 /* Info about the pin modes supported by the different pin direction modes.
 585  * For each direction the minimum and maximum values are given.
 586  */
 587 static signed char alc_pin_mode_dir_info[5][2] = {
 588         { 0, 2 },    /* ALC_PIN_DIR_IN */
 589         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 590         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 591         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 592         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 593 };
 594 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 595 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 596 #define alc_pin_mode_n_items(_dir) \
 597         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 598
 599 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 600                              struct snd_ctl_elem_info *uinfo)
 601 {
 602         unsigned int item_num = uinfo->value.enumerated.item;
 603         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 604
 605         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 606         uinfo->count = 1;
 607         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 608
 609         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 610                 item_num = alc_pin_mode_min(dir);
 611         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 612         return 0;
 613 }
 614
 615 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 616                             struct snd_ctl_elem_value *ucontrol)
 617 {
 618         unsigned int i;
 619         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 620         hda_nid_t nid = kcontrol->private_value & 0xffff;
 621         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 622         long *valp = ucontrol->value.integer.value;
 623         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 624                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 625                                                  0x00);
 626
 627         /* Find enumerated value for current pinctl setting */
 628         i = alc_pin_mode_min(dir);
 629         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 630                 i++;
 631         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 632         return 0;
 633 }
 634
 635 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 636                             struct snd_ctl_elem_value *ucontrol)
 637 {
 638         signed int change;
 639         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 640         hda_nid_t nid = kcontrol->private_value & 0xffff;
 641         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 642         long val = *ucontrol->value.integer.value;
 643         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 644                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 645                                                  0x00);
 646
 647         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 648                 val = alc_pin_mode_min(dir);
 649
 650         change = pinctl != alc_pin_mode_values[val];
 651         if (change) {
 652                 /* Set pin mode to that requested */
 653                 snd_hda_codec_write_cache(codec, nid, 0,
 654                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 655                                           alc_pin_mode_values[val]);
 656
 657                 /* Also enable the retasking pin's input/output as required
 658                  * for the requested pin mode.  Enum values of 2 or less are
 659                  * input modes.
 660                  *
 661                  * Dynamically switching the input/output buffers probably
 662                  * reduces noise slightly (particularly on input) so we'll
 663                  * do it.  However, having both input and output buffers
 664                  * enabled simultaneously doesn't seem to be problematic if
 665                  * this turns out to be necessary in the future.
 666                  */
 667                 if (val <= 2) {
 668                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 669                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 670                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 671                                                  HDA_AMP_MUTE, 0);
 672                 } else {
 673                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 674                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 675                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 676                                                  HDA_AMP_MUTE, 0);
 677                 }
 678         }
 679         return change;
 680 }
 681
 682 #define ALC_PIN_MODE(xname, nid, dir) \
 683         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 684           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 685           .info = alc_pin_mode_info, \
 686           .get = alc_pin_mode_get, \
 687           .put = alc_pin_mode_put, \
 688           .private_value = nid | (dir<<16) }
 689
 690 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 691  * together using a mask with more than one bit set.  This control is
 692  * currently used only by the ALC260 test model.  At this stage they are not
 693  * needed for any "production" models.
 694  */
 695 #ifdef CONFIG_SND_DEBUG
 696 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 697
 698 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 699                              struct snd_ctl_elem_value *ucontrol)
 700 {
 701         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 702         hda_nid_t nid = kcontrol->private_value & 0xffff;
 703         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 704         long *valp = ucontrol->value.integer.value;
 705         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 706                                               AC_VERB_GET_GPIO_DATA, 0x00);
 707
 708         *valp = (val & mask) != 0;
 709         return 0;
 710 }
 711 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 712                              struct snd_ctl_elem_value *ucontrol)
 713 {
 714         signed int change;
 715         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 716         hda_nid_t nid = kcontrol->private_value & 0xffff;
 717         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 718         long val = *ucontrol->value.integer.value;
 719         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 720                                                     AC_VERB_GET_GPIO_DATA,
 721                                                     0x00);
 722
 723         /* Set/unset the masked GPIO bit(s) as needed */
 724         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 725         if (val == 0)
 726                 gpio_data &= ~mask;
 727         else
 728                 gpio_data |= mask;
 729         snd_hda_codec_write_cache(codec, nid, 0,
 730                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 731
 732         return change;
 733 }
 734 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 735         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 736           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 737           .info = alc_gpio_data_info, \
 738           .get = alc_gpio_data_get, \
 739           .put = alc_gpio_data_put, \
 740           .private_value = nid | (mask<<16) }
 741 #endif   /* CONFIG_SND_DEBUG */
 742
 743 /* A switch control to allow the enabling of the digital IO pins on the
 744  * ALC260.  This is incredibly simplistic; the intention of this control is
 745  * to provide something in the test model allowing digital outputs to be
 746  * identified if present.  If models are found which can utilise these
 747  * outputs a more complete mixer control can be devised for those models if
 748  * necessary.
 749  */
 750 #ifdef CONFIG_SND_DEBUG
 751 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 752
 753 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 754                               struct snd_ctl_elem_value *ucontrol)
 755 {
 756         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 757         hda_nid_t nid = kcontrol->private_value & 0xffff;
 758         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 759         long *valp = ucontrol->value.integer.value;
 760         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 761                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 762
 763         *valp = (val & mask) != 0;
 764         return 0;
 765 }
 766 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 767                               struct snd_ctl_elem_value *ucontrol)
 768 {
 769         signed int change;
 770         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 771         hda_nid_t nid = kcontrol->private_value & 0xffff;
 772         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 773         long val = *ucontrol->value.integer.value;
 774         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 775                                                     AC_VERB_GET_DIGI_CONVERT_1,
 776                                                     0x00);
 777
 778         /* Set/unset the masked control bit(s) as needed */
 779         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 780         if (val==0)
 781                 ctrl_data &= ~mask;
 782         else
 783                 ctrl_data |= mask;
 784         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 785                                   ctrl_data);
 786
 787         return change;
 788 }
 789 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 790         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 791           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 792           .info = alc_spdif_ctrl_info, \
 793           .get = alc_spdif_ctrl_get, \
 794           .put = alc_spdif_ctrl_put, \
 795           .private_value = nid | (mask<<16) }
 796 #endif   /* CONFIG_SND_DEBUG */
 797
 798 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 799  * Again, this is only used in the ALC26x test models to help identify when
 800  * the EAPD line must be asserted for features to work.
 801  */
 802 #ifdef CONFIG_SND_DEBUG
 803 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 804
 805 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 806                               struct snd_ctl_elem_value *ucontrol)
 807 {
 808         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 809         hda_nid_t nid = kcontrol->private_value & 0xffff;
 810         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 811         long *valp = ucontrol->value.integer.value;
 812         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 813                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 814
 815         *valp = (val & mask) != 0;
 816         return 0;
 817 }
 818
 819 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 820                               struct snd_ctl_elem_value *ucontrol)
 821 {
 822         int change;
 823         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 824         hda_nid_t nid = kcontrol->private_value & 0xffff;
 825         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 826         long val = *ucontrol->value.integer.value;
 827         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 828                                                     AC_VERB_GET_EAPD_BTLENABLE,
 829                                                     0x00);
 830
 831         /* Set/unset the masked control bit(s) as needed */
 832         change = (!val ? 0 : mask) != (ctrl_data & mask);
 833         if (!val)
 834                 ctrl_data &= ~mask;
 835         else
 836                 ctrl_data |= mask;
 837         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 838                                   ctrl_data);
 839
 840         return change;
 841 }
 842
 843 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 844         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 845           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 846           .info = alc_eapd_ctrl_info, \
 847           .get = alc_eapd_ctrl_get, \
 848           .put = alc_eapd_ctrl_put, \
 849           .private_value = nid | (mask<<16) }
 850 #endif   /* CONFIG_SND_DEBUG */
 851
 852 /*
 853  * set up the input pin config (depending on the given auto-pin type)
 854  */
 855 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 856                               int auto_pin_type)
 857 {
 858         unsigned int val = PIN_IN;
 859
 860         if (auto_pin_type == AUTO_PIN_MIC) {
 861                 unsigned int pincap;
 862                 unsigned int oldval;
 863                 oldval = snd_hda_codec_read(codec, nid, 0,
 864                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 865                 pincap = snd_hda_query_pin_caps(codec, nid);
 866                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 867                 /* if the default pin setup is vref50, we give it priority */
 868                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 869                         val = PIN_VREF80;
 870                 else if (pincap & AC_PINCAP_VREF_50)
 871                         val = PIN_VREF50;
 872                 else if (pincap & AC_PINCAP_VREF_100)
 873                         val = PIN_VREF100;
 874                 else if (pincap & AC_PINCAP_VREF_GRD)
 875                         val = PIN_VREFGRD;
 876         }
 877         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 878 }
 879
 880 static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
 881 {
 882         struct alc_spec *spec = codec->spec;
 883         struct auto_pin_cfg *cfg = &spec->autocfg;
 884
 885         if (!cfg->line_outs) {
 886                 while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
 887                        cfg->line_out_pins[cfg->line_outs])
 888                         cfg->line_outs++;
 889         }
 890         if (!cfg->speaker_outs) {
 891                 while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
 892                        cfg->speaker_pins[cfg->speaker_outs])
 893                         cfg->speaker_outs++;
 894         }
 895         if (!cfg->hp_outs) {
 896                 while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
 897                        cfg->hp_pins[cfg->hp_outs])
 898                         cfg->hp_outs++;
 899         }
 900 }
 901
 902 /*
 903  */
 904 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 905 {
 906         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 907                 return;
 908         spec->mixers[spec->num_mixers++] = mix;
 909 }
 910
 911 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 912 {
 913         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 914                 return;
 915         spec->init_verbs[spec->num_init_verbs++] = verb;
 916 }
 917
 918 /*
 919  * set up from the preset table
 920  */
 921 static void setup_preset(struct hda_codec *codec,
 922                          const struct alc_config_preset *preset)
 923 {
 924         struct alc_spec *spec = codec->spec;
 925         int i;
 926
 927         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 928                 add_mixer(spec, preset->mixers[i]);
 929         spec->cap_mixer = preset->cap_mixer;
 930         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 931              i++)
 932                 add_verb(spec, preset->init_verbs[i]);
 933
 934         spec->channel_mode = preset->channel_mode;
 935         spec->num_channel_mode = preset->num_channel_mode;
 936         spec->need_dac_fix = preset->need_dac_fix;
 937         spec->const_channel_count = preset->const_channel_count;
 938
 939         if (preset->const_channel_count)
 940                 spec->multiout.max_channels = preset->const_channel_count;
 941         else
 942                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 943         spec->ext_channel_count = spec->channel_mode[0].channels;
 944
 945         spec->multiout.num_dacs = preset->num_dacs;
 946         spec->multiout.dac_nids = preset->dac_nids;
 947         spec->multiout.dig_out_nid = preset->dig_out_nid;
 948         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 949         spec->multiout.hp_nid = preset->hp_nid;
 950
 951         spec->num_mux_defs = preset->num_mux_defs;
 952         if (!spec->num_mux_defs)
 953                 spec->num_mux_defs = 1;
 954         spec->input_mux = preset->input_mux;
 955
 956         spec->num_adc_nids = preset->num_adc_nids;
 957         spec->adc_nids = preset->adc_nids;
 958         spec->capsrc_nids = preset->capsrc_nids;
 959         spec->dig_in_nid = preset->dig_in_nid;
 960
 961         spec->unsol_event = preset->unsol_event;
 962         spec->init_hook = preset->init_hook;
 963 #ifdef CONFIG_SND_HDA_POWER_SAVE
 964         spec->power_hook = preset->power_hook;
 965         spec->loopback.amplist = preset->loopbacks;
 966 #endif
 967
 968         if (preset->setup)
 969                 preset->setup(codec);
 970
 971         alc_fixup_autocfg_pin_nums(codec);
 972 }
 973
 974 /* Enable GPIO mask and set output */
 975 static struct hda_verb alc_gpio1_init_verbs[] = {
 976         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 977         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 978         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 979         { }
 980 };
 981
 982 static struct hda_verb alc_gpio2_init_verbs[] = {
 983         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 984         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 985         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 986         { }
 987 };
 988
 989 static struct hda_verb alc_gpio3_init_verbs[] = {
 990         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 991         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 992         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 993         { }
 994 };
 995
 996 /*
 997  * Fix hardware PLL issue
 998  * On some codecs, the analog PLL gating control must be off while
 999  * the default value is 1.
1000  */
1001 static void alc_fix_pll(struct hda_codec *codec)
1002 {
1003         struct alc_spec *spec = codec->spec;
1004         unsigned int val;
1005
1006         if (!spec->pll_nid)
1007                 return;
1008         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1009                             spec->pll_coef_idx);
1010         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1011                                  AC_VERB_GET_PROC_COEF, 0);
1012         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1013                             spec->pll_coef_idx);
1014         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1015                             val & ~(1 << spec->pll_coef_bit));
1016 }
1017
1018 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1019                              unsigned int coef_idx, unsigned int coef_bit)
1020 {
1021         struct alc_spec *spec = codec->spec;
1022         spec->pll_nid = nid;
1023         spec->pll_coef_idx = coef_idx;
1024         spec->pll_coef_bit = coef_bit;
1025         alc_fix_pll(codec);
1026 }
1027
1028 #ifdef CONFIG_SND_HDA_INPUT_JACK
1029 static void alc_free_jack_priv(struct snd_jack *jack)
1030 {
1031         struct alc_jack *jacks = jack->private_data;
1032         jacks->nid = 0;
1033         jacks->jack = NULL;
1034 }
1035
1036 static int alc_add_jack(struct hda_codec *codec,
1037                 hda_nid_t nid, int type)
1038 {
1039         struct alc_spec *spec;
1040         struct alc_jack *jack;
1041         const char *name;
1042         int err;
1043
1044         spec = codec->spec;
1045         snd_array_init(&spec->jacks, sizeof(*jack), 32);
1046         jack = snd_array_new(&spec->jacks);
1047         if (!jack)
1048                 return -ENOMEM;
1049
1050         jack->nid = nid;
1051         jack->type = type;
1052         name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
1053
1054         err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
1055         if (err < 0)
1056                 return err;
1057         jack->jack->private_data = jack;
1058         jack->jack->private_free = alc_free_jack_priv;
1059         return 0;
1060 }
1061
1062 static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1063 {
1064         struct alc_spec *spec = codec->spec;
1065         struct alc_jack *jacks = spec->jacks.list;
1066
1067         if (jacks) {
1068                 int i;
1069                 for (i = 0; i < spec->jacks.used; i++) {
1070                         if (jacks->nid == nid) {
1071                                 unsigned int present;
1072                                 present = snd_hda_jack_detect(codec, nid);
1073
1074                                 present = (present) ? jacks->type : 0;
1075
1076                                 snd_jack_report(jacks->jack, present);
1077                         }
1078                         jacks++;
1079                 }
1080         }
1081 }
1082
1083 static int alc_init_jacks(struct hda_codec *codec)
1084 {
1085         struct alc_spec *spec = codec->spec;
1086         int err;
1087         unsigned int hp_nid = spec->autocfg.hp_pins[0];
1088         unsigned int mic_nid = spec->ext_mic.pin;
1089
1090         if (hp_nid) {
1091                 err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1092                 if (err < 0)
1093                         return err;
1094                 alc_report_jack(codec, hp_nid);
1095         }
1096
1097         if (mic_nid) {
1098                 err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1099                 if (err < 0)
1100                         return err;
1101                 alc_report_jack(codec, mic_nid);
1102         }
1103
1104         return 0;
1105 }
1106 #else
1107 static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1108 {
1109 }
1110
1111 static inline int alc_init_jacks(struct hda_codec *codec)
1112 {
1113         return 0;
1114 }
1115 #endif
1116
1117 static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1118 {
1119         struct alc_spec *spec = codec->spec;
1120         unsigned int mute;
1121         hda_nid_t nid;
1122         int i;
1123
1124         spec->jack_present = 0;
1125         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1126                 nid = spec->autocfg.hp_pins[i];
1127                 if (!nid)
1128                         break;
1129                 if (snd_hda_jack_detect(codec, nid)) {
1130                         spec->jack_present = 1;
1131                         break;
1132                 }
1133                 alc_report_jack(codec, spec->autocfg.hp_pins[i]);
1134         }
1135
1136         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1137         /* Toggle internal speakers muting */
1138         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1139                 nid = spec->autocfg.speaker_pins[i];
1140                 if (!nid)
1141                         break;
1142                 if (pinctl) {
1143                         snd_hda_codec_write(codec, nid, 0,
1144                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1145                                     spec->jack_present ? 0 : PIN_OUT);
1146                 } else {
1147                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1148                                          HDA_AMP_MUTE, mute);
1149                 }
1150         }
1151 }
1152
1153 static void alc_automute_pin(struct hda_codec *codec)
1154 {
1155         alc_automute_speaker(codec, 1);
1156 }
1157
1158 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1159                                 hda_nid_t nid)
1160 {
1161         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1162         int i, nums;
1163
1164         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1165         for (i = 0; i < nums; i++)
1166                 if (conn[i] == nid)
1167                         return i;
1168         return -1;
1169 }
1170
1171 /* switch the current ADC according to the jack state */
1172 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1173 {
1174         struct alc_spec *spec = codec->spec;
1175         unsigned int present;
1176         hda_nid_t new_adc;
1177
1178         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1179         if (present)
1180                 spec->cur_adc_idx = 1;
1181         else
1182                 spec->cur_adc_idx = 0;
1183         new_adc = spec->adc_nids[spec->cur_adc_idx];
1184         if (spec->cur_adc && spec->cur_adc != new_adc) {
1185                 /* stream is running, let's swap the current ADC */
1186                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1187                 spec->cur_adc = new_adc;
1188                 snd_hda_codec_setup_stream(codec, new_adc,
1189                                            spec->cur_adc_stream_tag, 0,
1190                                            spec->cur_adc_format);
1191         }
1192 }
1193
1194 static void alc_mic_automute(struct hda_codec *codec)
1195 {
1196         struct alc_spec *spec = codec->spec;
1197         struct alc_mic_route *dead, *alive;
1198         unsigned int present, type;
1199         hda_nid_t cap_nid;
1200
1201         if (!spec->auto_mic)
1202                 return;
1203         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1204                 return;
1205         if (snd_BUG_ON(!spec->adc_nids))
1206                 return;
1207
1208         if (spec->dual_adc_switch) {
1209                 alc_dual_mic_adc_auto_switch(codec);
1210                 return;
1211         }
1212
1213         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1214
1215         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1216         if (present) {
1217                 alive = &spec->ext_mic;
1218                 dead = &spec->int_mic;
1219         } else {
1220                 alive = &spec->int_mic;
1221                 dead = &spec->ext_mic;
1222         }
1223
1224         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1225         if (type == AC_WID_AUD_MIX) {
1226                 /* Matrix-mixer style (e.g. ALC882) */
1227                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1228                                          alive->mux_idx,
1229                                          HDA_AMP_MUTE, 0);
1230                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1231                                          dead->mux_idx,
1232                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1233         } else {
1234                 /* MUX style (e.g. ALC880) */
1235                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1236                                           AC_VERB_SET_CONNECT_SEL,
1237                                           alive->mux_idx);
1238         }
1239         alc_report_jack(codec, spec->ext_mic.pin);
1240
1241         /* FIXME: analog mixer */
1242 }
1243
1244 /* unsolicited event for HP jack sensing */
1245 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1246 {
1247         if (codec->vendor_id == 0x10ec0880)
1248                 res >>= 28;
1249         else
1250                 res >>= 26;
1251         switch (res) {
1252         case ALC880_HP_EVENT:
1253                 alc_automute_pin(codec);
1254                 break;
1255         case ALC880_MIC_EVENT:
1256                 alc_mic_automute(codec);
1257                 break;
1258         }
1259 }
1260
1261 static void alc_inithook(struct hda_codec *codec)
1262 {
1263         alc_automute_pin(codec);
1264         alc_mic_automute(codec);
1265 }
1266
1267 /* additional initialization for ALC888 variants */
1268 static void alc888_coef_init(struct hda_codec *codec)
1269 {
1270         unsigned int tmp;
1271
1272         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1273         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1274         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1275         if ((tmp & 0xf0) == 0x20)
1276                 /* alc888S-VC */
1277                 snd_hda_codec_read(codec, 0x20, 0,
1278                                    AC_VERB_SET_PROC_COEF, 0x830);
1279          else
1280                  /* alc888-VB */
1281                  snd_hda_codec_read(codec, 0x20, 0,
1282                                     AC_VERB_SET_PROC_COEF, 0x3030);
1283 }
1284
1285 static void alc889_coef_init(struct hda_codec *codec)
1286 {
1287         unsigned int tmp;
1288
1289         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1290         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1291         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1292         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1293 }
1294
1295 /* turn on/off EAPD control (only if available) */
1296 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1297 {
1298         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1299                 return;
1300         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1301                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1302                                     on ? 2 : 0);
1303 }
1304
1305 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1306 {
1307         unsigned int tmp;
1308
1309         switch (type) {
1310         case ALC_INIT_GPIO1:
1311                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1312                 break;
1313         case ALC_INIT_GPIO2:
1314                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1315                 break;
1316         case ALC_INIT_GPIO3:
1317                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1318                 break;
1319         case ALC_INIT_DEFAULT:
1320                 switch (codec->vendor_id) {
1321                 case 0x10ec0260:
1322                         set_eapd(codec, 0x0f, 1);
1323                         set_eapd(codec, 0x10, 1);
1324                         break;
1325                 case 0x10ec0262:
1326                 case 0x10ec0267:
1327                 case 0x10ec0268:
1328                 case 0x10ec0269:
1329                 case 0x10ec0270:
1330                 case 0x10ec0272:
1331                 case 0x10ec0660:
1332                 case 0x10ec0662:
1333                 case 0x10ec0663:
1334                 case 0x10ec0862:
1335                 case 0x10ec0889:
1336                         set_eapd(codec, 0x14, 1);
1337                         set_eapd(codec, 0x15, 1);
1338                         break;
1339                 }
1340                 switch (codec->vendor_id) {
1341                 case 0x10ec0260:
1342                         snd_hda_codec_write(codec, 0x1a, 0,
1343                                             AC_VERB_SET_COEF_INDEX, 7);
1344                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1345                                                  AC_VERB_GET_PROC_COEF, 0);
1346                         snd_hda_codec_write(codec, 0x1a, 0,
1347                                             AC_VERB_SET_COEF_INDEX, 7);
1348                         snd_hda_codec_write(codec, 0x1a, 0,
1349                                             AC_VERB_SET_PROC_COEF,
1350                                             tmp | 0x2010);
1351                         break;
1352                 case 0x10ec0262:
1353                 case 0x10ec0880:
1354                 case 0x10ec0882:
1355                 case 0x10ec0883:
1356                 case 0x10ec0885:
1357                 case 0x10ec0887:
1358                 case 0x10ec0889:
1359                         alc889_coef_init(codec);
1360                         break;
1361                 case 0x10ec0888:
1362                         alc888_coef_init(codec);
1363                         break;
1364 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1365                 case 0x10ec0267:
1366                 case 0x10ec0268:
1367                         snd_hda_codec_write(codec, 0x20, 0,
1368                                             AC_VERB_SET_COEF_INDEX, 7);
1369                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1370                                                  AC_VERB_GET_PROC_COEF, 0);
1371                         snd_hda_codec_write(codec, 0x20, 0,
1372                                             AC_VERB_SET_COEF_INDEX, 7);
1373                         snd_hda_codec_write(codec, 0x20, 0,
1374                                             AC_VERB_SET_PROC_COEF,
1375                                             tmp | 0x3000);
1376                         break;
1377 #endif /* XXX */
1378                 }
1379                 break;
1380         }
1381 }
1382
1383 static void alc_init_auto_hp(struct hda_codec *codec)
1384 {
1385         struct alc_spec *spec = codec->spec;
1386         struct auto_pin_cfg *cfg = &spec->autocfg;
1387         int i;
1388
1389         if (!cfg->hp_pins[0]) {
1390                 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1391                         return;
1392         }
1393
1394         if (!cfg->speaker_pins[0]) {
1395                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1396                         return;
1397                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1398                        sizeof(cfg->speaker_pins));
1399                 cfg->speaker_outs = cfg->line_outs;
1400         }
1401
1402         if (!cfg->hp_pins[0]) {
1403                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1404                        sizeof(cfg->hp_pins));
1405                 cfg->hp_outs = cfg->line_outs;
1406         }
1407
1408         for (i = 0; i < cfg->hp_outs; i++) {
1409                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1410                             cfg->hp_pins[i]);
1411                 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1412                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1413                                   AC_USRSP_EN | ALC880_HP_EVENT);
1414         }
1415         spec->unsol_event = alc_sku_unsol_event;
1416 }
1417
1418 static void alc_init_auto_mic(struct hda_codec *codec)
1419 {
1420         struct alc_spec *spec = codec->spec;
1421         struct auto_pin_cfg *cfg = &spec->autocfg;
1422         hda_nid_t fixed, ext;
1423         int i;
1424
1425         /* there must be only two mic inputs exclusively */
1426         for (i = 0; i < cfg->num_inputs; i++)
1427                 if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1428                         return;
1429
1430         fixed = ext = 0;
1431         for (i = 0; i < cfg->num_inputs; i++) {
1432                 hda_nid_t nid = cfg->inputs[i].pin;
1433                 unsigned int defcfg;
1434                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1435                 switch (snd_hda_get_input_pin_attr(defcfg)) {
1436                 case INPUT_PIN_ATTR_INT:
1437                         if (fixed)
1438                                 return; /* already occupied */
1439                         fixed = nid;
1440                         break;
1441                 case INPUT_PIN_ATTR_UNUSED:
1442                         return; /* invalid entry */
1443                 default:
1444                         if (ext)
1445                                 return; /* already occupied */
1446                         ext = nid;
1447                         break;
1448                 }
1449         }
1450         if (!ext || !fixed)
1451                 return;
1452         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1453                 return; /* no unsol support */
1454         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1455                     ext, fixed);
1456         spec->ext_mic.pin = ext;
1457         spec->int_mic.pin = fixed;
1458         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1459         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1460         spec->auto_mic = 1;
1461         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1462                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1463                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1464         spec->unsol_event = alc_sku_unsol_event;
1465 }
1466
1467 /* Could be any non-zero and even value. When used as fixup, tells
1468  * the driver to ignore any present sku defines.
1469  */
1470 #define ALC_FIXUP_SKU_IGNORE (2)
1471
1472 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1473 {
1474         unsigned int ass, tmp, i;
1475         unsigned nid = 0;
1476         struct alc_spec *spec = codec->spec;
1477
1478         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1479
1480         if (spec->cdefine.fixup) {
1481                 ass = spec->cdefine.sku_cfg;
1482                 if (ass == ALC_FIXUP_SKU_IGNORE)
1483                         return -1;
1484                 goto do_sku;
1485         }
1486
1487         ass = codec->subsystem_id & 0xffff;
1488         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1489                 goto do_sku;
1490
1491         nid = 0x1d;
1492         if (codec->vendor_id == 0x10ec0260)
1493                 nid = 0x17;
1494         ass = snd_hda_codec_get_pincfg(codec, nid);
1495
1496         if (!(ass & 1)) {
1497                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1498                        codec->chip_name, ass);
1499                 return -1;
1500         }
1501
1502         /* check sum */
1503         tmp = 0;
1504         for (i = 1; i < 16; i++) {
1505                 if ((ass >> i) & 1)
1506                         tmp++;
1507         }
1508         if (((ass >> 16) & 0xf) != tmp)
1509                 return -1;
1510
1511         spec->cdefine.port_connectivity = ass >> 30;
1512         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1513         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1514         spec->cdefine.customization = ass >> 8;
1515 do_sku:
1516         spec->cdefine.sku_cfg = ass;
1517         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1518         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1519         spec->cdefine.swap = (ass & 0x2) >> 1;
1520         spec->cdefine.override = ass & 0x1;
1521
1522         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1523                    nid, spec->cdefine.sku_cfg);
1524         snd_printd("SKU: port_connectivity=0x%x\n",
1525                    spec->cdefine.port_connectivity);
1526         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1527         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1528         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1529         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1530         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1531         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1532         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1533
1534         return 0;
1535 }
1536
1537 /* check subsystem ID and set up device-specific initialization;
1538  * return 1 if initialized, 0 if invalid SSID
1539  */
1540 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1541  *      31 ~ 16 :       Manufacture ID
1542  *      15 ~ 8  :       SKU ID
1543  *      7  ~ 0  :       Assembly ID
1544  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1545  */
1546 static int alc_subsystem_id(struct hda_codec *codec,
1547                             hda_nid_t porta, hda_nid_t porte,
1548                             hda_nid_t portd, hda_nid_t porti)
1549 {
1550         unsigned int ass, tmp, i;
1551         unsigned nid;
1552         struct alc_spec *spec = codec->spec;
1553
1554         if (spec->cdefine.fixup) {
1555                 ass = spec->cdefine.sku_cfg;
1556                 if (ass == ALC_FIXUP_SKU_IGNORE)
1557                         return 0;
1558                 goto do_sku;
1559         }
1560
1561         ass = codec->subsystem_id & 0xffff;
1562         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1563                 goto do_sku;
1564
1565         /* invalid SSID, check the special NID pin defcfg instead */
1566         /*
1567          * 31~30        : port connectivity
1568          * 29~21        : reserve
1569          * 20           : PCBEEP input
1570          * 19~16        : Check sum (15:1)
1571          * 15~1         : Custom
1572          * 0            : override
1573         */
1574         nid = 0x1d;
1575         if (codec->vendor_id == 0x10ec0260)
1576                 nid = 0x17;
1577         ass = snd_hda_codec_get_pincfg(codec, nid);
1578         snd_printd("realtek: No valid SSID, "
1579                    "checking pincfg 0x%08x for NID 0x%x\n",
1580                    ass, nid);
1581         if (!(ass & 1))
1582                 return 0;
1583         if ((ass >> 30) != 1)   /* no physical connection */
1584                 return 0;
1585
1586         /* check sum */
1587         tmp = 0;
1588         for (i = 1; i < 16; i++) {
1589                 if ((ass >> i) & 1)
1590                         tmp++;
1591         }
1592         if (((ass >> 16) & 0xf) != tmp)
1593                 return 0;
1594 do_sku:
1595         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1596                    ass & 0xffff, codec->vendor_id);
1597         /*
1598          * 0 : override
1599          * 1 :  Swap Jack
1600          * 2 : 0 --> Desktop, 1 --> Laptop
1601          * 3~5 : External Amplifier control
1602          * 7~6 : Reserved
1603         */
1604         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1605         switch (tmp) {
1606         case 1:
1607                 spec->init_amp = ALC_INIT_GPIO1;
1608                 break;
1609         case 3:
1610                 spec->init_amp = ALC_INIT_GPIO2;
1611                 break;
1612         case 7:
1613                 spec->init_amp = ALC_INIT_GPIO3;
1614                 break;
1615         case 5:
1616         default:
1617                 spec->init_amp = ALC_INIT_DEFAULT;
1618                 break;
1619         }
1620
1621         /* is laptop or Desktop and enable the function "Mute internal speaker
1622          * when the external headphone out jack is plugged"
1623          */
1624         if (!(ass & 0x8000))
1625                 return 1;
1626         /*
1627          * 10~8 : Jack location
1628          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1629          * 14~13: Resvered
1630          * 15   : 1 --> enable the function "Mute internal speaker
1631          *              when the external headphone out jack is plugged"
1632          */
1633         if (!spec->autocfg.hp_pins[0]) {
1634                 hda_nid_t nid;
1635                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1636                 if (tmp == 0)
1637                         nid = porta;
1638                 else if (tmp == 1)
1639                         nid = porte;
1640                 else if (tmp == 2)
1641                         nid = portd;
1642                 else if (tmp == 3)
1643                         nid = porti;
1644                 else
1645                         return 1;
1646                 for (i = 0; i < spec->autocfg.line_outs; i++)
1647                         if (spec->autocfg.line_out_pins[i] == nid)
1648                                 return 1;
1649                 spec->autocfg.hp_pins[0] = nid;
1650         }
1651
1652         alc_init_auto_hp(codec);
1653         alc_init_auto_mic(codec);
1654         return 1;
1655 }
1656
1657 static void alc_ssid_check(struct hda_codec *codec,
1658                            hda_nid_t porta, hda_nid_t porte,
1659                            hda_nid_t portd, hda_nid_t porti)
1660 {
1661         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1662                 struct alc_spec *spec = codec->spec;
1663                 snd_printd("realtek: "
1664                            "Enable default setup for auto mode as fallback\n");
1665                 spec->init_amp = ALC_INIT_DEFAULT;
1666                 alc_init_auto_hp(codec);
1667                 alc_init_auto_mic(codec);
1668         }
1669 }
1670
1671 /*
1672  * Fix-up pin default configurations and add default verbs
1673  */
1674
1675 struct alc_pincfg {
1676         hda_nid_t nid;
1677         u32 val;
1678 };
1679
1680 struct alc_model_fixup {
1681         const int id;
1682         const char *name;
1683 };
1684
1685 struct alc_fixup {
1686         unsigned int sku;
1687         const struct alc_pincfg *pins;
1688         const struct hda_verb *verbs;
1689         void (*func)(struct hda_codec *codec, const struct alc_fixup *fix,
1690                      int pre_init);
1691 };
1692
1693 static void __alc_pick_fixup(struct hda_codec *codec,
1694                              const struct alc_fixup *fix,
1695                              const char *modelname,
1696                              int pre_init)
1697 {
1698         const struct alc_pincfg *cfg;
1699         struct alc_spec *spec;
1700
1701         cfg = fix->pins;
1702         if (pre_init && fix->sku) {
1703 #ifdef CONFIG_SND_DEBUG_VERBOSE
1704                 snd_printdd(KERN_INFO "hda_codec: %s: Apply sku override for %s\n",
1705                             codec->chip_name, modelname);
1706 #endif
1707                 spec = codec->spec;
1708                 spec->cdefine.sku_cfg = fix->sku;
1709                 spec->cdefine.fixup = 1;
1710         }
1711         if (pre_init && cfg) {
1712 #ifdef CONFIG_SND_DEBUG_VERBOSE
1713                 snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
1714                             codec->chip_name, modelname);
1715 #endif
1716                 for (; cfg->nid; cfg++)
1717                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1718         }
1719         if (!pre_init && fix->verbs) {
1720 #ifdef CONFIG_SND_DEBUG_VERBOSE
1721                 snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
1722                             codec->chip_name, modelname);
1723 #endif
1724                 add_verb(codec->spec, fix->verbs);
1725         }
1726         if (fix->func) {
1727 #ifdef CONFIG_SND_DEBUG_VERBOSE
1728                 snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-func for %s\n",
1729                             codec->chip_name, modelname);
1730 #endif
1731                 fix->func(codec, fix, pre_init);
1732         }
1733 }
1734
1735 static void alc_pick_fixup(struct hda_codec *codec,
1736                                  const struct snd_pci_quirk *quirk,
1737                                  const struct alc_fixup *fix,
1738                                  int pre_init)
1739 {
1740         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1741         if (quirk) {
1742                 fix += quirk->value;
1743 #ifdef CONFIG_SND_DEBUG_VERBOSE
1744                 __alc_pick_fixup(codec, fix, quirk->name, pre_init);
1745 #else
1746                 __alc_pick_fixup(codec, fix, NULL, pre_init);
1747 #endif
1748         }
1749 }
1750
1751 static void alc_pick_fixup_model(struct hda_codec *codec,
1752                                  const struct alc_model_fixup *models,
1753                                  const struct snd_pci_quirk *quirk,
1754                                  const struct alc_fixup *fix,
1755                                  int pre_init)
1756 {
1757         if (codec->modelname && models) {
1758                 while (models->name) {
1759                         if (!strcmp(codec->modelname, models->name)) {
1760                                 fix += models->id;
1761                                 break;
1762                         }
1763                         models++;
1764                 }
1765                 __alc_pick_fixup(codec, fix, codec->modelname, pre_init);
1766         } else {
1767                 alc_pick_fixup(codec, quirk, fix, pre_init);
1768         }
1769 }
1770
1771 static int alc_read_coef_idx(struct hda_codec *codec,
1772                         unsigned int coef_idx)
1773 {
1774         unsigned int val;
1775         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1776                                 coef_idx);
1777         val = snd_hda_codec_read(codec, 0x20, 0,
1778                                 AC_VERB_GET_PROC_COEF, 0);
1779         return val;
1780 }
1781
1782 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1783                                                         unsigned int coef_val)
1784 {
1785         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1786                             coef_idx);
1787         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1788                             coef_val);
1789 }
1790
1791 /* set right pin controls for digital I/O */
1792 static void alc_auto_init_digital(struct hda_codec *codec)
1793 {
1794         struct alc_spec *spec = codec->spec;
1795         int i;
1796         hda_nid_t pin;
1797
1798         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1799                 pin = spec->autocfg.dig_out_pins[i];
1800                 if (pin) {
1801                         snd_hda_codec_write(codec, pin, 0,
1802                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1803                                             PIN_OUT);
1804                 }
1805         }
1806         pin = spec->autocfg.dig_in_pin;
1807         if (pin)
1808                 snd_hda_codec_write(codec, pin, 0,
1809                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1810                                     PIN_IN);
1811 }
1812
1813 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1814 static void alc_auto_parse_digital(struct hda_codec *codec)
1815 {
1816         struct alc_spec *spec = codec->spec;
1817         int i, err;
1818         hda_nid_t dig_nid;
1819
1820         /* support multiple SPDIFs; the secondary is set up as a slave */
1821         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1822                 err = snd_hda_get_connections(codec,
1823                                               spec->autocfg.dig_out_pins[i],
1824                                               &dig_nid, 1);
1825                 if (err < 0)
1826                         continue;
1827                 if (!i) {
1828                         spec->multiout.dig_out_nid = dig_nid;
1829                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1830                 } else {
1831                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1832                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1833                                 break;
1834                         spec->slave_dig_outs[i - 1] = dig_nid;
1835                 }
1836         }
1837
1838         if (spec->autocfg.dig_in_pin) {
1839                 dig_nid = codec->start_nid;
1840                 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1841                         unsigned int wcaps = get_wcaps(codec, dig_nid);
1842                         if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1843                                 continue;
1844                         if (!(wcaps & AC_WCAP_DIGITAL))
1845                                 continue;
1846                         if (!(wcaps & AC_WCAP_CONN_LIST))
1847                                 continue;
1848                         err = get_connection_index(codec, dig_nid,
1849                                                    spec->autocfg.dig_in_pin);
1850                         if (err >= 0) {
1851                                 spec->dig_in_nid = dig_nid;
1852                                 break;
1853                         }
1854                 }
1855         }
1856 }
1857
1858 /*
1859  * ALC888
1860  */
1861
1862 /*
1863  * 2ch mode
1864  */
1865 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1866 /* Mic-in jack as mic in */
1867         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1868         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1869 /* Line-in jack as Line in */
1870         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1871         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1872 /* Line-Out as Front */
1873         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1874         { } /* end */
1875 };
1876
1877 /*
1878  * 4ch mode
1879  */
1880 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1881 /* Mic-in jack as mic in */
1882         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1883         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1884 /* Line-in jack as Surround */
1885         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1886         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1887 /* Line-Out as Front */
1888         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1889         { } /* end */
1890 };
1891
1892 /*
1893  * 6ch mode
1894  */
1895 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1896 /* Mic-in jack as CLFE */
1897         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1898         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1899 /* Line-in jack as Surround */
1900         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1901         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1902 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1903         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1904         { } /* end */
1905 };
1906
1907 /*
1908  * 8ch mode
1909  */
1910 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1911 /* Mic-in jack as CLFE */
1912         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1913         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1914 /* Line-in jack as Surround */
1915         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1916         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1917 /* Line-Out as Side */
1918         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1919         { } /* end */
1920 };
1921
1922 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1923         { 2, alc888_4ST_ch2_intel_init },
1924         { 4, alc888_4ST_ch4_intel_init },
1925         { 6, alc888_4ST_ch6_intel_init },
1926         { 8, alc888_4ST_ch8_intel_init },
1927 };
1928
1929 /*
1930  * ALC888 Fujitsu Siemens Amillo xa3530
1931  */
1932
1933 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1934 /* Front Mic: set to PIN_IN (empty by default) */
1935         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1936 /* Connect Internal HP to Front */
1937         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1938         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1939         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1940 /* Connect Bass HP to Front */
1941         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1942         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1943         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1944 /* Connect Line-Out side jack (SPDIF) to Side */
1945         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1946         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1947         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1948 /* Connect Mic jack to CLFE */
1949         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1950         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1951         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1952 /* Connect Line-in jack to Surround */
1953         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1954         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1955         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1956 /* Connect HP out jack to Front */
1957         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1958         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1959         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1960 /* Enable unsolicited event for HP jack and Line-out jack */
1961         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1962         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1963         {}
1964 };
1965
1966 static void alc_automute_amp(struct hda_codec *codec)
1967 {
1968         alc_automute_speaker(codec, 0);
1969 }
1970
1971 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1972                                          unsigned int res)
1973 {
1974         if (codec->vendor_id == 0x10ec0880)
1975                 res >>= 28;
1976         else
1977                 res >>= 26;
1978         if (res == ALC880_HP_EVENT)
1979                 alc_automute_amp(codec);
1980 }
1981
1982 static void alc889_automute_setup(struct hda_codec *codec)
1983 {
1984         struct alc_spec *spec = codec->spec;
1985
1986         spec->autocfg.hp_pins[0] = 0x15;
1987         spec->autocfg.speaker_pins[0] = 0x14;
1988         spec->autocfg.speaker_pins[1] = 0x16;
1989         spec->autocfg.speaker_pins[2] = 0x17;
1990         spec->autocfg.speaker_pins[3] = 0x19;
1991         spec->autocfg.speaker_pins[4] = 0x1a;
1992 }
1993
1994 static void alc889_intel_init_hook(struct hda_codec *codec)
1995 {
1996         alc889_coef_init(codec);
1997         alc_automute_amp(codec);
1998 }
1999
2000 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
2001 {
2002         struct alc_spec *spec = codec->spec;
2003
2004         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
2005         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
2006         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
2007         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
2008 }
2009
2010 /*
2011  * ALC888 Acer Aspire 4930G model
2012  */
2013
2014 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
2015 /* Front Mic: set to PIN_IN (empty by default) */
2016         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2017 /* Unselect Front Mic by default in input mixer 3 */
2018         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2019 /* Enable unsolicited event for HP jack */
2020         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2021 /* Connect Internal HP to front */
2022         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2023         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2024         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2025 /* Connect HP out to front */
2026         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2027         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2028         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2029         { }
2030 };
2031
2032 /*
2033  * ALC888 Acer Aspire 6530G model
2034  */
2035
2036 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2037 /* Route to built-in subwoofer as well as speakers */
2038         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2039         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2040         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2041         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2042 /* Bias voltage on for external mic port */
2043         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2044 /* Front Mic: set to PIN_IN (empty by default) */
2045         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2046 /* Unselect Front Mic by default in input mixer 3 */
2047         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2048 /* Enable unsolicited event for HP jack */
2049         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2050 /* Enable speaker output */
2051         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2052         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2053         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2054 /* Enable headphone output */
2055         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2056         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2057         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2058         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2059         { }
2060 };
2061
2062 /*
2063  *ALC888 Acer Aspire 7730G model
2064  */
2065
2066 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2067 /* Bias voltage on for external mic port */
2068         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2069 /* Front Mic: set to PIN_IN (empty by default) */
2070         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2071 /* Unselect Front Mic by default in input mixer 3 */
2072         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2073 /* Enable unsolicited event for HP jack */
2074         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2075 /* Enable speaker output */
2076         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2077         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2078         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2079 /* Enable headphone output */
2080         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2081         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2083         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2084 /*Enable internal subwoofer */
2085         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2086         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2087         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2088         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2089         { }
2090 };
2091
2092 /*
2093  * ALC889 Acer Aspire 8930G model
2094  */
2095
2096 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2097 /* Front Mic: set to PIN_IN (empty by default) */
2098         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2099 /* Unselect Front Mic by default in input mixer 3 */
2100         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2101 /* Enable unsolicited event for HP jack */
2102         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2103 /* Connect Internal Front to Front */
2104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2106         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2107 /* Connect Internal Rear to Rear */
2108         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2109         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2110         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2111 /* Connect Internal CLFE to CLFE */
2112         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2113         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2114         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2115 /* Connect HP out to Front */
2116         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2117         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2118         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2119 /* Enable all DACs */
2120 /*  DAC DISABLE/MUTE 1? */
2121 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2122         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2123         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2124 /*  DAC DISABLE/MUTE 2? */
2125 /*  some bit here disables the other DACs. Init=0x4900 */
2126         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2127         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2128 /* DMIC fix
2129  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2130  * which makes the stereo useless. However, either the mic or the ALC889
2131  * makes the signal become a difference/sum signal instead of standard
2132  * stereo, which is annoying. So instead we flip this bit which makes the
2133  * codec replicate the sum signal to both channels, turning it into a
2134  * normal mono mic.
2135  */
2136 /*  DMIC_CONTROL? Init value = 0x0001 */
2137         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2138         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2139         { }
2140 };
2141
2142 static struct hda_input_mux alc888_2_capture_sources[2] = {
2143         /* Front mic only available on one ADC */
2144         {
2145                 .num_items = 4,
2146                 .items = {
2147                         { "Mic", 0x0 },
2148                         { "Line", 0x2 },
2149                         { "CD", 0x4 },
2150                         { "Front Mic", 0xb },
2151                 },
2152         },
2153         {
2154                 .num_items = 3,
2155                 .items = {
2156                         { "Mic", 0x0 },
2157                         { "Line", 0x2 },
2158                         { "CD", 0x4 },
2159                 },
2160         }
2161 };
2162
2163 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2164         /* Interal mic only available on one ADC */
2165         {
2166                 .num_items = 5,
2167                 .items = {
2168                         { "Ext Mic", 0x0 },
2169                         { "Line In", 0x2 },
2170                         { "CD", 0x4 },
2171                         { "Input Mix", 0xa },
2172                         { "Int Mic", 0xb },
2173                 },
2174         },
2175         {
2176                 .num_items = 4,
2177                 .items = {
2178                         { "Ext Mic", 0x0 },
2179                         { "Line In", 0x2 },
2180                         { "CD", 0x4 },
2181                         { "Input Mix", 0xa },
2182                 },
2183         }
2184 };
2185
2186 static struct hda_input_mux alc889_capture_sources[3] = {
2187         /* Digital mic only available on first "ADC" */
2188         {
2189                 .num_items = 5,
2190                 .items = {
2191                         { "Mic", 0x0 },
2192                         { "Line", 0x2 },
2193                         { "CD", 0x4 },
2194                         { "Front Mic", 0xb },
2195                         { "Input Mix", 0xa },
2196                 },
2197         },
2198         {
2199                 .num_items = 4,
2200                 .items = {
2201                         { "Mic", 0x0 },
2202                         { "Line", 0x2 },
2203                         { "CD", 0x4 },
2204                         { "Input Mix", 0xa },
2205                 },
2206         },
2207         {
2208                 .num_items = 4,
2209                 .items = {
2210                         { "Mic", 0x0 },
2211                         { "Line", 0x2 },
2212                         { "CD", 0x4 },
2213                         { "Input Mix", 0xa },
2214                 },
2215         }
2216 };
2217
2218 static struct snd_kcontrol_new alc888_base_mixer[] = {
2219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2220         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2221         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2222         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2223         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2224                 HDA_OUTPUT),
2225         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2226         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2227         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2228         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2229         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2230         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2231         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2232         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2233         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2234         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2235         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2236         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2237         { } /* end */
2238 };
2239
2240 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2241         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2242         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2243         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2244         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2245         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2246                 HDA_OUTPUT),
2247         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2248         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2249         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2252         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2253         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2254         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2255         { } /* end */
2256 };
2257
2258
2259 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2260 {
2261         struct alc_spec *spec = codec->spec;
2262
2263         spec->autocfg.hp_pins[0] = 0x15;
2264         spec->autocfg.speaker_pins[0] = 0x14;
2265         spec->autocfg.speaker_pins[1] = 0x16;
2266         spec->autocfg.speaker_pins[2] = 0x17;
2267 }
2268
2269 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2270 {
2271         struct alc_spec *spec = codec->spec;
2272
2273         spec->autocfg.hp_pins[0] = 0x15;
2274         spec->autocfg.speaker_pins[0] = 0x14;
2275         spec->autocfg.speaker_pins[1] = 0x16;
2276         spec->autocfg.speaker_pins[2] = 0x17;
2277 }
2278
2279 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2280 {
2281         struct alc_spec *spec = codec->spec;
2282
2283         spec->autocfg.hp_pins[0] = 0x15;
2284         spec->autocfg.speaker_pins[0] = 0x14;
2285         spec->autocfg.speaker_pins[1] = 0x16;
2286         spec->autocfg.speaker_pins[2] = 0x17;
2287 }
2288
2289 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2290 {
2291         struct alc_spec *spec = codec->spec;
2292
2293         spec->autocfg.hp_pins[0] = 0x15;
2294         spec->autocfg.speaker_pins[0] = 0x14;
2295         spec->autocfg.speaker_pins[1] = 0x16;
2296         spec->autocfg.speaker_pins[2] = 0x1b;
2297 }
2298
2299 /*
2300  * ALC880 3-stack model
2301  *
2302  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2303  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2304  *                 F-Mic = 0x1b, HP = 0x19
2305  */
2306
2307 static hda_nid_t alc880_dac_nids[4] = {
2308         /* front, rear, clfe, rear_surr */
2309         0x02, 0x05, 0x04, 0x03
2310 };
2311
2312 static hda_nid_t alc880_adc_nids[3] = {
2313         /* ADC0-2 */
2314         0x07, 0x08, 0x09,
2315 };
2316
2317 /* The datasheet says the node 0x07 is connected from inputs,
2318  * but it shows zero connection in the real implementation on some devices.
2319  * Note: this is a 915GAV bug, fixed on 915GLV
2320  */
2321 static hda_nid_t alc880_adc_nids_alt[2] = {
2322         /* ADC1-2 */
2323         0x08, 0x09,
2324 };
2325
2326 #define ALC880_DIGOUT_NID       0x06
2327 #define ALC880_DIGIN_NID        0x0a
2328
2329 static struct hda_input_mux alc880_capture_source = {
2330         .num_items = 4,
2331         .items = {
2332                 { "Mic", 0x0 },
2333                 { "Front Mic", 0x3 },
2334                 { "Line", 0x2 },
2335                 { "CD", 0x4 },
2336         },
2337 };
2338
2339 /* channel source setting (2/6 channel selection for 3-stack) */
2340 /* 2ch mode */
2341 static struct hda_verb alc880_threestack_ch2_init[] = {
2342         /* set line-in to input, mute it */
2343         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2344         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2345         /* set mic-in to input vref 80%, mute it */
2346         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2347         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2348         { } /* end */
2349 };
2350
2351 /* 6ch mode */
2352 static struct hda_verb alc880_threestack_ch6_init[] = {
2353         /* set line-in to output, unmute it */
2354         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2355         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2356         /* set mic-in to output, unmute it */
2357         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2358         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2359         { } /* end */
2360 };
2361
2362 static struct hda_channel_mode alc880_threestack_modes[2] = {
2363         { 2, alc880_threestack_ch2_init },
2364         { 6, alc880_threestack_ch6_init },
2365 };
2366
2367 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2368         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2369         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2370         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2371         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2372         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2373         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2374         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2375         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2376         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2377         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2378         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2379         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2380         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2381         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2382         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2383         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2384         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2385         {
2386                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2387                 .name = "Channel Mode",
2388                 .info = alc_ch_mode_info,
2389                 .get = alc_ch_mode_get,
2390                 .put = alc_ch_mode_put,
2391         },
2392         { } /* end */
2393 };
2394
2395 /* capture mixer elements */
2396 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2397                             struct snd_ctl_elem_info *uinfo)
2398 {
2399         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2400         struct alc_spec *spec = codec->spec;
2401         int err;
2402
2403         mutex_lock(&codec->control_mutex);
2404         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2405                                                       HDA_INPUT);
2406         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2407         mutex_unlock(&codec->control_mutex);
2408         return err;
2409 }
2410
2411 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2412                            unsigned int size, unsigned int __user *tlv)
2413 {
2414         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2415         struct alc_spec *spec = codec->spec;
2416         int err;
2417
2418         mutex_lock(&codec->control_mutex);
2419         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2420                                                       HDA_INPUT);
2421         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2422         mutex_unlock(&codec->control_mutex);
2423         return err;
2424 }
2425
2426 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2427                              struct snd_ctl_elem_value *ucontrol);
2428
2429 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2430                                  struct snd_ctl_elem_value *ucontrol,
2431                                  getput_call_t func)
2432 {
2433         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2434         struct alc_spec *spec = codec->spec;
2435         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2436         int err;
2437
2438         mutex_lock(&codec->control_mutex);
2439         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2440                                                       3, 0, HDA_INPUT);
2441         err = func(kcontrol, ucontrol);
2442         mutex_unlock(&codec->control_mutex);
2443         return err;
2444 }
2445
2446 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2447                            struct snd_ctl_elem_value *ucontrol)
2448 {
2449         return alc_cap_getput_caller(kcontrol, ucontrol,
2450                                      snd_hda_mixer_amp_volume_get);
2451 }
2452
2453 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2454                            struct snd_ctl_elem_value *ucontrol)
2455 {
2456         return alc_cap_getput_caller(kcontrol, ucontrol,
2457                                      snd_hda_mixer_amp_volume_put);
2458 }
2459
2460 /* capture mixer elements */
2461 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2462
2463 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2464                           struct snd_ctl_elem_value *ucontrol)
2465 {
2466         return alc_cap_getput_caller(kcontrol, ucontrol,
2467                                      snd_hda_mixer_amp_switch_get);
2468 }
2469
2470 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2471                           struct snd_ctl_elem_value *ucontrol)
2472 {
2473         return alc_cap_getput_caller(kcontrol, ucontrol,
2474                                      snd_hda_mixer_amp_switch_put);
2475 }
2476
2477 #define _DEFINE_CAPMIX(num) \
2478         { \
2479                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2480                 .name = "Capture Switch", \
2481                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2482                 .count = num, \
2483                 .info = alc_cap_sw_info, \
2484                 .get = alc_cap_sw_get, \
2485                 .put = alc_cap_sw_put, \
2486         }, \
2487         { \
2488                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2489                 .name = "Capture Volume", \
2490                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2491                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2492                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2493                 .count = num, \
2494                 .info = alc_cap_vol_info, \
2495                 .get = alc_cap_vol_get, \
2496                 .put = alc_cap_vol_put, \
2497                 .tlv = { .c = alc_cap_vol_tlv }, \
2498         }
2499
2500 #define _DEFINE_CAPSRC(num) \
2501         { \
2502                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2503                 /* .name = "Capture Source", */ \
2504                 .name = "Input Source", \
2505                 .count = num, \
2506                 .info = alc_mux_enum_info, \
2507                 .get = alc_mux_enum_get, \
2508                 .put = alc_mux_enum_put, \
2509         }
2510
2511 #define DEFINE_CAPMIX(num) \
2512 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2513         _DEFINE_CAPMIX(num),                                  \
2514         _DEFINE_CAPSRC(num),                                  \
2515         { } /* end */                                         \
2516 }
2517
2518 #define DEFINE_CAPMIX_NOSRC(num) \
2519 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2520         _DEFINE_CAPMIX(num),                                        \
2521         { } /* end */                                               \
2522 }
2523
2524 /* up to three ADCs */
2525 DEFINE_CAPMIX(1);
2526 DEFINE_CAPMIX(2);
2527 DEFINE_CAPMIX(3);
2528 DEFINE_CAPMIX_NOSRC(1);
2529 DEFINE_CAPMIX_NOSRC(2);
2530 DEFINE_CAPMIX_NOSRC(3);
2531
2532 /*
2533  * ALC880 5-stack model
2534  *
2535  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2536  *      Side = 0x02 (0xd)
2537  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2538  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2539  */
2540
2541 /* additional mixers to alc880_three_stack_mixer */
2542 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2543         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2544         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2545         { } /* end */
2546 };
2547
2548 /* channel source setting (6/8 channel selection for 5-stack) */
2549 /* 6ch mode */
2550 static struct hda_verb alc880_fivestack_ch6_init[] = {
2551         /* set line-in to input, mute it */
2552         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2553         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2554         { } /* end */
2555 };
2556
2557 /* 8ch mode */
2558 static struct hda_verb alc880_fivestack_ch8_init[] = {
2559         /* set line-in to output, unmute it */
2560         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2561         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2562         { } /* end */
2563 };
2564
2565 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2566         { 6, alc880_fivestack_ch6_init },
2567         { 8, alc880_fivestack_ch8_init },
2568 };
2569
2570
2571 /*
2572  * ALC880 6-stack model
2573  *
2574  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2575  *      Side = 0x05 (0x0f)
2576  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2577  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2578  */
2579
2580 static hda_nid_t alc880_6st_dac_nids[4] = {
2581         /* front, rear, clfe, rear_surr */
2582         0x02, 0x03, 0x04, 0x05
2583 };
2584
2585 static struct hda_input_mux alc880_6stack_capture_source = {
2586         .num_items = 4,
2587         .items = {
2588                 { "Mic", 0x0 },
2589                 { "Front Mic", 0x1 },
2590                 { "Line", 0x2 },
2591                 { "CD", 0x4 },
2592         },
2593 };
2594
2595 /* fixed 8-channels */
2596 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2597         { 8, NULL },
2598 };
2599
2600 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2601         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2602         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2603         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2604         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2605         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2606         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2607         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2608         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2609         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2610         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2611         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2612         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2613         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2614         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2615         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2616         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2617         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2618         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2619         {
2620                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2621                 .name = "Channel Mode",
2622                 .info = alc_ch_mode_info,
2623                 .get = alc_ch_mode_get,
2624                 .put = alc_ch_mode_put,
2625         },
2626         { } /* end */
2627 };
2628
2629
2630 /*
2631  * ALC880 W810 model
2632  *
2633  * W810 has rear IO for:
2634  * Front (DAC 02)
2635  * Surround (DAC 03)
2636  * Center/LFE (DAC 04)
2637  * Digital out (06)
2638  *
2639  * The system also has a pair of internal speakers, and a headphone jack.
2640  * These are both connected to Line2 on the codec, hence to DAC 02.
2641  *
2642  * There is a variable resistor to control the speaker or headphone
2643  * volume. This is a hardware-only device without a software API.
2644  *
2645  * Plugging headphones in will disable the internal speakers. This is
2646  * implemented in hardware, not via the driver using jack sense. In
2647  * a similar fashion, plugging into the rear socket marked "front" will
2648  * disable both the speakers and headphones.
2649  *
2650  * For input, there's a microphone jack, and an "audio in" jack.
2651  * These may not do anything useful with this driver yet, because I
2652  * haven't setup any initialization verbs for these yet...
2653  */
2654
2655 static hda_nid_t alc880_w810_dac_nids[3] = {
2656         /* front, rear/surround, clfe */
2657         0x02, 0x03, 0x04
2658 };
2659
2660 /* fixed 6 channels */
2661 static struct hda_channel_mode alc880_w810_modes[1] = {
2662         { 6, NULL }
2663 };
2664
2665 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2666 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2667         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2668         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2669         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2670         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2671         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2672         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2673         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2674         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2675         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2676         { } /* end */
2677 };
2678
2679
2680 /*
2681  * Z710V model
2682  *
2683  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2684  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2685  *                 Line = 0x1a
2686  */
2687
2688 static hda_nid_t alc880_z71v_dac_nids[1] = {
2689         0x02
2690 };
2691 #define ALC880_Z71V_HP_DAC      0x03
2692
2693 /* fixed 2 channels */
2694 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2695         { 2, NULL }
2696 };
2697
2698 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2699         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2700         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2701         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2702         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2703         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2704         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2705         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2706         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2707         { } /* end */
2708 };
2709
2710
2711 /*
2712  * ALC880 F1734 model
2713  *
2714  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2715  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2716  */
2717
2718 static hda_nid_t alc880_f1734_dac_nids[1] = {
2719         0x03
2720 };
2721 #define ALC880_F1734_HP_DAC     0x02
2722
2723 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2724         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2725         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2726         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2727         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2728         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2729         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2730         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2731         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2732         { } /* end */
2733 };
2734
2735 static struct hda_input_mux alc880_f1734_capture_source = {
2736         .num_items = 2,
2737         .items = {
2738                 { "Mic", 0x1 },
2739                 { "CD", 0x4 },
2740         },
2741 };
2742
2743
2744 /*
2745  * ALC880 ASUS model
2746  *
2747  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2748  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2749  *  Mic = 0x18, Line = 0x1a
2750  */
2751
2752 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2753 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2754
2755 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2756         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2757         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2758         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2759         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2760         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2761         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2762         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2763         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2764         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2765         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2766         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2767         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2768         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2769         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2770         {
2771                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2772                 .name = "Channel Mode",
2773                 .info = alc_ch_mode_info,
2774                 .get = alc_ch_mode_get,
2775                 .put = alc_ch_mode_put,
2776         },
2777         { } /* end */
2778 };
2779
2780 /*
2781  * ALC880 ASUS W1V model
2782  *
2783  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2784  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2785  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2786  */
2787
2788 /* additional mixers to alc880_asus_mixer */
2789 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2790         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2791         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2792         { } /* end */
2793 };
2794
2795 /* TCL S700 */
2796 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2797         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2798         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2799         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2800         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2801         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2802         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2803         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2804         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2805         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2806         { } /* end */
2807 };
2808
2809 /* Uniwill */
2810 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2811         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2812         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2813         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2814         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2815         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2816         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2817         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2818         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2819         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2820         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2821         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2822         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2823         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2824         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2825         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2826         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2827         {
2828                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2829                 .name = "Channel Mode",
2830                 .info = alc_ch_mode_info,
2831                 .get = alc_ch_mode_get,
2832                 .put = alc_ch_mode_put,
2833         },
2834         { } /* end */
2835 };
2836
2837 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2838         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2839         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2840         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2841         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2842         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2843         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2844         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2845         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2846         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2847         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2848         { } /* end */
2849 };
2850
2851 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2852         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2853         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2854         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2855         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2856         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2858         { } /* end */
2859 };
2860
2861 /*
2862  * virtual master controls
2863  */
2864
2865 /*
2866  * slave controls for virtual master
2867  */
2868 static const char *alc_slave_vols[] = {
2869         "Front Playback Volume",
2870         "Surround Playback Volume",
2871         "Center Playback Volume",
2872         "LFE Playback Volume",
2873         "Side Playback Volume",
2874         "Headphone Playback Volume",
2875         "Speaker Playback Volume",
2876         "Mono Playback Volume",
2877         "Line-Out Playback Volume",
2878         "PCM Playback Volume",
2879         NULL,
2880 };
2881
2882 static const char *alc_slave_sws[] = {
2883         "Front Playback Switch",
2884         "Surround Playback Switch",
2885         "Center Playback Switch",
2886         "LFE Playback Switch",
2887         "Side Playback Switch",
2888         "Headphone Playback Switch",
2889         "Speaker Playback Switch",
2890         "Mono Playback Switch",
2891         "IEC958 Playback Switch",
2892         "Line-Out Playback Switch",
2893         "PCM Playback Switch",
2894         NULL,
2895 };
2896
2897 /*
2898  * build control elements
2899  */
2900
2901 #define NID_MAPPING             (-1)
2902
2903 #define SUBDEV_SPEAKER_         (0 << 6)
2904 #define SUBDEV_HP_              (1 << 6)
2905 #define SUBDEV_LINE_            (2 << 6)
2906 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2907 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2908 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2909
2910 static void alc_free_kctls(struct hda_codec *codec);
2911
2912 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2913 /* additional beep mixers; the actual parameters are overwritten at build */
2914 static struct snd_kcontrol_new alc_beep_mixer[] = {
2915         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2916         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2917         { } /* end */
2918 };
2919 #endif
2920
2921 static int alc_build_controls(struct hda_codec *codec)
2922 {
2923         struct alc_spec *spec = codec->spec;
2924         struct snd_kcontrol *kctl = NULL;
2925         struct snd_kcontrol_new *knew;
2926         int i, j, err;
2927         unsigned int u;
2928         hda_nid_t nid;
2929
2930         for (i = 0; i < spec->num_mixers; i++) {
2931                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2932                 if (err < 0)
2933                         return err;
2934         }
2935         if (spec->cap_mixer) {
2936                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2937                 if (err < 0)
2938                         return err;
2939         }
2940         if (spec->multiout.dig_out_nid) {
2941                 err = snd_hda_create_spdif_out_ctls(codec,
2942                                                     spec->multiout.dig_out_nid);
2943                 if (err < 0)
2944                         return err;
2945                 if (!spec->no_analog) {
2946                         err = snd_hda_create_spdif_share_sw(codec,
2947                                                             &spec->multiout);
2948                         if (err < 0)
2949                                 return err;
2950                         spec->multiout.share_spdif = 1;
2951                 }
2952         }
2953         if (spec->dig_in_nid) {
2954                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2955                 if (err < 0)
2956                         return err;
2957         }
2958
2959 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2960         /* create beep controls if needed */
2961         if (spec->beep_amp) {
2962                 struct snd_kcontrol_new *knew;
2963                 for (knew = alc_beep_mixer; knew->name; knew++) {
2964                         struct snd_kcontrol *kctl;
2965                         kctl = snd_ctl_new1(knew, codec);
2966                         if (!kctl)
2967                                 return -ENOMEM;
2968                         kctl->private_value = spec->beep_amp;
2969                         err = snd_hda_ctl_add(codec, 0, kctl);
2970                         if (err < 0)
2971                                 return err;
2972                 }
2973         }
2974 #endif
2975
2976         /* if we have no master control, let's create it */
2977         if (!spec->no_analog &&
2978             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2979                 unsigned int vmaster_tlv[4];
2980                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2981                                         HDA_OUTPUT, vmaster_tlv);
2982                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2983                                           vmaster_tlv, alc_slave_vols);
2984                 if (err < 0)
2985                         return err;
2986         }
2987         if (!spec->no_analog &&
2988             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2989                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2990                                           NULL, alc_slave_sws);
2991                 if (err < 0)
2992                         return err;
2993         }
2994
2995         /* assign Capture Source enums to NID */
2996         if (spec->capsrc_nids || spec->adc_nids) {
2997                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2998                 if (!kctl)
2999                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3000                 for (i = 0; kctl && i < kctl->count; i++) {
3001                         hda_nid_t *nids = spec->capsrc_nids;
3002                         if (!nids)
3003                                 nids = spec->adc_nids;
3004                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3005                         if (err < 0)
3006                                 return err;
3007                 }
3008         }
3009         if (spec->cap_mixer) {
3010                 const char *kname = kctl ? kctl->id.name : NULL;
3011                 for (knew = spec->cap_mixer; knew->name; knew++) {
3012                         if (kname && strcmp(knew->name, kname) == 0)
3013                                 continue;
3014                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3015                         for (i = 0; kctl && i < kctl->count; i++) {
3016                                 err = snd_hda_add_nid(codec, kctl, i,
3017                                                       spec->adc_nids[i]);
3018                                 if (err < 0)
3019                                         return err;
3020                         }
3021                 }
3022         }
3023
3024         /* other nid->control mapping */
3025         for (i = 0; i < spec->num_mixers; i++) {
3026                 for (knew = spec->mixers[i]; knew->name; knew++) {
3027                         if (knew->iface != NID_MAPPING)
3028                                 continue;
3029                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3030                         if (kctl == NULL)
3031                                 continue;
3032                         u = knew->subdevice;
3033                         for (j = 0; j < 4; j++, u >>= 8) {
3034                                 nid = u & 0x3f;
3035                                 if (nid == 0)
3036                                         continue;
3037                                 switch (u & 0xc0) {
3038                                 case SUBDEV_SPEAKER_:
3039                                         nid = spec->autocfg.speaker_pins[nid];
3040                                         break;
3041                                 case SUBDEV_LINE_:
3042                                         nid = spec->autocfg.line_out_pins[nid];
3043                                         break;
3044                                 case SUBDEV_HP_:
3045                                         nid = spec->autocfg.hp_pins[nid];
3046                                         break;
3047                                 default:
3048                                         continue;
3049                                 }
3050                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3051                                 if (err < 0)
3052                                         return err;
3053                         }
3054                         u = knew->private_value;
3055                         for (j = 0; j < 4; j++, u >>= 8) {
3056                                 nid = u & 0xff;
3057                                 if (nid == 0)
3058                                         continue;
3059                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3060                                 if (err < 0)
3061                                         return err;
3062                         }
3063                 }
3064         }
3065
3066         alc_free_kctls(codec); /* no longer needed */
3067
3068         return 0;
3069 }
3070
3071
3072 /*
3073  * initialize the codec volumes, etc
3074  */
3075
3076 /*
3077  * generic initialization of ADC, input mixers and output mixers
3078  */
3079 static struct hda_verb alc880_volume_init_verbs[] = {
3080         /*
3081          * Unmute ADC0-2 and set the default input to mic-in
3082          */
3083         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3084         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3085         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3086         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3087         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3088         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3089
3090         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3091          * mixer widget
3092          * Note: PASD motherboards uses the Line In 2 as the input for front
3093          * panel mic (mic 2)
3094          */
3095         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3096         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3097         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3098         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3099         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3101         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3102         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3103
3104         /*
3105          * Set up output mixers (0x0c - 0x0f)
3106          */
3107         /* set vol=0 to output mixers */
3108         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3109         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3110         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3111         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3112         /* set up input amps for analog loopback */
3113         /* Amp Indices: DAC = 0, mixer = 1 */
3114         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3115         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3116         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3117         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3118         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3119         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3120         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3121         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3122
3123         { }
3124 };
3125
3126 /*
3127  * 3-stack pin configuration:
3128  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3129  */
3130 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3131         /*
3132          * preset connection lists of input pins
3133          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3134          */
3135         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3136         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3137         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3138
3139         /*
3140          * Set pin mode and muting
3141          */
3142         /* set front pin widgets 0x14 for output */
3143         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3144         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3145         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3146         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3147         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3148         /* Mic2 (as headphone out) for HP output */
3149         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3150         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3151         /* Line In pin widget for input */
3152         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3153         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3154         /* Line2 (as front mic) pin widget for input and vref at 80% */
3155         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3156         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3157         /* CD pin widget for input */
3158         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3159
3160         { }
3161 };
3162
3163 /*
3164  * 5-stack pin configuration:
3165  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3166  * line-in/side = 0x1a, f-mic = 0x1b
3167  */
3168 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3169         /*
3170          * preset connection lists of input pins
3171          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3172          */
3173         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3174         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3175
3176         /*
3177          * Set pin mode and muting
3178          */
3179         /* set pin widgets 0x14-0x17 for output */
3180         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3181         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3182         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3183         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3184         /* unmute pins for output (no gain on this amp) */
3185         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3186         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3187         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3188         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189
3190         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3191         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3192         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3193         /* Mic2 (as headphone out) for HP output */
3194         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3195         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3196         /* Line In pin widget for input */
3197         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3198         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3199         /* Line2 (as front mic) pin widget for input and vref at 80% */
3200         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3201         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3202         /* CD pin widget for input */
3203         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3204
3205         { }
3206 };
3207
3208 /*
3209  * W810 pin configuration:
3210  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3211  */
3212 static struct hda_verb alc880_pin_w810_init_verbs[] = {
3213         /* hphone/speaker input selector: front DAC */
3214         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3215
3216         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3217         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3218         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3219         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3220         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3221         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3222
3223         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3224         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3225
3226         { }
3227 };
3228
3229 /*
3230  * Z71V pin configuration:
3231  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3232  */
3233 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3234         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3235         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3237         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3238
3239         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3240         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3241         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3242         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3243
3244         { }
3245 };
3246
3247 /*
3248  * 6-stack pin configuration:
3249  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3250  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3251  */
3252 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3253         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3254
3255         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3256         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3257         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3258         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3259         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3260         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3261         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3262         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3263
3264         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3265         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3266         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3267         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3268         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3269         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3270         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3271         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3272         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3273
3274         { }
3275 };
3276
3277 /*
3278  * Uniwill pin configuration:
3279  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3280  * line = 0x1a
3281  */
3282 static struct hda_verb alc880_uniwill_init_verbs[] = {
3283         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3284
3285         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3286         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3287         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3288         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3289         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3290         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3291         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3292         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3293         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3294         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3295         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3296         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3297         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3298         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3299
3300         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3301         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3302         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3303         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3304         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3305         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3306         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3307         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3308         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3309
3310         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3311         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3312
3313         { }
3314 };
3315
3316 /*
3317 * Uniwill P53
3318 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3319  */
3320 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3321         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3322
3323         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3324         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3325         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3326         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3327         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3328         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3329         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3330         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3331         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3332         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3333         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3334         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3335
3336         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3337         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3338         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3339         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3340         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3341         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3342
3343         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3344         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3345
3346         { }
3347 };
3348
3349 static struct hda_verb alc880_beep_init_verbs[] = {
3350         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3351         { }
3352 };
3353
3354 /* auto-toggle front mic */
3355 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3356 {
3357         unsigned int present;
3358         unsigned char bits;
3359
3360         present = snd_hda_jack_detect(codec, 0x18);
3361         bits = present ? HDA_AMP_MUTE : 0;
3362         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3363 }
3364
3365 static void alc880_uniwill_setup(struct hda_codec *codec)
3366 {
3367         struct alc_spec *spec = codec->spec;
3368
3369         spec->autocfg.hp_pins[0] = 0x14;
3370         spec->autocfg.speaker_pins[0] = 0x15;
3371         spec->autocfg.speaker_pins[0] = 0x16;
3372 }
3373
3374 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3375 {
3376         alc_automute_amp(codec);
3377         alc88x_simple_mic_automute(codec);
3378 }
3379
3380 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3381                                        unsigned int res)
3382 {
3383         /* Looks like the unsol event is incompatible with the standard
3384          * definition.  4bit tag is placed at 28 bit!
3385          */
3386         switch (res >> 28) {
3387         case ALC880_MIC_EVENT:
3388                 alc88x_simple_mic_automute(codec);
3389                 break;
3390         default:
3391                 alc_automute_amp_unsol_event(codec, res);
3392                 break;
3393         }
3394 }
3395
3396 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3397 {
3398         struct alc_spec *spec = codec->spec;
3399
3400         spec->autocfg.hp_pins[0] = 0x14;
3401         spec->autocfg.speaker_pins[0] = 0x15;
3402 }
3403
3404 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3405 {
3406         unsigned int present;
3407
3408         present = snd_hda_codec_read(codec, 0x21, 0,
3409                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3410         present &= HDA_AMP_VOLMASK;
3411         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3412                                  HDA_AMP_VOLMASK, present);
3413         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3414                                  HDA_AMP_VOLMASK, present);
3415 }
3416
3417 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3418                                            unsigned int res)
3419 {
3420         /* Looks like the unsol event is incompatible with the standard
3421          * definition.  4bit tag is placed at 28 bit!
3422          */
3423         if ((res >> 28) == ALC880_DCVOL_EVENT)
3424                 alc880_uniwill_p53_dcvol_automute(codec);
3425         else
3426                 alc_automute_amp_unsol_event(codec, res);
3427 }
3428
3429 /*
3430  * F1734 pin configuration:
3431  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3432  */
3433 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3434         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3435         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3436         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3437         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3438         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3439
3440         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3441         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3442         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3443         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3444
3445         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3446         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3447         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3448         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3449         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3450         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3451         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3452         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3453         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3454
3455         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3456         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3457
3458         { }
3459 };
3460
3461 /*
3462  * ASUS pin configuration:
3463  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3464  */
3465 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3466         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3467         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3468         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3469         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3470
3471         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3472         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3473         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3474         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3476         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3477         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3478         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3479
3480         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3481         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3482         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3483         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3484         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3485         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3486         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3487         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3488         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3489
3490         { }
3491 };
3492
3493 /* Enable GPIO mask and set output */
3494 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3495 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3496 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3497
3498 /* Clevo m520g init */
3499 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3500         /* headphone output */
3501         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3502         /* line-out */
3503         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3504         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3505         /* Line-in */
3506         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3507         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3508         /* CD */
3509         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3510         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3511         /* Mic1 (rear panel) */
3512         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3513         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3514         /* Mic2 (front panel) */
3515         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3516         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3517         /* headphone */
3518         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3519         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3520         /* change to EAPD mode */
3521         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3522         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3523
3524         { }
3525 };
3526
3527 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3528         /* change to EAPD mode */
3529         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3530         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3531
3532         /* Headphone output */
3533         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3534         /* Front output*/
3535         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3536         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3537
3538         /* Line In pin widget for input */
3539         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3540         /* CD pin widget for input */
3541         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3542         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3543         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3544
3545         /* change to EAPD mode */
3546         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3547         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3548
3549         { }
3550 };
3551
3552 /*
3553  * LG m1 express dual
3554  *
3555  * Pin assignment:
3556  *   Rear Line-In/Out (blue): 0x14
3557  *   Build-in Mic-In: 0x15
3558  *   Speaker-out: 0x17
3559  *   HP-Out (green): 0x1b
3560  *   Mic-In/Out (red): 0x19
3561  *   SPDIF-Out: 0x1e
3562  */
3563
3564 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3565 static hda_nid_t alc880_lg_dac_nids[3] = {
3566         0x05, 0x02, 0x03
3567 };
3568
3569 /* seems analog CD is not working */
3570 static struct hda_input_mux alc880_lg_capture_source = {
3571         .num_items = 3,
3572         .items = {
3573                 { "Mic", 0x1 },
3574                 { "Line", 0x5 },
3575                 { "Internal Mic", 0x6 },
3576         },
3577 };
3578
3579 /* 2,4,6 channel modes */
3580 static struct hda_verb alc880_lg_ch2_init[] = {
3581         /* set line-in and mic-in to input */
3582         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3583         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3584         { }
3585 };
3586
3587 static struct hda_verb alc880_lg_ch4_init[] = {
3588         /* set line-in to out and mic-in to input */
3589         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3590         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3591         { }
3592 };
3593
3594 static struct hda_verb alc880_lg_ch6_init[] = {
3595         /* set line-in and mic-in to output */
3596         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3597         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3598         { }
3599 };
3600
3601 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3602         { 2, alc880_lg_ch2_init },
3603         { 4, alc880_lg_ch4_init },
3604         { 6, alc880_lg_ch6_init },
3605 };
3606
3607 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3608         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3609         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3610         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3611         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3612         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3613         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3614         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3615         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3616         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3617         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3618         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3619         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3620         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3621         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3622         {
3623                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3624                 .name = "Channel Mode",
3625                 .info = alc_ch_mode_info,
3626                 .get = alc_ch_mode_get,
3627                 .put = alc_ch_mode_put,
3628         },
3629         { } /* end */
3630 };
3631
3632 static struct hda_verb alc880_lg_init_verbs[] = {
3633         /* set capture source to mic-in */
3634         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3635         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3636         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3637         /* mute all amp mixer inputs */
3638         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3639         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3641         /* line-in to input */
3642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3643         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3644         /* built-in mic */
3645         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3646         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3647         /* speaker-out */
3648         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3649         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3650         /* mic-in to input */
3651         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3652         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3653         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3654         /* HP-out */
3655         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3656         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3657         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3658         /* jack sense */
3659         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3660         { }
3661 };
3662
3663 /* toggle speaker-output according to the hp-jack state */
3664 static void alc880_lg_setup(struct hda_codec *codec)
3665 {
3666         struct alc_spec *spec = codec->spec;
3667
3668         spec->autocfg.hp_pins[0] = 0x1b;
3669         spec->autocfg.speaker_pins[0] = 0x17;
3670 }
3671
3672 /*
3673  * LG LW20
3674  *
3675  * Pin assignment:
3676  *   Speaker-out: 0x14
3677  *   Mic-In: 0x18
3678  *   Built-in Mic-In: 0x19
3679  *   Line-In: 0x1b
3680  *   HP-Out: 0x1a
3681  *   SPDIF-Out: 0x1e
3682  */
3683
3684 static struct hda_input_mux alc880_lg_lw_capture_source = {
3685         .num_items = 3,
3686         .items = {
3687                 { "Mic", 0x0 },
3688                 { "Internal Mic", 0x1 },
3689                 { "Line In", 0x2 },
3690         },
3691 };
3692
3693 #define alc880_lg_lw_modes alc880_threestack_modes
3694
3695 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3696         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3697         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3698         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3699         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3700         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3701         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3702         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3703         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3704         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3705         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3706         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3707         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3708         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3709         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3710         {
3711                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3712                 .name = "Channel Mode",
3713                 .info = alc_ch_mode_info,
3714                 .get = alc_ch_mode_get,
3715                 .put = alc_ch_mode_put,
3716         },
3717         { } /* end */
3718 };
3719
3720 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3721         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3722         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3723         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3724
3725         /* set capture source to mic-in */
3726         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3727         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3728         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3729         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3730         /* speaker-out */
3731         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3732         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3733         /* HP-out */
3734         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3735         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3736         /* mic-in to input */
3737         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3738         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3739         /* built-in mic */
3740         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3741         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3742         /* jack sense */
3743         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3744         { }
3745 };
3746
3747 /* toggle speaker-output according to the hp-jack state */
3748 static void alc880_lg_lw_setup(struct hda_codec *codec)
3749 {
3750         struct alc_spec *spec = codec->spec;
3751
3752         spec->autocfg.hp_pins[0] = 0x1b;
3753         spec->autocfg.speaker_pins[0] = 0x14;
3754 }
3755
3756 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3757         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3758         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3759         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3760         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3761         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3762         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3763         { } /* end */
3764 };
3765
3766 static struct hda_input_mux alc880_medion_rim_capture_source = {
3767         .num_items = 2,
3768         .items = {
3769                 { "Mic", 0x0 },
3770                 { "Internal Mic", 0x1 },
3771         },
3772 };
3773
3774 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3775         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3776
3777         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3778         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3779
3780         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3781         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3782         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3783         /* Mic2 (as headphone out) for HP output */
3784         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3785         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3786         /* Internal Speaker */
3787         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3788         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3789
3790         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3791         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3792
3793         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3794         { }
3795 };
3796
3797 /* toggle speaker-output according to the hp-jack state */
3798 static void alc880_medion_rim_automute(struct hda_codec *codec)
3799 {
3800         struct alc_spec *spec = codec->spec;
3801         alc_automute_amp(codec);
3802         /* toggle EAPD */
3803         if (spec->jack_present)
3804                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3805         else
3806                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3807 }
3808
3809 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3810                                           unsigned int res)
3811 {
3812         /* Looks like the unsol event is incompatible with the standard
3813          * definition.  4bit tag is placed at 28 bit!
3814          */
3815         if ((res >> 28) == ALC880_HP_EVENT)
3816                 alc880_medion_rim_automute(codec);
3817 }
3818
3819 static void alc880_medion_rim_setup(struct hda_codec *codec)
3820 {
3821         struct alc_spec *spec = codec->spec;
3822
3823         spec->autocfg.hp_pins[0] = 0x14;
3824         spec->autocfg.speaker_pins[0] = 0x1b;
3825 }
3826
3827 #ifdef CONFIG_SND_HDA_POWER_SAVE
3828 static struct hda_amp_list alc880_loopbacks[] = {
3829         { 0x0b, HDA_INPUT, 0 },
3830         { 0x0b, HDA_INPUT, 1 },
3831         { 0x0b, HDA_INPUT, 2 },
3832         { 0x0b, HDA_INPUT, 3 },
3833         { 0x0b, HDA_INPUT, 4 },
3834         { } /* end */
3835 };
3836
3837 static struct hda_amp_list alc880_lg_loopbacks[] = {
3838         { 0x0b, HDA_INPUT, 1 },
3839         { 0x0b, HDA_INPUT, 6 },
3840         { 0x0b, HDA_INPUT, 7 },
3841         { } /* end */
3842 };
3843 #endif
3844
3845 /*
3846  * Common callbacks
3847  */
3848
3849 static int alc_init(struct hda_codec *codec)
3850 {
3851         struct alc_spec *spec = codec->spec;
3852         unsigned int i;
3853
3854         alc_fix_pll(codec);
3855         alc_auto_init_amp(codec, spec->init_amp);
3856
3857         for (i = 0; i < spec->num_init_verbs; i++)
3858                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3859
3860         if (spec->init_hook)
3861                 spec->init_hook(codec);
3862
3863         hda_call_check_power_status(codec, 0x01);
3864         return 0;
3865 }
3866
3867 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3868 {
3869         struct alc_spec *spec = codec->spec;
3870
3871         if (spec->unsol_event)
3872                 spec->unsol_event(codec, res);
3873 }
3874
3875 #ifdef CONFIG_SND_HDA_POWER_SAVE
3876 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3877 {
3878         struct alc_spec *spec = codec->spec;
3879         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3880 }
3881 #endif
3882
3883 /*
3884  * Analog playback callbacks
3885  */
3886 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3887                                     struct hda_codec *codec,
3888                                     struct snd_pcm_substream *substream)
3889 {
3890         struct alc_spec *spec = codec->spec;
3891         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3892                                              hinfo);
3893 }
3894
3895 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3896                                        struct hda_codec *codec,
3897                                        unsigned int stream_tag,
3898                                        unsigned int format,
3899                                        struct snd_pcm_substream *substream)
3900 {
3901         struct alc_spec *spec = codec->spec;
3902         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3903                                                 stream_tag, format, substream);
3904 }
3905
3906 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3907                                        struct hda_codec *codec,
3908                                        struct snd_pcm_substream *substream)
3909 {
3910         struct alc_spec *spec = codec->spec;
3911         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3912 }
3913
3914 /*
3915  * Digital out
3916  */
3917 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3918                                         struct hda_codec *codec,
3919                                         struct snd_pcm_substream *substream)
3920 {
3921         struct alc_spec *spec = codec->spec;
3922         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3923 }
3924
3925 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3926                                            struct hda_codec *codec,
3927                                            unsigned int stream_tag,
3928                                            unsigned int format,
3929                                            struct snd_pcm_substream *substream)
3930 {
3931         struct alc_spec *spec = codec->spec;
3932         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3933                                              stream_tag, format, substream);
3934 }
3935
3936 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3937                                            struct hda_codec *codec,
3938                                            struct snd_pcm_substream *substream)
3939 {
3940         struct alc_spec *spec = codec->spec;
3941         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3942 }
3943
3944 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3945                                          struct hda_codec *codec,
3946                                          struct snd_pcm_substream *substream)
3947 {
3948         struct alc_spec *spec = codec->spec;
3949         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3950 }
3951
3952 /*
3953  * Analog capture
3954  */
3955 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3956                                       struct hda_codec *codec,
3957                                       unsigned int stream_tag,
3958                                       unsigned int format,
3959                                       struct snd_pcm_substream *substream)
3960 {
3961         struct alc_spec *spec = codec->spec;
3962
3963         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3964                                    stream_tag, 0, format);
3965         return 0;
3966 }
3967
3968 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3969                                       struct hda_codec *codec,
3970                                       struct snd_pcm_substream *substream)
3971 {
3972         struct alc_spec *spec = codec->spec;
3973
3974         snd_hda_codec_cleanup_stream(codec,
3975                                      spec->adc_nids[substream->number + 1]);
3976         return 0;
3977 }
3978
3979 /* analog capture with dynamic dual-adc changes */
3980 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3981                                        struct hda_codec *codec,
3982                                        unsigned int stream_tag,
3983                                        unsigned int format,
3984                                        struct snd_pcm_substream *substream)
3985 {
3986         struct alc_spec *spec = codec->spec;
3987         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3988         spec->cur_adc_stream_tag = stream_tag;
3989         spec->cur_adc_format = format;
3990         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3991         return 0;
3992 }
3993
3994 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3995                                        struct hda_codec *codec,
3996                                        struct snd_pcm_substream *substream)
3997 {
3998         struct alc_spec *spec = codec->spec;
3999         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4000         spec->cur_adc = 0;
4001         return 0;
4002 }
4003
4004 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
4005         .substreams = 1,
4006         .channels_min = 2,
4007         .channels_max = 2,
4008         .nid = 0, /* fill later */
4009         .ops = {
4010                 .prepare = dualmic_capture_pcm_prepare,
4011                 .cleanup = dualmic_capture_pcm_cleanup
4012         },
4013 };
4014
4015 /*
4016  */
4017 static struct hda_pcm_stream alc880_pcm_analog_playback = {
4018         .substreams = 1,
4019         .channels_min = 2,
4020         .channels_max = 8,
4021         /* NID is set in alc_build_pcms */
4022         .ops = {
4023                 .open = alc880_playback_pcm_open,
4024                 .prepare = alc880_playback_pcm_prepare,
4025                 .cleanup = alc880_playback_pcm_cleanup
4026         },
4027 };
4028
4029 static struct hda_pcm_stream alc880_pcm_analog_capture = {
4030         .substreams = 1,
4031         .channels_min = 2,
4032         .channels_max = 2,
4033         /* NID is set in alc_build_pcms */
4034 };
4035
4036 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4037         .substreams = 1,
4038         .channels_min = 2,
4039         .channels_max = 2,
4040         /* NID is set in alc_build_pcms */
4041 };
4042
4043 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4044         .substreams = 2, /* can be overridden */
4045         .channels_min = 2,
4046         .channels_max = 2,
4047         /* NID is set in alc_build_pcms */
4048         .ops = {
4049                 .prepare = alc880_alt_capture_pcm_prepare,
4050                 .cleanup = alc880_alt_capture_pcm_cleanup
4051         },
4052 };
4053
4054 static struct hda_pcm_stream alc880_pcm_digital_playback = {
4055         .substreams = 1,
4056         .channels_min = 2,
4057         .channels_max = 2,
4058         /* NID is set in alc_build_pcms */
4059         .ops = {
4060                 .open = alc880_dig_playback_pcm_open,
4061                 .close = alc880_dig_playback_pcm_close,
4062                 .prepare = alc880_dig_playback_pcm_prepare,
4063                 .cleanup = alc880_dig_playback_pcm_cleanup
4064         },
4065 };
4066
4067 static struct hda_pcm_stream alc880_pcm_digital_capture = {
4068         .substreams = 1,
4069         .channels_min = 2,
4070         .channels_max = 2,
4071         /* NID is set in alc_build_pcms */
4072 };
4073
4074 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4075 static struct hda_pcm_stream alc_pcm_null_stream = {
4076         .substreams = 0,
4077         .channels_min = 0,
4078         .channels_max = 0,
4079 };
4080
4081 static int alc_build_pcms(struct hda_codec *codec)
4082 {
4083         struct alc_spec *spec = codec->spec;
4084         struct hda_pcm *info = spec->pcm_rec;
4085         int i;
4086
4087         codec->num_pcms = 1;
4088         codec->pcm_info = info;
4089
4090         if (spec->no_analog)
4091                 goto skip_analog;
4092
4093         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4094                  "%s Analog", codec->chip_name);
4095         info->name = spec->stream_name_analog;
4096
4097         if (spec->stream_analog_playback) {
4098                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4099                         return -EINVAL;
4100                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4101                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4102         }
4103         if (spec->stream_analog_capture) {
4104                 if (snd_BUG_ON(!spec->adc_nids))
4105                         return -EINVAL;
4106                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4107                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4108         }
4109
4110         if (spec->channel_mode) {
4111                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4112                 for (i = 0; i < spec->num_channel_mode; i++) {
4113                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4114                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4115                         }
4116                 }
4117         }
4118
4119  skip_analog:
4120         /* SPDIF for stream index #1 */
4121         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4122                 snprintf(spec->stream_name_digital,
4123                          sizeof(spec->stream_name_digital),
4124                          "%s Digital", codec->chip_name);
4125                 codec->num_pcms = 2;
4126                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4127                 info = spec->pcm_rec + 1;
4128                 info->name = spec->stream_name_digital;
4129                 if (spec->dig_out_type)
4130                         info->pcm_type = spec->dig_out_type;
4131                 else
4132                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4133                 if (spec->multiout.dig_out_nid &&
4134                     spec->stream_digital_playback) {
4135                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4136                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4137                 }
4138                 if (spec->dig_in_nid &&
4139                     spec->stream_digital_capture) {
4140                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4141                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4142                 }
4143                 /* FIXME: do we need this for all Realtek codec models? */
4144                 codec->spdif_status_reset = 1;
4145         }
4146
4147         if (spec->no_analog)
4148                 return 0;
4149
4150         /* If the use of more than one ADC is requested for the current
4151          * model, configure a second analog capture-only PCM.
4152          */
4153         /* Additional Analaog capture for index #2 */
4154         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4155             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4156                 codec->num_pcms = 3;
4157                 info = spec->pcm_rec + 2;
4158                 info->name = spec->stream_name_analog;
4159                 if (spec->alt_dac_nid) {
4160                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4161                                 *spec->stream_analog_alt_playback;
4162                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4163                                 spec->alt_dac_nid;
4164                 } else {
4165                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4166                                 alc_pcm_null_stream;
4167                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4168                 }
4169                 if (spec->num_adc_nids > 1) {
4170                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4171                                 *spec->stream_analog_alt_capture;
4172                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4173                                 spec->adc_nids[1];
4174                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4175                                 spec->num_adc_nids - 1;
4176                 } else {
4177                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4178                                 alc_pcm_null_stream;
4179                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4180                 }
4181         }
4182
4183         return 0;
4184 }
4185
4186 static inline void alc_shutup(struct hda_codec *codec)
4187 {
4188         snd_hda_shutup_pins(codec);
4189 }
4190
4191 static void alc_free_kctls(struct hda_codec *codec)
4192 {
4193         struct alc_spec *spec = codec->spec;
4194
4195         if (spec->kctls.list) {
4196                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4197                 int i;
4198                 for (i = 0; i < spec->kctls.used; i++)
4199                         kfree(kctl[i].name);
4200         }
4201         snd_array_free(&spec->kctls);
4202 }
4203
4204 static void alc_free(struct hda_codec *codec)
4205 {
4206         struct alc_spec *spec = codec->spec;
4207
4208         if (!spec)
4209                 return;
4210
4211         alc_shutup(codec);
4212         alc_free_kctls(codec);
4213         kfree(spec);
4214         snd_hda_detach_beep_device(codec);
4215 }
4216
4217 #ifdef CONFIG_SND_HDA_POWER_SAVE
4218 static void alc_power_eapd(struct hda_codec *codec)
4219 {
4220         /* We currently only handle front, HP */
4221         switch (codec->vendor_id) {
4222         case 0x10ec0260:
4223                 set_eapd(codec, 0x0f, 0);
4224                 set_eapd(codec, 0x10, 0);
4225                 break;
4226         case 0x10ec0262:
4227         case 0x10ec0267:
4228         case 0x10ec0268:
4229         case 0x10ec0269:
4230         case 0x10ec0270:
4231         case 0x10ec0272:
4232         case 0x10ec0660:
4233         case 0x10ec0662:
4234         case 0x10ec0663:
4235         case 0x10ec0862:
4236         case 0x10ec0889:
4237                 set_eapd(codec, 0x14, 0);
4238                 set_eapd(codec, 0x15, 0);
4239                 break;
4240         }
4241 }
4242
4243 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4244 {
4245         struct alc_spec *spec = codec->spec;
4246         alc_shutup(codec);
4247         if (spec && spec->power_hook)
4248                 spec->power_hook(codec);
4249         return 0;
4250 }
4251 #endif
4252
4253 #ifdef SND_HDA_NEEDS_RESUME
4254 static int alc_resume(struct hda_codec *codec)
4255 {
4256         codec->patch_ops.init(codec);
4257         snd_hda_codec_resume_amp(codec);
4258         snd_hda_codec_resume_cache(codec);
4259         hda_call_check_power_status(codec, 0x01);
4260         return 0;
4261 }
4262 #endif
4263
4264 /*
4265  */
4266 static struct hda_codec_ops alc_patch_ops = {
4267         .build_controls = alc_build_controls,
4268         .build_pcms = alc_build_pcms,
4269         .init = alc_init,
4270         .free = alc_free,
4271         .unsol_event = alc_unsol_event,
4272 #ifdef SND_HDA_NEEDS_RESUME
4273         .resume = alc_resume,
4274 #endif
4275 #ifdef CONFIG_SND_HDA_POWER_SAVE
4276         .suspend = alc_suspend,
4277         .check_power_status = alc_check_power_status,
4278 #endif
4279         .reboot_notify = alc_shutup,
4280 };
4281
4282 /* replace the codec chip_name with the given string */
4283 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4284 {
4285         kfree(codec->chip_name);
4286         codec->chip_name = kstrdup(name, GFP_KERNEL);
4287         if (!codec->chip_name) {
4288                 alc_free(codec);
4289                 return -ENOMEM;
4290         }
4291         return 0;
4292 }
4293
4294 /*
4295  * Test configuration for debugging
4296  *
4297  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4298  * enum controls.
4299  */
4300 #ifdef CONFIG_SND_DEBUG
4301 static hda_nid_t alc880_test_dac_nids[4] = {
4302         0x02, 0x03, 0x04, 0x05
4303 };
4304
4305 static struct hda_input_mux alc880_test_capture_source = {
4306         .num_items = 7,
4307         .items = {
4308                 { "In-1", 0x0 },
4309                 { "In-2", 0x1 },
4310                 { "In-3", 0x2 },
4311                 { "In-4", 0x3 },
4312                 { "CD", 0x4 },
4313                 { "Front", 0x5 },
4314                 { "Surround", 0x6 },
4315         },
4316 };
4317
4318 static struct hda_channel_mode alc880_test_modes[4] = {
4319         { 2, NULL },
4320         { 4, NULL },
4321         { 6, NULL },
4322         { 8, NULL },
4323 };
4324
4325 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4326                                  struct snd_ctl_elem_info *uinfo)
4327 {
4328         static char *texts[] = {
4329                 "N/A", "Line Out", "HP Out",
4330                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4331         };
4332         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4333         uinfo->count = 1;
4334         uinfo->value.enumerated.items = 8;
4335         if (uinfo->value.enumerated.item >= 8)
4336                 uinfo->value.enumerated.item = 7;
4337         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4338         return 0;
4339 }
4340
4341 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4342                                 struct snd_ctl_elem_value *ucontrol)
4343 {
4344         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4345         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4346         unsigned int pin_ctl, item = 0;
4347
4348         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4349                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4350         if (pin_ctl & AC_PINCTL_OUT_EN) {
4351                 if (pin_ctl & AC_PINCTL_HP_EN)
4352                         item = 2;
4353                 else
4354                         item = 1;
4355         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4356                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4357                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4358                 case AC_PINCTL_VREF_50:  item = 4; break;
4359                 case AC_PINCTL_VREF_GRD: item = 5; break;
4360                 case AC_PINCTL_VREF_80:  item = 6; break;
4361                 case AC_PINCTL_VREF_100: item = 7; break;
4362                 }
4363         }
4364         ucontrol->value.enumerated.item[0] = item;
4365         return 0;
4366 }
4367
4368 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4369                                 struct snd_ctl_elem_value *ucontrol)
4370 {
4371         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4372         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4373         static unsigned int ctls[] = {
4374                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4375                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4376                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4377                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4378                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4379                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4380         };
4381         unsigned int old_ctl, new_ctl;
4382
4383         old_ctl = snd_hda_codec_read(codec, nid, 0,
4384                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4385         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4386         if (old_ctl != new_ctl) {
4387                 int val;
4388                 snd_hda_codec_write_cache(codec, nid, 0,
4389                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4390                                           new_ctl);
4391                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4392                         HDA_AMP_MUTE : 0;
4393                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4394                                          HDA_AMP_MUTE, val);
4395                 return 1;
4396         }
4397         return 0;
4398 }
4399
4400 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4401                                  struct snd_ctl_elem_info *uinfo)
4402 {
4403         static char *texts[] = {
4404                 "Front", "Surround", "CLFE", "Side"
4405         };
4406         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4407         uinfo->count = 1;
4408         uinfo->value.enumerated.items = 4;
4409         if (uinfo->value.enumerated.item >= 4)
4410                 uinfo->value.enumerated.item = 3;
4411         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4412         return 0;
4413 }
4414
4415 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4416                                 struct snd_ctl_elem_value *ucontrol)
4417 {
4418         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4419         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4420         unsigned int sel;
4421
4422         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4423         ucontrol->value.enumerated.item[0] = sel & 3;
4424         return 0;
4425 }
4426
4427 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4428                                 struct snd_ctl_elem_value *ucontrol)
4429 {
4430         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4431         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4432         unsigned int sel;
4433
4434         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4435         if (ucontrol->value.enumerated.item[0] != sel) {
4436                 sel = ucontrol->value.enumerated.item[0] & 3;
4437                 snd_hda_codec_write_cache(codec, nid, 0,
4438                                           AC_VERB_SET_CONNECT_SEL, sel);
4439                 return 1;
4440         }
4441         return 0;
4442 }
4443
4444 #define PIN_CTL_TEST(xname,nid) {                       \
4445                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4446                         .name = xname,                 \
4447                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4448                         .info = alc_test_pin_ctl_info, \
4449                         .get = alc_test_pin_ctl_get,   \
4450                         .put = alc_test_pin_ctl_put,   \
4451                         .private_value = nid           \
4452                         }
4453
4454 #define PIN_SRC_TEST(xname,nid) {                       \
4455                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4456                         .name = xname,                 \
4457                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4458                         .info = alc_test_pin_src_info, \
4459                         .get = alc_test_pin_src_get,   \
4460                         .put = alc_test_pin_src_put,   \
4461                         .private_value = nid           \
4462                         }
4463
4464 static struct snd_kcontrol_new alc880_test_mixer[] = {
4465         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4466         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4467         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4468         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4469         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4470         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4471         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4472         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4473         PIN_CTL_TEST("Front Pin Mode", 0x14),
4474         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4475         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4476         PIN_CTL_TEST("Side Pin Mode", 0x17),
4477         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4478         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4479         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4480         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4481         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4482         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4483         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4484         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4485         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4486         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4487         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4488         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4489         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4490         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4491         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4492         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4493         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4494         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4495         {
4496                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4497                 .name = "Channel Mode",
4498                 .info = alc_ch_mode_info,
4499                 .get = alc_ch_mode_get,
4500                 .put = alc_ch_mode_put,
4501         },
4502         { } /* end */
4503 };
4504
4505 static struct hda_verb alc880_test_init_verbs[] = {
4506         /* Unmute inputs of 0x0c - 0x0f */
4507         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4510         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4511         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4512         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4513         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4514         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4515         /* Vol output for 0x0c-0x0f */
4516         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4517         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4518         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4519         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4520         /* Set output pins 0x14-0x17 */
4521         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4522         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4523         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4524         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4525         /* Unmute output pins 0x14-0x17 */
4526         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4527         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4528         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4529         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4530         /* Set input pins 0x18-0x1c */
4531         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4532         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4533         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4534         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4535         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4536         /* Mute input pins 0x18-0x1b */
4537         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4538         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4539         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4540         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4541         /* ADC set up */
4542         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4543         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4544         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4545         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4546         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4547         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4548         /* Analog input/passthru */
4549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4551         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4552         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4553         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4554         { }
4555 };
4556 #endif
4557
4558 /*
4559  */
4560
4561 static const char *alc880_models[ALC880_MODEL_LAST] = {
4562         [ALC880_3ST]            = "3stack",
4563         [ALC880_TCL_S700]       = "tcl",
4564         [ALC880_3ST_DIG]        = "3stack-digout",
4565         [ALC880_CLEVO]          = "clevo",
4566         [ALC880_5ST]            = "5stack",
4567         [ALC880_5ST_DIG]        = "5stack-digout",
4568         [ALC880_W810]           = "w810",
4569         [ALC880_Z71V]           = "z71v",
4570         [ALC880_6ST]            = "6stack",
4571         [ALC880_6ST_DIG]        = "6stack-digout",
4572         [ALC880_ASUS]           = "asus",
4573         [ALC880_ASUS_W1V]       = "asus-w1v",
4574         [ALC880_ASUS_DIG]       = "asus-dig",
4575         [ALC880_ASUS_DIG2]      = "asus-dig2",
4576         [ALC880_UNIWILL_DIG]    = "uniwill",
4577         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4578         [ALC880_FUJITSU]        = "fujitsu",
4579         [ALC880_F1734]          = "F1734",
4580         [ALC880_LG]             = "lg",
4581         [ALC880_LG_LW]          = "lg-lw",
4582         [ALC880_MEDION_RIM]     = "medion",
4583 #ifdef CONFIG_SND_DEBUG
4584         [ALC880_TEST]           = "test",
4585 #endif
4586         [ALC880_AUTO]           = "auto",
4587 };
4588
4589 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4590         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4591         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4592         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4593         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4594         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4595         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4596         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4597         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4598         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4599         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4600         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4601         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4602         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4603         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4604         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4605         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4606         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4607         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4608         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4609         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4610         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4611         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4612         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4613         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4614         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4615         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4616         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4617         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4618         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4619         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4620         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4621         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4622         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4623         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4624         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4625         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4626         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4627         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4628         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4629         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4630         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4631         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4632         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4633         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4634         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4635         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4636         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4637         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4638         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4639         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4640         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4641         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4642         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4643         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4644         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4645         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4646         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4647         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4648         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4649         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4650         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4651         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4652         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4653         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4654         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4655         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4656         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4657         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4658         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4659         /* default Intel */
4660         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4661         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4662         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4663         {}
4664 };
4665
4666 /*
4667  * ALC880 codec presets
4668  */
4669 static struct alc_config_preset alc880_presets[] = {
4670         [ALC880_3ST] = {
4671                 .mixers = { alc880_three_stack_mixer },
4672                 .init_verbs = { alc880_volume_init_verbs,
4673                                 alc880_pin_3stack_init_verbs },
4674                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4675                 .dac_nids = alc880_dac_nids,
4676                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4677                 .channel_mode = alc880_threestack_modes,
4678                 .need_dac_fix = 1,
4679                 .input_mux = &alc880_capture_source,
4680         },
4681         [ALC880_3ST_DIG] = {
4682                 .mixers = { alc880_three_stack_mixer },
4683                 .init_verbs = { alc880_volume_init_verbs,
4684                                 alc880_pin_3stack_init_verbs },
4685                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4686                 .dac_nids = alc880_dac_nids,
4687                 .dig_out_nid = ALC880_DIGOUT_NID,
4688                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4689                 .channel_mode = alc880_threestack_modes,
4690                 .need_dac_fix = 1,
4691                 .input_mux = &alc880_capture_source,
4692         },
4693         [ALC880_TCL_S700] = {
4694                 .mixers = { alc880_tcl_s700_mixer },
4695                 .init_verbs = { alc880_volume_init_verbs,
4696                                 alc880_pin_tcl_S700_init_verbs,
4697                                 alc880_gpio2_init_verbs },
4698                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4699                 .dac_nids = alc880_dac_nids,
4700                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4701                 .num_adc_nids = 1, /* single ADC */
4702                 .hp_nid = 0x03,
4703                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4704                 .channel_mode = alc880_2_jack_modes,
4705                 .input_mux = &alc880_capture_source,
4706         },
4707         [ALC880_5ST] = {
4708                 .mixers = { alc880_three_stack_mixer,
4709                             alc880_five_stack_mixer},
4710                 .init_verbs = { alc880_volume_init_verbs,
4711                                 alc880_pin_5stack_init_verbs },
4712                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4713                 .dac_nids = alc880_dac_nids,
4714                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4715                 .channel_mode = alc880_fivestack_modes,
4716                 .input_mux = &alc880_capture_source,
4717         },
4718         [ALC880_5ST_DIG] = {
4719                 .mixers = { alc880_three_stack_mixer,
4720                             alc880_five_stack_mixer },
4721                 .init_verbs = { alc880_volume_init_verbs,
4722                                 alc880_pin_5stack_init_verbs },
4723                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4724                 .dac_nids = alc880_dac_nids,
4725                 .dig_out_nid = ALC880_DIGOUT_NID,
4726                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4727                 .channel_mode = alc880_fivestack_modes,
4728                 .input_mux = &alc880_capture_source,
4729         },
4730         [ALC880_6ST] = {
4731                 .mixers = { alc880_six_stack_mixer },
4732                 .init_verbs = { alc880_volume_init_verbs,
4733                                 alc880_pin_6stack_init_verbs },
4734                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4735                 .dac_nids = alc880_6st_dac_nids,
4736                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4737                 .channel_mode = alc880_sixstack_modes,
4738                 .input_mux = &alc880_6stack_capture_source,
4739         },
4740         [ALC880_6ST_DIG] = {
4741                 .mixers = { alc880_six_stack_mixer },
4742                 .init_verbs = { alc880_volume_init_verbs,
4743                                 alc880_pin_6stack_init_verbs },
4744                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4745                 .dac_nids = alc880_6st_dac_nids,
4746                 .dig_out_nid = ALC880_DIGOUT_NID,
4747                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4748                 .channel_mode = alc880_sixstack_modes,
4749                 .input_mux = &alc880_6stack_capture_source,
4750         },
4751         [ALC880_W810] = {
4752                 .mixers = { alc880_w810_base_mixer },
4753                 .init_verbs = { alc880_volume_init_verbs,
4754                                 alc880_pin_w810_init_verbs,
4755                                 alc880_gpio2_init_verbs },
4756                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4757                 .dac_nids = alc880_w810_dac_nids,
4758                 .dig_out_nid = ALC880_DIGOUT_NID,
4759                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4760                 .channel_mode = alc880_w810_modes,
4761                 .input_mux = &alc880_capture_source,
4762         },
4763         [ALC880_Z71V] = {
4764                 .mixers = { alc880_z71v_mixer },
4765                 .init_verbs = { alc880_volume_init_verbs,
4766                                 alc880_pin_z71v_init_verbs },
4767                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4768                 .dac_nids = alc880_z71v_dac_nids,
4769                 .dig_out_nid = ALC880_DIGOUT_NID,
4770                 .hp_nid = 0x03,
4771                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4772                 .channel_mode = alc880_2_jack_modes,
4773                 .input_mux = &alc880_capture_source,
4774         },
4775         [ALC880_F1734] = {
4776                 .mixers = { alc880_f1734_mixer },
4777                 .init_verbs = { alc880_volume_init_verbs,
4778                                 alc880_pin_f1734_init_verbs },
4779                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4780                 .dac_nids = alc880_f1734_dac_nids,
4781                 .hp_nid = 0x02,
4782                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4783                 .channel_mode = alc880_2_jack_modes,
4784                 .input_mux = &alc880_f1734_capture_source,
4785                 .unsol_event = alc880_uniwill_p53_unsol_event,
4786                 .setup = alc880_uniwill_p53_setup,
4787                 .init_hook = alc_automute_amp,
4788         },
4789         [ALC880_ASUS] = {
4790                 .mixers = { alc880_asus_mixer },
4791                 .init_verbs = { alc880_volume_init_verbs,
4792                                 alc880_pin_asus_init_verbs,
4793                                 alc880_gpio1_init_verbs },
4794                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4795                 .dac_nids = alc880_asus_dac_nids,
4796                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4797                 .channel_mode = alc880_asus_modes,
4798                 .need_dac_fix = 1,
4799                 .input_mux = &alc880_capture_source,
4800         },
4801         [ALC880_ASUS_DIG] = {
4802                 .mixers = { alc880_asus_mixer },
4803                 .init_verbs = { alc880_volume_init_verbs,
4804                                 alc880_pin_asus_init_verbs,
4805                                 alc880_gpio1_init_verbs },
4806                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4807                 .dac_nids = alc880_asus_dac_nids,
4808                 .dig_out_nid = ALC880_DIGOUT_NID,
4809                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4810                 .channel_mode = alc880_asus_modes,
4811                 .need_dac_fix = 1,
4812                 .input_mux = &alc880_capture_source,
4813         },
4814         [ALC880_ASUS_DIG2] = {
4815                 .mixers = { alc880_asus_mixer },
4816                 .init_verbs = { alc880_volume_init_verbs,
4817                                 alc880_pin_asus_init_verbs,
4818                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4819                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4820                 .dac_nids = alc880_asus_dac_nids,
4821                 .dig_out_nid = ALC880_DIGOUT_NID,
4822                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4823                 .channel_mode = alc880_asus_modes,
4824                 .need_dac_fix = 1,
4825                 .input_mux = &alc880_capture_source,
4826         },
4827         [ALC880_ASUS_W1V] = {
4828                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4829                 .init_verbs = { alc880_volume_init_verbs,
4830                                 alc880_pin_asus_init_verbs,
4831                                 alc880_gpio1_init_verbs },
4832                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4833                 .dac_nids = alc880_asus_dac_nids,
4834                 .dig_out_nid = ALC880_DIGOUT_NID,
4835                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4836                 .channel_mode = alc880_asus_modes,
4837                 .need_dac_fix = 1,
4838                 .input_mux = &alc880_capture_source,
4839         },
4840         [ALC880_UNIWILL_DIG] = {
4841                 .mixers = { alc880_asus_mixer },
4842                 .init_verbs = { alc880_volume_init_verbs,
4843                                 alc880_pin_asus_init_verbs },
4844                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4845                 .dac_nids = alc880_asus_dac_nids,
4846                 .dig_out_nid = ALC880_DIGOUT_NID,
4847                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4848                 .channel_mode = alc880_asus_modes,
4849                 .need_dac_fix = 1,
4850                 .input_mux = &alc880_capture_source,
4851         },
4852         [ALC880_UNIWILL] = {
4853                 .mixers = { alc880_uniwill_mixer },
4854                 .init_verbs = { alc880_volume_init_verbs,
4855                                 alc880_uniwill_init_verbs },
4856                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4857                 .dac_nids = alc880_asus_dac_nids,
4858                 .dig_out_nid = ALC880_DIGOUT_NID,
4859                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4860                 .channel_mode = alc880_threestack_modes,
4861                 .need_dac_fix = 1,
4862                 .input_mux = &alc880_capture_source,
4863                 .unsol_event = alc880_uniwill_unsol_event,
4864                 .setup = alc880_uniwill_setup,
4865                 .init_hook = alc880_uniwill_init_hook,
4866         },
4867         [ALC880_UNIWILL_P53] = {
4868                 .mixers = { alc880_uniwill_p53_mixer },
4869                 .init_verbs = { alc880_volume_init_verbs,
4870                                 alc880_uniwill_p53_init_verbs },
4871                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4872                 .dac_nids = alc880_asus_dac_nids,
4873                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4874                 .channel_mode = alc880_threestack_modes,
4875                 .input_mux = &alc880_capture_source,
4876                 .unsol_event = alc880_uniwill_p53_unsol_event,
4877                 .setup = alc880_uniwill_p53_setup,
4878                 .init_hook = alc_automute_amp,
4879         },
4880         [ALC880_FUJITSU] = {
4881                 .mixers = { alc880_fujitsu_mixer },
4882                 .init_verbs = { alc880_volume_init_verbs,
4883                                 alc880_uniwill_p53_init_verbs,
4884                                 alc880_beep_init_verbs },
4885                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4886                 .dac_nids = alc880_dac_nids,
4887                 .dig_out_nid = ALC880_DIGOUT_NID,
4888                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4889                 .channel_mode = alc880_2_jack_modes,
4890                 .input_mux = &alc880_capture_source,
4891                 .unsol_event = alc880_uniwill_p53_unsol_event,
4892                 .setup = alc880_uniwill_p53_setup,
4893                 .init_hook = alc_automute_amp,
4894         },
4895         [ALC880_CLEVO] = {
4896                 .mixers = { alc880_three_stack_mixer },
4897                 .init_verbs = { alc880_volume_init_verbs,
4898                                 alc880_pin_clevo_init_verbs },
4899                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4900                 .dac_nids = alc880_dac_nids,
4901                 .hp_nid = 0x03,
4902                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4903                 .channel_mode = alc880_threestack_modes,
4904                 .need_dac_fix = 1,
4905                 .input_mux = &alc880_capture_source,
4906         },
4907         [ALC880_LG] = {
4908                 .mixers = { alc880_lg_mixer },
4909                 .init_verbs = { alc880_volume_init_verbs,
4910                                 alc880_lg_init_verbs },
4911                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4912                 .dac_nids = alc880_lg_dac_nids,
4913                 .dig_out_nid = ALC880_DIGOUT_NID,
4914                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4915                 .channel_mode = alc880_lg_ch_modes,
4916                 .need_dac_fix = 1,
4917                 .input_mux = &alc880_lg_capture_source,
4918                 .unsol_event = alc_automute_amp_unsol_event,
4919                 .setup = alc880_lg_setup,
4920                 .init_hook = alc_automute_amp,
4921 #ifdef CONFIG_SND_HDA_POWER_SAVE
4922                 .loopbacks = alc880_lg_loopbacks,
4923 #endif
4924         },
4925         [ALC880_LG_LW] = {
4926                 .mixers = { alc880_lg_lw_mixer },
4927                 .init_verbs = { alc880_volume_init_verbs,
4928                                 alc880_lg_lw_init_verbs },
4929                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4930                 .dac_nids = alc880_dac_nids,
4931                 .dig_out_nid = ALC880_DIGOUT_NID,
4932                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4933                 .channel_mode = alc880_lg_lw_modes,
4934                 .input_mux = &alc880_lg_lw_capture_source,
4935                 .unsol_event = alc_automute_amp_unsol_event,
4936                 .setup = alc880_lg_lw_setup,
4937                 .init_hook = alc_automute_amp,
4938         },
4939         [ALC880_MEDION_RIM] = {
4940                 .mixers = { alc880_medion_rim_mixer },
4941                 .init_verbs = { alc880_volume_init_verbs,
4942                                 alc880_medion_rim_init_verbs,
4943                                 alc_gpio2_init_verbs },
4944                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4945                 .dac_nids = alc880_dac_nids,
4946                 .dig_out_nid = ALC880_DIGOUT_NID,
4947                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4948                 .channel_mode = alc880_2_jack_modes,
4949                 .input_mux = &alc880_medion_rim_capture_source,
4950                 .unsol_event = alc880_medion_rim_unsol_event,
4951                 .setup = alc880_medion_rim_setup,
4952                 .init_hook = alc880_medion_rim_automute,
4953         },
4954 #ifdef CONFIG_SND_DEBUG
4955         [ALC880_TEST] = {
4956                 .mixers = { alc880_test_mixer },
4957                 .init_verbs = { alc880_test_init_verbs },
4958                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4959                 .dac_nids = alc880_test_dac_nids,
4960                 .dig_out_nid = ALC880_DIGOUT_NID,
4961                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4962                 .channel_mode = alc880_test_modes,
4963                 .input_mux = &alc880_test_capture_source,
4964         },
4965 #endif
4966 };
4967
4968 /*
4969  * Automatic parse of I/O pins from the BIOS configuration
4970  */
4971
4972 enum {
4973         ALC_CTL_WIDGET_VOL,
4974         ALC_CTL_WIDGET_MUTE,
4975         ALC_CTL_BIND_MUTE,
4976 };
4977 static struct snd_kcontrol_new alc880_control_templates[] = {
4978         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4979         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4980         HDA_BIND_MUTE(NULL, 0, 0, 0),
4981 };
4982
4983 /* add dynamic controls */
4984 static int add_control(struct alc_spec *spec, int type, const char *name,
4985                        int cidx, unsigned long val)
4986 {
4987         struct snd_kcontrol_new *knew;
4988
4989         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4990         knew = snd_array_new(&spec->kctls);
4991         if (!knew)
4992                 return -ENOMEM;
4993         *knew = alc880_control_templates[type];
4994         knew->name = kstrdup(name, GFP_KERNEL);
4995         if (!knew->name)
4996                 return -ENOMEM;
4997         knew->index = cidx;
4998         if (get_amp_nid_(val))
4999                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5000         knew->private_value = val;
5001         return 0;
5002 }
5003
5004 static int add_control_with_pfx(struct alc_spec *spec, int type,
5005                                 const char *pfx, const char *dir,
5006                                 const char *sfx, int cidx, unsigned long val)
5007 {
5008         char name[32];
5009         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5010         return add_control(spec, type, name, cidx, val);
5011 }
5012
5013 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5014         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5015 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5016         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5017 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5018         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5019 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5020         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5021
5022 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5023 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5024 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5025 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5026 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5027 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5028 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5029 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5030 #define ALC880_PIN_CD_NID               0x1c
5031
5032 /* fill in the dac_nids table from the parsed pin configuration */
5033 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5034                                      const struct auto_pin_cfg *cfg)
5035 {
5036         hda_nid_t nid;
5037         int assigned[4];
5038         int i, j;
5039
5040         memset(assigned, 0, sizeof(assigned));
5041         spec->multiout.dac_nids = spec->private_dac_nids;
5042
5043         /* check the pins hardwired to audio widget */
5044         for (i = 0; i < cfg->line_outs; i++) {
5045                 nid = cfg->line_out_pins[i];
5046                 if (alc880_is_fixed_pin(nid)) {
5047                         int idx = alc880_fixed_pin_idx(nid);
5048                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5049                         assigned[idx] = 1;
5050                 }
5051         }
5052         /* left pins can be connect to any audio widget */
5053         for (i = 0; i < cfg->line_outs; i++) {
5054                 nid = cfg->line_out_pins[i];
5055                 if (alc880_is_fixed_pin(nid))
5056                         continue;
5057                 /* search for an empty channel */
5058                 for (j = 0; j < cfg->line_outs; j++) {
5059                         if (!assigned[j]) {
5060                                 spec->multiout.dac_nids[i] =
5061                                         alc880_idx_to_dac(j);
5062                                 assigned[j] = 1;
5063                                 break;
5064                         }
5065                 }
5066         }
5067         spec->multiout.num_dacs = cfg->line_outs;
5068         return 0;
5069 }
5070
5071 /* add playback controls from the parsed DAC table */
5072 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5073                                              const struct auto_pin_cfg *cfg)
5074 {
5075         static const char *chname[4] = {
5076                 "Front", "Surround", NULL /*CLFE*/, "Side"
5077         };
5078         hda_nid_t nid;
5079         int i, err;
5080
5081         for (i = 0; i < cfg->line_outs; i++) {
5082                 if (!spec->multiout.dac_nids[i])
5083                         continue;
5084                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5085                 if (i == 2) {
5086                         /* Center/LFE */
5087                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5088                                               "Center",
5089                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5090                                                               HDA_OUTPUT));
5091                         if (err < 0)
5092                                 return err;
5093                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5094                                               "LFE",
5095                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5096                                                               HDA_OUTPUT));
5097                         if (err < 0)
5098                                 return err;
5099                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5100                                              "Center",
5101                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5102                                                               HDA_INPUT));
5103                         if (err < 0)
5104                                 return err;
5105                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5106                                              "LFE",
5107                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5108                                                               HDA_INPUT));
5109                         if (err < 0)
5110                                 return err;
5111                 } else {
5112                         const char *pfx;
5113                         if (cfg->line_outs == 1 &&
5114                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
5115                                 pfx = "Speaker";
5116                         else
5117                                 pfx = chname[i];
5118                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5119                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5120                                                               HDA_OUTPUT));
5121                         if (err < 0)
5122                                 return err;
5123                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5124                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5125                                                               HDA_INPUT));
5126                         if (err < 0)
5127                                 return err;
5128                 }
5129         }
5130         return 0;
5131 }
5132
5133 /* add playback controls for speaker and HP outputs */
5134 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5135                                         const char *pfx)
5136 {
5137         hda_nid_t nid;
5138         int err;
5139
5140         if (!pin)
5141                 return 0;
5142
5143         if (alc880_is_fixed_pin(pin)) {
5144                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5145                 /* specify the DAC as the extra output */
5146                 if (!spec->multiout.hp_nid)
5147                         spec->multiout.hp_nid = nid;
5148                 else
5149                         spec->multiout.extra_out_nid[0] = nid;
5150                 /* control HP volume/switch on the output mixer amp */
5151                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5152                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5153                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5154                 if (err < 0)
5155                         return err;
5156                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5157                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5158                 if (err < 0)
5159                         return err;
5160         } else if (alc880_is_multi_pin(pin)) {
5161                 /* set manual connection */
5162                 /* we have only a switch on HP-out PIN */
5163                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5164                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5165                 if (err < 0)
5166                         return err;
5167         }
5168         return 0;
5169 }
5170
5171 /* create input playback/capture controls for the given pin */
5172 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5173                             const char *ctlname, int ctlidx,
5174                             int idx, hda_nid_t mix_nid)
5175 {
5176         int err;
5177
5178         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5179                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5180         if (err < 0)
5181                 return err;
5182         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5183                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5184         if (err < 0)
5185                 return err;
5186         return 0;
5187 }
5188
5189 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5190 {
5191         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5192         return (pincap & AC_PINCAP_IN) != 0;
5193 }
5194
5195 /* create playback/capture controls for input pins */
5196 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5197                                       const struct auto_pin_cfg *cfg,
5198                                       hda_nid_t mixer,
5199                                       hda_nid_t cap1, hda_nid_t cap2)
5200 {
5201         struct alc_spec *spec = codec->spec;
5202         struct hda_input_mux *imux = &spec->private_imux[0];
5203         int i, err, idx, type, type_idx = 0;
5204
5205         for (i = 0; i < cfg->num_inputs; i++) {
5206                 hda_nid_t pin;
5207                 const char *label;
5208
5209                 pin = cfg->inputs[i].pin;
5210                 if (!alc_is_input_pin(codec, pin))
5211                         continue;
5212
5213                 type = cfg->inputs[i].type;
5214                 if (i > 0 && type == cfg->inputs[i - 1].type)
5215                         type_idx++;
5216                 else
5217                         type_idx = 0;
5218                 label = hda_get_autocfg_input_label(codec, cfg, i);
5219                 if (mixer) {
5220                         idx = get_connection_index(codec, mixer, pin);
5221                         if (idx >= 0) {
5222                                 err = new_analog_input(spec, pin,
5223                                                        label, type_idx,
5224                                                        idx, mixer);
5225                                 if (err < 0)
5226                                         return err;
5227                         }
5228                 }
5229
5230                 if (!cap1)
5231                         continue;
5232                 idx = get_connection_index(codec, cap1, pin);
5233                 if (idx < 0 && cap2)
5234                         idx = get_connection_index(codec, cap2, pin);
5235                 if (idx >= 0)
5236                         snd_hda_add_imux_item(imux, label, idx, NULL);
5237         }
5238         return 0;
5239 }
5240
5241 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5242                                                 const struct auto_pin_cfg *cfg)
5243 {
5244         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5245 }
5246
5247 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5248                                unsigned int pin_type)
5249 {
5250         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5251                             pin_type);
5252         /* unmute pin */
5253         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5254                             AMP_OUT_UNMUTE);
5255 }
5256
5257 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5258                                               hda_nid_t nid, int pin_type,
5259                                               int dac_idx)
5260 {
5261         alc_set_pin_output(codec, nid, pin_type);
5262         /* need the manual connection? */
5263         if (alc880_is_multi_pin(nid)) {
5264                 struct alc_spec *spec = codec->spec;
5265                 int idx = alc880_multi_pin_idx(nid);
5266                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5267                                     AC_VERB_SET_CONNECT_SEL,
5268                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5269         }
5270 }
5271
5272 static int get_pin_type(int line_out_type)
5273 {
5274         if (line_out_type == AUTO_PIN_HP_OUT)
5275                 return PIN_HP;
5276         else
5277                 return PIN_OUT;
5278 }
5279
5280 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5281 {
5282         struct alc_spec *spec = codec->spec;
5283         int i;
5284
5285         for (i = 0; i < spec->autocfg.line_outs; i++) {
5286                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5287                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5288                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5289         }
5290 }
5291
5292 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5293 {
5294         struct alc_spec *spec = codec->spec;
5295         hda_nid_t pin;
5296
5297         pin = spec->autocfg.speaker_pins[0];
5298         if (pin) /* connect to front */
5299                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5300         pin = spec->autocfg.hp_pins[0];
5301         if (pin) /* connect to front */
5302                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5303 }
5304
5305 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5306 {
5307         struct alc_spec *spec = codec->spec;
5308         struct auto_pin_cfg *cfg = &spec->autocfg;
5309         int i;
5310
5311         for (i = 0; i < cfg->num_inputs; i++) {
5312                 hda_nid_t nid = cfg->inputs[i].pin;
5313                 if (alc_is_input_pin(codec, nid)) {
5314                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5315                         if (nid != ALC880_PIN_CD_NID &&
5316                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5317                                 snd_hda_codec_write(codec, nid, 0,
5318                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5319                                                     AMP_OUT_MUTE);
5320                 }
5321         }
5322 }
5323
5324 static void alc880_auto_init_input_src(struct hda_codec *codec)
5325 {
5326         struct alc_spec *spec = codec->spec;
5327         int c;
5328
5329         for (c = 0; c < spec->num_adc_nids; c++) {
5330                 unsigned int mux_idx;
5331                 const struct hda_input_mux *imux;
5332                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5333                 imux = &spec->input_mux[mux_idx];
5334                 if (!imux->num_items && mux_idx > 0)
5335                         imux = &spec->input_mux[0];
5336                 if (imux)
5337                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5338                                             AC_VERB_SET_CONNECT_SEL,
5339                                             imux->items[0].index);
5340         }
5341 }
5342
5343 /* parse the BIOS configuration and set up the alc_spec */
5344 /* return 1 if successful, 0 if the proper config is not found,
5345  * or a negative error code
5346  */
5347 static int alc880_parse_auto_config(struct hda_codec *codec)
5348 {
5349         struct alc_spec *spec = codec->spec;
5350         int err;
5351         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5352
5353         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5354                                            alc880_ignore);
5355         if (err < 0)
5356                 return err;
5357         if (!spec->autocfg.line_outs)
5358                 return 0; /* can't find valid BIOS pin config */
5359
5360         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5361         if (err < 0)
5362                 return err;
5363         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5364         if (err < 0)
5365                 return err;
5366         err = alc880_auto_create_extra_out(spec,
5367                                            spec->autocfg.speaker_pins[0],
5368                                            "Speaker");
5369         if (err < 0)
5370                 return err;
5371         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5372                                            "Headphone");
5373         if (err < 0)
5374                 return err;
5375         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5376         if (err < 0)
5377                 return err;
5378
5379         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5380
5381         alc_auto_parse_digital(codec);
5382
5383         if (spec->kctls.list)
5384                 add_mixer(spec, spec->kctls.list);
5385
5386         add_verb(spec, alc880_volume_init_verbs);
5387
5388         spec->num_mux_defs = 1;
5389         spec->input_mux = &spec->private_imux[0];
5390
5391         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5392
5393         return 1;
5394 }
5395
5396 /* additional initialization for auto-configuration model */
5397 static void alc880_auto_init(struct hda_codec *codec)
5398 {
5399         struct alc_spec *spec = codec->spec;
5400         alc880_auto_init_multi_out(codec);
5401         alc880_auto_init_extra_out(codec);
5402         alc880_auto_init_analog_input(codec);
5403         alc880_auto_init_input_src(codec);
5404         alc_auto_init_digital(codec);
5405         if (spec->unsol_event)
5406                 alc_inithook(codec);
5407 }
5408
5409 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5410  * one of two digital mic pins, e.g. on ALC272
5411  */
5412 static void fixup_automic_adc(struct hda_codec *codec)
5413 {
5414         struct alc_spec *spec = codec->spec;
5415         int i;
5416
5417         for (i = 0; i < spec->num_adc_nids; i++) {
5418                 hda_nid_t cap = spec->capsrc_nids ?
5419                         spec->capsrc_nids[i] : spec->adc_nids[i];
5420                 int iidx, eidx;
5421
5422                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5423                 if (iidx < 0)
5424                         continue;
5425                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5426                 if (eidx < 0)
5427                         continue;
5428                 spec->int_mic.mux_idx = iidx;
5429                 spec->ext_mic.mux_idx = eidx;
5430                 if (spec->capsrc_nids)
5431                         spec->capsrc_nids += i;
5432                 spec->adc_nids += i;
5433                 spec->num_adc_nids = 1;
5434                 return;
5435         }
5436         snd_printd(KERN_INFO "hda_codec: %s: "
5437                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5438                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5439         spec->auto_mic = 0; /* disable auto-mic to be sure */
5440 }
5441
5442 /* select or unmute the given capsrc route */
5443 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5444                                     int idx)
5445 {
5446         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5447                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5448                                          HDA_AMP_MUTE, 0);
5449         } else {
5450                 snd_hda_codec_write_cache(codec, cap, 0,
5451                                           AC_VERB_SET_CONNECT_SEL, idx);
5452         }
5453 }
5454
5455 /* set the default connection to that pin */
5456 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5457 {
5458         struct alc_spec *spec = codec->spec;
5459         int i;
5460
5461         for (i = 0; i < spec->num_adc_nids; i++) {
5462                 hda_nid_t cap = spec->capsrc_nids ?
5463                         spec->capsrc_nids[i] : spec->adc_nids[i];
5464                 int idx;
5465
5466                 idx = get_connection_index(codec, cap, pin);
5467                 if (idx < 0)
5468                         continue;
5469                 select_or_unmute_capsrc(codec, cap, idx);
5470                 return i; /* return the found index */
5471         }
5472         return -1; /* not found */
5473 }
5474
5475 /* choose the ADC/MUX containing the input pin and initialize the setup */
5476 static void fixup_single_adc(struct hda_codec *codec)
5477 {
5478         struct alc_spec *spec = codec->spec;
5479         struct auto_pin_cfg *cfg = &spec->autocfg;
5480         int i;
5481
5482         /* search for the input pin; there must be only one */
5483         if (cfg->num_inputs != 1)
5484                 return;
5485         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5486         if (i >= 0) {
5487                 /* use only this ADC */
5488                 if (spec->capsrc_nids)
5489                         spec->capsrc_nids += i;
5490                 spec->adc_nids += i;
5491                 spec->num_adc_nids = 1;
5492         }
5493 }
5494
5495 /* initialize dual adcs */
5496 static void fixup_dual_adc_switch(struct hda_codec *codec)
5497 {
5498         struct alc_spec *spec = codec->spec;
5499         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5500         init_capsrc_for_pin(codec, spec->int_mic.pin);
5501 }
5502
5503 static void set_capture_mixer(struct hda_codec *codec)
5504 {
5505         struct alc_spec *spec = codec->spec;
5506         static struct snd_kcontrol_new *caps[2][3] = {
5507                 { alc_capture_mixer_nosrc1,
5508                   alc_capture_mixer_nosrc2,
5509                   alc_capture_mixer_nosrc3 },
5510                 { alc_capture_mixer1,
5511                   alc_capture_mixer2,
5512                   alc_capture_mixer3 },
5513         };
5514         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5515                 int mux = 0;
5516                 int num_adcs = spec->num_adc_nids;
5517                 if (spec->dual_adc_switch)
5518                         fixup_dual_adc_switch(codec);
5519                 else if (spec->auto_mic)
5520                         fixup_automic_adc(codec);
5521                 else if (spec->input_mux) {
5522                         if (spec->input_mux->num_items > 1)
5523                                 mux = 1;
5524                         else if (spec->input_mux->num_items == 1)
5525                                 fixup_single_adc(codec);
5526                 }
5527                 if (spec->dual_adc_switch)
5528                         num_adcs = 1;
5529                 spec->cap_mixer = caps[mux][num_adcs - 1];
5530         }
5531 }
5532
5533 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5534 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5535                                  int num_nids)
5536 {
5537         struct alc_spec *spec = codec->spec;
5538         struct auto_pin_cfg *cfg = &spec->autocfg;
5539         int n;
5540         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5541
5542         for (n = 0; n < num_nids; n++) {
5543                 hda_nid_t adc, cap;
5544                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5545                 int nconns, i, j;
5546
5547                 adc = nids[n];
5548                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5549                         continue;
5550                 cap = adc;
5551                 nconns = snd_hda_get_connections(codec, cap, conn,
5552                                                  ARRAY_SIZE(conn));
5553                 if (nconns == 1) {
5554                         cap = conn[0];
5555                         nconns = snd_hda_get_connections(codec, cap, conn,
5556                                                          ARRAY_SIZE(conn));
5557                 }
5558                 if (nconns <= 0)
5559                         continue;
5560                 if (!fallback_adc) {
5561                         fallback_adc = adc;
5562                         fallback_cap = cap;
5563                 }
5564                 for (i = 0; i < cfg->num_inputs; i++) {
5565                         hda_nid_t nid = cfg->inputs[i].pin;
5566                         for (j = 0; j < nconns; j++) {
5567                                 if (conn[j] == nid)
5568                                         break;
5569                         }
5570                         if (j >= nconns)
5571                                 break;
5572                 }
5573                 if (i >= cfg->num_inputs) {
5574                         int num_adcs = spec->num_adc_nids;
5575                         spec->private_adc_nids[num_adcs] = adc;
5576                         spec->private_capsrc_nids[num_adcs] = cap;
5577                         spec->num_adc_nids++;
5578                         spec->adc_nids = spec->private_adc_nids;
5579                         if (adc != cap)
5580                                 spec->capsrc_nids = spec->private_capsrc_nids;
5581                 }
5582         }
5583         if (!spec->num_adc_nids) {
5584                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5585                        " using fallback 0x%x\n",
5586                        codec->chip_name, fallback_adc);
5587                 spec->private_adc_nids[0] = fallback_adc;
5588                 spec->adc_nids = spec->private_adc_nids;
5589                 if (fallback_adc != fallback_cap) {
5590                         spec->private_capsrc_nids[0] = fallback_cap;
5591                         spec->capsrc_nids = spec->private_adc_nids;
5592                 }
5593         }
5594 }
5595
5596 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5597 #define set_beep_amp(spec, nid, idx, dir) \
5598         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5599
5600 static struct snd_pci_quirk beep_white_list[] = {
5601         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5602         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5603         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5604         {}
5605 };
5606
5607 static inline int has_cdefine_beep(struct hda_codec *codec)
5608 {
5609         struct alc_spec *spec = codec->spec;
5610         const struct snd_pci_quirk *q;
5611         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5612         if (q)
5613                 return q->value;
5614         return spec->cdefine.enable_pcbeep;
5615 }
5616 #else
5617 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5618 #define has_cdefine_beep(codec)         0
5619 #endif
5620
5621 /*
5622  * OK, here we have finally the patch for ALC880
5623  */
5624
5625 static int patch_alc880(struct hda_codec *codec)
5626 {
5627         struct alc_spec *spec;
5628         int board_config;
5629         int err;
5630
5631         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5632         if (spec == NULL)
5633                 return -ENOMEM;
5634
5635         codec->spec = spec;
5636
5637         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5638                                                   alc880_models,
5639                                                   alc880_cfg_tbl);
5640         if (board_config < 0) {
5641                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5642                        codec->chip_name);
5643                 board_config = ALC880_AUTO;
5644         }
5645
5646         if (board_config == ALC880_AUTO) {
5647                 /* automatic parse from the BIOS config */
5648                 err = alc880_parse_auto_config(codec);
5649                 if (err < 0) {
5650                         alc_free(codec);
5651                         return err;
5652                 } else if (!err) {
5653                         printk(KERN_INFO
5654                                "hda_codec: Cannot set up configuration "
5655                                "from BIOS.  Using 3-stack mode...\n");
5656                         board_config = ALC880_3ST;
5657                 }
5658         }
5659
5660         err = snd_hda_attach_beep_device(codec, 0x1);
5661         if (err < 0) {
5662                 alc_free(codec);
5663                 return err;
5664         }
5665
5666         if (board_config != ALC880_AUTO)
5667                 setup_preset(codec, &alc880_presets[board_config]);
5668
5669         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5670         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5671         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5672
5673         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5674         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5675
5676         if (!spec->adc_nids && spec->input_mux) {
5677                 /* check whether NID 0x07 is valid */
5678                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5679                 /* get type */
5680                 wcap = get_wcaps_type(wcap);
5681                 if (wcap != AC_WID_AUD_IN) {
5682                         spec->adc_nids = alc880_adc_nids_alt;
5683                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5684                 } else {
5685                         spec->adc_nids = alc880_adc_nids;
5686                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5687                 }
5688         }
5689         set_capture_mixer(codec);
5690         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5691
5692         spec->vmaster_nid = 0x0c;
5693
5694         codec->patch_ops = alc_patch_ops;
5695         if (board_config == ALC880_AUTO)
5696                 spec->init_hook = alc880_auto_init;
5697 #ifdef CONFIG_SND_HDA_POWER_SAVE
5698         if (!spec->loopback.amplist)
5699                 spec->loopback.amplist = alc880_loopbacks;
5700 #endif
5701
5702         return 0;
5703 }
5704
5705
5706 /*
5707  * ALC260 support
5708  */
5709
5710 static hda_nid_t alc260_dac_nids[1] = {
5711         /* front */
5712         0x02,
5713 };
5714
5715 static hda_nid_t alc260_adc_nids[1] = {
5716         /* ADC0 */
5717         0x04,
5718 };
5719
5720 static hda_nid_t alc260_adc_nids_alt[1] = {
5721         /* ADC1 */
5722         0x05,
5723 };
5724
5725 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5726  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5727  */
5728 static hda_nid_t alc260_dual_adc_nids[2] = {
5729         /* ADC0, ADC1 */
5730         0x04, 0x05
5731 };
5732
5733 #define ALC260_DIGOUT_NID       0x03
5734 #define ALC260_DIGIN_NID        0x06
5735
5736 static struct hda_input_mux alc260_capture_source = {
5737         .num_items = 4,
5738         .items = {
5739                 { "Mic", 0x0 },
5740                 { "Front Mic", 0x1 },
5741                 { "Line", 0x2 },
5742                 { "CD", 0x4 },
5743         },
5744 };
5745
5746 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5747  * headphone jack and the internal CD lines since these are the only pins at
5748  * which audio can appear.  For flexibility, also allow the option of
5749  * recording the mixer output on the second ADC (ADC0 doesn't have a
5750  * connection to the mixer output).
5751  */
5752 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5753         {
5754                 .num_items = 3,
5755                 .items = {
5756                         { "Mic/Line", 0x0 },
5757                         { "CD", 0x4 },
5758                         { "Headphone", 0x2 },
5759                 },
5760         },
5761         {
5762                 .num_items = 4,
5763                 .items = {
5764                         { "Mic/Line", 0x0 },
5765                         { "CD", 0x4 },
5766                         { "Headphone", 0x2 },
5767                         { "Mixer", 0x5 },
5768                 },
5769         },
5770
5771 };
5772
5773 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5774  * the Fujitsu S702x, but jacks are marked differently.
5775  */
5776 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5777         {
5778                 .num_items = 4,
5779                 .items = {
5780                         { "Mic", 0x0 },
5781                         { "Line", 0x2 },
5782                         { "CD", 0x4 },
5783                         { "Headphone", 0x5 },
5784                 },
5785         },
5786         {
5787                 .num_items = 5,
5788                 .items = {
5789                         { "Mic", 0x0 },
5790                         { "Line", 0x2 },
5791                         { "CD", 0x4 },
5792                         { "Headphone", 0x6 },
5793                         { "Mixer", 0x5 },
5794                 },
5795         },
5796 };
5797
5798 /* Maxdata Favorit 100XS */
5799 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5800         {
5801                 .num_items = 2,
5802                 .items = {
5803                         { "Line/Mic", 0x0 },
5804                         { "CD", 0x4 },
5805                 },
5806         },
5807         {
5808                 .num_items = 3,
5809                 .items = {
5810                         { "Line/Mic", 0x0 },
5811                         { "CD", 0x4 },
5812                         { "Mixer", 0x5 },
5813                 },
5814         },
5815 };
5816
5817 /*
5818  * This is just place-holder, so there's something for alc_build_pcms to look
5819  * at when it calculates the maximum number of channels. ALC260 has no mixer
5820  * element which allows changing the channel mode, so the verb list is
5821  * never used.
5822  */
5823 static struct hda_channel_mode alc260_modes[1] = {
5824         { 2, NULL },
5825 };
5826
5827
5828 /* Mixer combinations
5829  *
5830  * basic: base_output + input + pc_beep + capture
5831  * HP: base_output + input + capture_alt
5832  * HP_3013: hp_3013 + input + capture
5833  * fujitsu: fujitsu + capture
5834  * acer: acer + capture
5835  */
5836
5837 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5838         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5839         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5840         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5841         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5842         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5843         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5844         { } /* end */
5845 };
5846
5847 static struct snd_kcontrol_new alc260_input_mixer[] = {
5848         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5849         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5850         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5851         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5852         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5853         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5854         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5855         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5856         { } /* end */
5857 };
5858
5859 /* update HP, line and mono out pins according to the master switch */
5860 static void alc260_hp_master_update(struct hda_codec *codec,
5861                                     hda_nid_t hp, hda_nid_t line,
5862                                     hda_nid_t mono)
5863 {
5864         struct alc_spec *spec = codec->spec;
5865         unsigned int val = spec->master_sw ? PIN_HP : 0;
5866         /* change HP and line-out pins */
5867         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5868                             val);
5869         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5870                             val);
5871         /* mono (speaker) depending on the HP jack sense */
5872         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5873         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5874                             val);
5875 }
5876
5877 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5878                                    struct snd_ctl_elem_value *ucontrol)
5879 {
5880         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5881         struct alc_spec *spec = codec->spec;
5882         *ucontrol->value.integer.value = spec->master_sw;
5883         return 0;
5884 }
5885
5886 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5887                                    struct snd_ctl_elem_value *ucontrol)
5888 {
5889         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5890         struct alc_spec *spec = codec->spec;
5891         int val = !!*ucontrol->value.integer.value;
5892         hda_nid_t hp, line, mono;
5893
5894         if (val == spec->master_sw)
5895                 return 0;
5896         spec->master_sw = val;
5897         hp = (kcontrol->private_value >> 16) & 0xff;
5898         line = (kcontrol->private_value >> 8) & 0xff;
5899         mono = kcontrol->private_value & 0xff;
5900         alc260_hp_master_update(codec, hp, line, mono);
5901         return 1;
5902 }
5903
5904 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5905         {
5906                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5907                 .name = "Master Playback Switch",
5908                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5909                 .info = snd_ctl_boolean_mono_info,
5910                 .get = alc260_hp_master_sw_get,
5911                 .put = alc260_hp_master_sw_put,
5912                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5913         },
5914         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5915         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5916         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5917         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5918         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5919                               HDA_OUTPUT),
5920         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5921         { } /* end */
5922 };
5923
5924 static struct hda_verb alc260_hp_unsol_verbs[] = {
5925         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5926         {},
5927 };
5928
5929 static void alc260_hp_automute(struct hda_codec *codec)
5930 {
5931         struct alc_spec *spec = codec->spec;
5932
5933         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5934         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5935 }
5936
5937 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5938 {
5939         if ((res >> 26) == ALC880_HP_EVENT)
5940                 alc260_hp_automute(codec);
5941 }
5942
5943 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5944         {
5945                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5946                 .name = "Master Playback Switch",
5947                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5948                 .info = snd_ctl_boolean_mono_info,
5949                 .get = alc260_hp_master_sw_get,
5950                 .put = alc260_hp_master_sw_put,
5951                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5952         },
5953         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5954         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5955         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5956         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5957         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5958         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5959         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5960         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5961         { } /* end */
5962 };
5963
5964 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5965         .ops = &snd_hda_bind_vol,
5966         .values = {
5967                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5968                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5969                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5970                 0
5971         },
5972 };
5973
5974 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5975         .ops = &snd_hda_bind_sw,
5976         .values = {
5977                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5978                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5979                 0
5980         },
5981 };
5982
5983 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5984         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5985         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5986         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5987         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5988         { } /* end */
5989 };
5990
5991 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5992         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5993         {},
5994 };
5995
5996 static void alc260_hp_3013_automute(struct hda_codec *codec)
5997 {
5998         struct alc_spec *spec = codec->spec;
5999
6000         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
6001         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
6002 }
6003
6004 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
6005                                        unsigned int res)
6006 {
6007         if ((res >> 26) == ALC880_HP_EVENT)
6008                 alc260_hp_3013_automute(codec);
6009 }
6010
6011 static void alc260_hp_3012_automute(struct hda_codec *codec)
6012 {
6013         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
6014
6015         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6016                             bits);
6017         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6018                             bits);
6019         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6020                             bits);
6021 }
6022
6023 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
6024                                        unsigned int res)
6025 {
6026         if ((res >> 26) == ALC880_HP_EVENT)
6027                 alc260_hp_3012_automute(codec);
6028 }
6029
6030 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6031  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6032  */
6033 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6034         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6035         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6036         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6037         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6038         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6039         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6040         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6041         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6042         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6043         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6044         { } /* end */
6045 };
6046
6047 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6048  * versions of the ALC260 don't act on requests to enable mic bias from NID
6049  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6050  * datasheet doesn't mention this restriction.  At this stage it's not clear
6051  * whether this behaviour is intentional or is a hardware bug in chip
6052  * revisions available in early 2006.  Therefore for now allow the
6053  * "Headphone Jack Mode" control to span all choices, but if it turns out
6054  * that the lack of mic bias for this NID is intentional we could change the
6055  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6056  *
6057  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6058  * don't appear to make the mic bias available from the "line" jack, even
6059  * though the NID used for this jack (0x14) can supply it.  The theory is
6060  * that perhaps Acer have included blocking capacitors between the ALC260
6061  * and the output jack.  If this turns out to be the case for all such
6062  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6063  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6064  *
6065  * The C20x Tablet series have a mono internal speaker which is controlled
6066  * via the chip's Mono sum widget and pin complex, so include the necessary
6067  * controls for such models.  On models without a "mono speaker" the control
6068  * won't do anything.
6069  */
6070 static struct snd_kcontrol_new alc260_acer_mixer[] = {
6071         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6072         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6073         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6074         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6075                               HDA_OUTPUT),
6076         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6077                            HDA_INPUT),
6078         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6079         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6080         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6081         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6082         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6083         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6084         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6085         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6086         { } /* end */
6087 };
6088
6089 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6090  */
6091 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6092         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6093         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6094         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6095         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6096         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6097         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6098         { } /* end */
6099 };
6100
6101 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6102  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6103  */
6104 static struct snd_kcontrol_new alc260_will_mixer[] = {
6105         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6106         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6108         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6109         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6110         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6111         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6112         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6113         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6114         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6115         { } /* end */
6116 };
6117
6118 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6119  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6120  */
6121 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6122         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6123         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6124         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6125         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6126         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6127         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6128         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6129         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6130         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6131         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6132         { } /* end */
6133 };
6134
6135 /*
6136  * initialization verbs
6137  */
6138 static struct hda_verb alc260_init_verbs[] = {
6139         /* Line In pin widget for input */
6140         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6141         /* CD pin widget for input */
6142         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6143         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6144         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6145         /* Mic2 (front panel) pin widget for input and vref at 80% */
6146         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6147         /* LINE-2 is used for line-out in rear */
6148         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6149         /* select line-out */
6150         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6151         /* LINE-OUT pin */
6152         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6153         /* enable HP */
6154         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6155         /* enable Mono */
6156         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6157         /* mute capture amp left and right */
6158         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6159         /* set connection select to line in (default select for this ADC) */
6160         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6161         /* mute capture amp left and right */
6162         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6163         /* set connection select to line in (default select for this ADC) */
6164         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6165         /* set vol=0 Line-Out mixer amp left and right */
6166         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6167         /* unmute pin widget amp left and right (no gain on this amp) */
6168         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6169         /* set vol=0 HP mixer amp left and right */
6170         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6171         /* unmute pin widget amp left and right (no gain on this amp) */
6172         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6173         /* set vol=0 Mono mixer amp left and right */
6174         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6175         /* unmute pin widget amp left and right (no gain on this amp) */
6176         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6177         /* unmute LINE-2 out pin */
6178         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6179         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6180          * Line In 2 = 0x03
6181          */
6182         /* mute analog inputs */
6183         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6184         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6185         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6186         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6187         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6188         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6189         /* mute Front out path */
6190         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6192         /* mute Headphone out path */
6193         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6194         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6195         /* mute Mono out path */
6196         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6197         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6198         { }
6199 };
6200
6201 #if 0 /* should be identical with alc260_init_verbs? */
6202 static struct hda_verb alc260_hp_init_verbs[] = {
6203         /* Headphone and output */
6204         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6205         /* mono output */
6206         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6207         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6208         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6209         /* Mic2 (front panel) pin widget for input and vref at 80% */
6210         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6211         /* Line In pin widget for input */
6212         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6213         /* Line-2 pin widget for output */
6214         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6215         /* CD pin widget for input */
6216         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6217         /* unmute amp left and right */
6218         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6219         /* set connection select to line in (default select for this ADC) */
6220         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6221         /* unmute Line-Out mixer amp left and right (volume = 0) */
6222         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6223         /* mute pin widget amp left and right (no gain on this amp) */
6224         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6225         /* unmute HP mixer amp left and right (volume = 0) */
6226         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6227         /* mute pin widget amp left and right (no gain on this amp) */
6228         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6229         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6230          * Line In 2 = 0x03
6231          */
6232         /* mute analog inputs */
6233         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6234         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6235         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6236         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6237         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6238         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6239         /* Unmute Front out path */
6240         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6241         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6242         /* Unmute Headphone out path */
6243         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6244         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6245         /* Unmute Mono out path */
6246         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6247         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6248         { }
6249 };
6250 #endif
6251
6252 static struct hda_verb alc260_hp_3013_init_verbs[] = {
6253         /* Line out and output */
6254         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6255         /* mono output */
6256         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6257         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6258         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6259         /* Mic2 (front panel) pin widget for input and vref at 80% */
6260         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6261         /* Line In pin widget for input */
6262         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6263         /* Headphone pin widget for output */
6264         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6265         /* CD pin widget for input */
6266         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6267         /* unmute amp left and right */
6268         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6269         /* set connection select to line in (default select for this ADC) */
6270         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6271         /* unmute Line-Out mixer amp left and right (volume = 0) */
6272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6273         /* mute pin widget amp left and right (no gain on this amp) */
6274         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6275         /* unmute HP mixer amp left and right (volume = 0) */
6276         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6277         /* mute pin widget amp left and right (no gain on this amp) */
6278         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6279         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6280          * Line In 2 = 0x03
6281          */
6282         /* mute analog inputs */
6283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6284         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6285         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6286         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6287         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6288         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6289         /* Unmute Front out path */
6290         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6291         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6292         /* Unmute Headphone out path */
6293         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6294         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6295         /* Unmute Mono out path */
6296         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6297         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6298         { }
6299 };
6300
6301 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6302  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6303  * audio = 0x16, internal speaker = 0x10.
6304  */
6305 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6306         /* Disable all GPIOs */
6307         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6308         /* Internal speaker is connected to headphone pin */
6309         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6310         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6312         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6313         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6314         /* Ensure all other unused pins are disabled and muted. */
6315         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6316         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6317         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6318         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6319         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6320         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6323
6324         /* Disable digital (SPDIF) pins */
6325         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6326         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6327
6328         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6329          * when acting as an output.
6330          */
6331         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6332
6333         /* Start with output sum widgets muted and their output gains at min */
6334         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6335         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6336         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6337         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6338         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6339         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6340         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6341         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6342         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6343
6344         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6345         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6346         /* Unmute Line1 pin widget output buffer since it starts as an output.
6347          * If the pin mode is changed by the user the pin mode control will
6348          * take care of enabling the pin's input/output buffers as needed.
6349          * Therefore there's no need to enable the input buffer at this
6350          * stage.
6351          */
6352         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6353         /* Unmute input buffer of pin widget used for Line-in (no equiv
6354          * mixer ctrl)
6355          */
6356         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6357
6358         /* Mute capture amp left and right */
6359         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6360         /* Set ADC connection select to match default mixer setting - line
6361          * in (on mic1 pin)
6362          */
6363         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6364
6365         /* Do the same for the second ADC: mute capture input amp and
6366          * set ADC connection to line in (on mic1 pin)
6367          */
6368         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6369         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6370
6371         /* Mute all inputs to mixer widget (even unconnected ones) */
6372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6373         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6374         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6375         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6376         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6377         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6378         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6379         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6380
6381         { }
6382 };
6383
6384 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6385  * similar laptops (adapted from Fujitsu init verbs).
6386  */
6387 static struct hda_verb alc260_acer_init_verbs[] = {
6388         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6389          * the headphone jack.  Turn this on and rely on the standard mute
6390          * methods whenever the user wants to turn these outputs off.
6391          */
6392         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6393         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6394         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6395         /* Internal speaker/Headphone jack is connected to Line-out pin */
6396         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6397         /* Internal microphone/Mic jack is connected to Mic1 pin */
6398         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6399         /* Line In jack is connected to Line1 pin */
6400         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6401         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6402         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6403         /* Ensure all other unused pins are disabled and muted. */
6404         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6405         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6406         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6407         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6408         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6409         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6410         /* Disable digital (SPDIF) pins */
6411         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6412         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6413
6414         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6415          * bus when acting as outputs.
6416          */
6417         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6418         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6419
6420         /* Start with output sum widgets muted and their output gains at min */
6421         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6422         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6423         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6424         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6425         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6426         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6427         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6428         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6429         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6430
6431         /* Unmute Line-out pin widget amp left and right
6432          * (no equiv mixer ctrl)
6433          */
6434         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6435         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6436         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6437         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6438          * inputs. If the pin mode is changed by the user the pin mode control
6439          * will take care of enabling the pin's input/output buffers as needed.
6440          * Therefore there's no need to enable the input buffer at this
6441          * stage.
6442          */
6443         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6444         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6445
6446         /* Mute capture amp left and right */
6447         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6448         /* Set ADC connection select to match default mixer setting - mic
6449          * (on mic1 pin)
6450          */
6451         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6452
6453         /* Do similar with the second ADC: mute capture input amp and
6454          * set ADC connection to mic to match ALSA's default state.
6455          */
6456         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6457         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6458
6459         /* Mute all inputs to mixer widget (even unconnected ones) */
6460         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6462         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6463         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6464         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6465         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6466         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6467         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6468
6469         { }
6470 };
6471
6472 /* Initialisation sequence for Maxdata Favorit 100XS
6473  * (adapted from Acer init verbs).
6474  */
6475 static struct hda_verb alc260_favorit100_init_verbs[] = {
6476         /* GPIO 0 enables the output jack.
6477          * Turn this on and rely on the standard mute
6478          * methods whenever the user wants to turn these outputs off.
6479          */
6480         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6481         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6482         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6483         /* Line/Mic input jack is connected to Mic1 pin */
6484         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6485         /* Ensure all other unused pins are disabled and muted. */
6486         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6487         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6488         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6489         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6490         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6491         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6492         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6493         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6494         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6495         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6496         /* Disable digital (SPDIF) pins */
6497         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6498         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6499
6500         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6501          * bus when acting as outputs.
6502          */
6503         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6504         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6505
6506         /* Start with output sum widgets muted and their output gains at min */
6507         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6508         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6509         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6510         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6511         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6512         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6513         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6514         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6515         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6516
6517         /* Unmute Line-out pin widget amp left and right
6518          * (no equiv mixer ctrl)
6519          */
6520         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6521         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6522          * inputs. If the pin mode is changed by the user the pin mode control
6523          * will take care of enabling the pin's input/output buffers as needed.
6524          * Therefore there's no need to enable the input buffer at this
6525          * stage.
6526          */
6527         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6528
6529         /* Mute capture amp left and right */
6530         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6531         /* Set ADC connection select to match default mixer setting - mic
6532          * (on mic1 pin)
6533          */
6534         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6535
6536         /* Do similar with the second ADC: mute capture input amp and
6537          * set ADC connection to mic to match ALSA's default state.
6538          */
6539         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6540         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6541
6542         /* Mute all inputs to mixer widget (even unconnected ones) */
6543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6551
6552         { }
6553 };
6554
6555 static struct hda_verb alc260_will_verbs[] = {
6556         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6557         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6558         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6559         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6560         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6561         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6562         {}
6563 };
6564
6565 static struct hda_verb alc260_replacer_672v_verbs[] = {
6566         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6567         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6568         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6569
6570         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6571         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6572         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6573
6574         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6575         {}
6576 };
6577
6578 /* toggle speaker-output according to the hp-jack state */
6579 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6580 {
6581         unsigned int present;
6582
6583         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6584         present = snd_hda_jack_detect(codec, 0x0f);
6585         if (present) {
6586                 snd_hda_codec_write_cache(codec, 0x01, 0,
6587                                           AC_VERB_SET_GPIO_DATA, 1);
6588                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6589                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6590                                           PIN_HP);
6591         } else {
6592                 snd_hda_codec_write_cache(codec, 0x01, 0,
6593                                           AC_VERB_SET_GPIO_DATA, 0);
6594                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6595                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6596                                           PIN_OUT);
6597         }
6598 }
6599
6600 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6601                                        unsigned int res)
6602 {
6603         if ((res >> 26) == ALC880_HP_EVENT)
6604                 alc260_replacer_672v_automute(codec);
6605 }
6606
6607 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6608         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6609         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6610         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6611         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6612         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6613         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6614         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6615         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6616         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6617         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6618         {}
6619 };
6620
6621 /* Test configuration for debugging, modelled after the ALC880 test
6622  * configuration.
6623  */
6624 #ifdef CONFIG_SND_DEBUG
6625 static hda_nid_t alc260_test_dac_nids[1] = {
6626         0x02,
6627 };
6628 static hda_nid_t alc260_test_adc_nids[2] = {
6629         0x04, 0x05,
6630 };
6631 /* For testing the ALC260, each input MUX needs its own definition since
6632  * the signal assignments are different.  This assumes that the first ADC
6633  * is NID 0x04.
6634  */
6635 static struct hda_input_mux alc260_test_capture_sources[2] = {
6636         {
6637                 .num_items = 7,
6638                 .items = {
6639                         { "MIC1 pin", 0x0 },
6640                         { "MIC2 pin", 0x1 },
6641                         { "LINE1 pin", 0x2 },
6642                         { "LINE2 pin", 0x3 },
6643                         { "CD pin", 0x4 },
6644                         { "LINE-OUT pin", 0x5 },
6645                         { "HP-OUT pin", 0x6 },
6646                 },
6647         },
6648         {
6649                 .num_items = 8,
6650                 .items = {
6651                         { "MIC1 pin", 0x0 },
6652                         { "MIC2 pin", 0x1 },
6653                         { "LINE1 pin", 0x2 },
6654                         { "LINE2 pin", 0x3 },
6655                         { "CD pin", 0x4 },
6656                         { "Mixer", 0x5 },
6657                         { "LINE-OUT pin", 0x6 },
6658                         { "HP-OUT pin", 0x7 },
6659                 },
6660         },
6661 };
6662 static struct snd_kcontrol_new alc260_test_mixer[] = {
6663         /* Output driver widgets */
6664         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6665         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6666         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6667         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6668         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6669         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6670
6671         /* Modes for retasking pin widgets
6672          * Note: the ALC260 doesn't seem to act on requests to enable mic
6673          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6674          * mention this restriction.  At this stage it's not clear whether
6675          * this behaviour is intentional or is a hardware bug in chip
6676          * revisions available at least up until early 2006.  Therefore for
6677          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6678          * choices, but if it turns out that the lack of mic bias for these
6679          * NIDs is intentional we could change their modes from
6680          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6681          */
6682         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6683         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6684         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6685         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6686         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6687         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6688
6689         /* Loopback mixer controls */
6690         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6691         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6692         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6693         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6694         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6695         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6696         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6697         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6698         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6699         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6700         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6701         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6702         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6703         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6704
6705         /* Controls for GPIO pins, assuming they are configured as outputs */
6706         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6707         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6708         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6709         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6710
6711         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6712          * is ambigious as to which NID is which; testing on laptops which
6713          * make this output available should provide clarification.
6714          */
6715         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6716         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6717
6718         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6719          * this output to turn on an external amplifier.
6720          */
6721         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6722         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6723
6724         { } /* end */
6725 };
6726 static struct hda_verb alc260_test_init_verbs[] = {
6727         /* Enable all GPIOs as outputs with an initial value of 0 */
6728         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6729         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6730         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6731
6732         /* Enable retasking pins as output, initially without power amp */
6733         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6734         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6735         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6737         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6738         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6739
6740         /* Disable digital (SPDIF) pins initially, but users can enable
6741          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6742          * payload also sets the generation to 0, output to be in "consumer"
6743          * PCM format, copyright asserted, no pre-emphasis and no validity
6744          * control.
6745          */
6746         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6747         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6748
6749         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6750          * OUT1 sum bus when acting as an output.
6751          */
6752         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6753         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6754         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6755         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6756
6757         /* Start with output sum widgets muted and their output gains at min */
6758         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6759         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6760         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6761         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6762         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6763         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6764         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6765         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6766         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6767
6768         /* Unmute retasking pin widget output buffers since the default
6769          * state appears to be output.  As the pin mode is changed by the
6770          * user the pin mode control will take care of enabling the pin's
6771          * input/output buffers as needed.
6772          */
6773         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6774         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6775         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6776         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6777         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6778         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6779         /* Also unmute the mono-out pin widget */
6780         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6781
6782         /* Mute capture amp left and right */
6783         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6784         /* Set ADC connection select to match default mixer setting (mic1
6785          * pin)
6786          */
6787         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6788
6789         /* Do the same for the second ADC: mute capture input amp and
6790          * set ADC connection to mic1 pin
6791          */
6792         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6793         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6794
6795         /* Mute all inputs to mixer widget (even unconnected ones) */
6796         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6797         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6798         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6799         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6800         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6801         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6802         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6803         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6804
6805         { }
6806 };
6807 #endif
6808
6809 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6810 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6811
6812 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6813 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6814
6815 /*
6816  * for BIOS auto-configuration
6817  */
6818
6819 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6820                                         const char *pfx, int *vol_bits)
6821 {
6822         hda_nid_t nid_vol;
6823         unsigned long vol_val, sw_val;
6824         int err;
6825
6826         if (nid >= 0x0f && nid < 0x11) {
6827                 nid_vol = nid - 0x7;
6828                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6829                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6830         } else if (nid == 0x11) {
6831                 nid_vol = nid - 0x7;
6832                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6833                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6834         } else if (nid >= 0x12 && nid <= 0x15) {
6835                 nid_vol = 0x08;
6836                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6837                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6838         } else
6839                 return 0; /* N/A */
6840
6841         if (!(*vol_bits & (1 << nid_vol))) {
6842                 /* first control for the volume widget */
6843                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6844                 if (err < 0)
6845                         return err;
6846                 *vol_bits |= (1 << nid_vol);
6847         }
6848         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6849         if (err < 0)
6850                 return err;
6851         return 1;
6852 }
6853
6854 /* add playback controls from the parsed DAC table */
6855 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6856                                              const struct auto_pin_cfg *cfg)
6857 {
6858         hda_nid_t nid;
6859         int err;
6860         int vols = 0;
6861
6862         spec->multiout.num_dacs = 1;
6863         spec->multiout.dac_nids = spec->private_dac_nids;
6864         spec->multiout.dac_nids[0] = 0x02;
6865
6866         nid = cfg->line_out_pins[0];
6867         if (nid) {
6868                 const char *pfx;
6869                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6870                         pfx = "Master";
6871                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6872                         pfx = "Speaker";
6873                 else
6874                         pfx = "Front";
6875                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6876                 if (err < 0)
6877                         return err;
6878         }
6879
6880         nid = cfg->speaker_pins[0];
6881         if (nid) {
6882                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6883                 if (err < 0)
6884                         return err;
6885         }
6886
6887         nid = cfg->hp_pins[0];
6888         if (nid) {
6889                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6890                                                    &vols);
6891                 if (err < 0)
6892                         return err;
6893         }
6894         return 0;
6895 }
6896
6897 /* create playback/capture controls for input pins */
6898 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6899                                                 const struct auto_pin_cfg *cfg)
6900 {
6901         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6902 }
6903
6904 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6905                                               hda_nid_t nid, int pin_type,
6906                                               int sel_idx)
6907 {
6908         alc_set_pin_output(codec, nid, pin_type);
6909         /* need the manual connection? */
6910         if (nid >= 0x12) {
6911                 int idx = nid - 0x12;
6912                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6913                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6914         }
6915 }
6916
6917 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6918 {
6919         struct alc_spec *spec = codec->spec;
6920         hda_nid_t nid;
6921
6922         nid = spec->autocfg.line_out_pins[0];
6923         if (nid) {
6924                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6925                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6926         }
6927
6928         nid = spec->autocfg.speaker_pins[0];
6929         if (nid)
6930                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6931
6932         nid = spec->autocfg.hp_pins[0];
6933         if (nid)
6934                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6935 }
6936
6937 #define ALC260_PIN_CD_NID               0x16
6938 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6939 {
6940         struct alc_spec *spec = codec->spec;
6941         struct auto_pin_cfg *cfg = &spec->autocfg;
6942         int i;
6943
6944         for (i = 0; i < cfg->num_inputs; i++) {
6945                 hda_nid_t nid = cfg->inputs[i].pin;
6946                 if (nid >= 0x12) {
6947                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6948                         if (nid != ALC260_PIN_CD_NID &&
6949                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6950                                 snd_hda_codec_write(codec, nid, 0,
6951                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6952                                                     AMP_OUT_MUTE);
6953                 }
6954         }
6955 }
6956
6957 #define alc260_auto_init_input_src      alc880_auto_init_input_src
6958
6959 /*
6960  * generic initialization of ADC, input mixers and output mixers
6961  */
6962 static struct hda_verb alc260_volume_init_verbs[] = {
6963         /*
6964          * Unmute ADC0-1 and set the default input to mic-in
6965          */
6966         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6967         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6968         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6969         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6970
6971         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6972          * mixer widget
6973          * Note: PASD motherboards uses the Line In 2 as the input for
6974          * front panel mic (mic 2)
6975          */
6976         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6977         /* mute analog inputs */
6978         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6979         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6980         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6981         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6982         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6983
6984         /*
6985          * Set up output mixers (0x08 - 0x0a)
6986          */
6987         /* set vol=0 to output mixers */
6988         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6989         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6990         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6991         /* set up input amps for analog loopback */
6992         /* Amp Indices: DAC = 0, mixer = 1 */
6993         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6994         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6995         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6996         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6997         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6998         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6999
7000         { }
7001 };
7002
7003 static int alc260_parse_auto_config(struct hda_codec *codec)
7004 {
7005         struct alc_spec *spec = codec->spec;
7006         int err;
7007         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
7008
7009         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7010                                            alc260_ignore);
7011         if (err < 0)
7012                 return err;
7013         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7014         if (err < 0)
7015                 return err;
7016         if (!spec->kctls.list)
7017                 return 0; /* can't find valid BIOS pin config */
7018         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7019         if (err < 0)
7020                 return err;
7021
7022         spec->multiout.max_channels = 2;
7023
7024         if (spec->autocfg.dig_outs)
7025                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7026         if (spec->kctls.list)
7027                 add_mixer(spec, spec->kctls.list);
7028
7029         add_verb(spec, alc260_volume_init_verbs);
7030
7031         spec->num_mux_defs = 1;
7032         spec->input_mux = &spec->private_imux[0];
7033
7034         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7035
7036         return 1;
7037 }
7038
7039 /* additional initialization for auto-configuration model */
7040 static void alc260_auto_init(struct hda_codec *codec)
7041 {
7042         struct alc_spec *spec = codec->spec;
7043         alc260_auto_init_multi_out(codec);
7044         alc260_auto_init_analog_input(codec);
7045         alc260_auto_init_input_src(codec);
7046         alc_auto_init_digital(codec);
7047         if (spec->unsol_event)
7048                 alc_inithook(codec);
7049 }
7050
7051 #ifdef CONFIG_SND_HDA_POWER_SAVE
7052 static struct hda_amp_list alc260_loopbacks[] = {
7053         { 0x07, HDA_INPUT, 0 },
7054         { 0x07, HDA_INPUT, 1 },
7055         { 0x07, HDA_INPUT, 2 },
7056         { 0x07, HDA_INPUT, 3 },
7057         { 0x07, HDA_INPUT, 4 },
7058         { } /* end */
7059 };
7060 #endif
7061
7062 /*
7063  * Pin config fixes
7064  */
7065 enum {
7066         PINFIX_HP_DC5750,
7067 };
7068
7069 static const struct alc_fixup alc260_fixups[] = {
7070         [PINFIX_HP_DC5750] = {
7071                 .pins = (const struct alc_pincfg[]) {
7072                         { 0x11, 0x90130110 }, /* speaker */
7073                         { }
7074                 }
7075         },
7076 };
7077
7078 static struct snd_pci_quirk alc260_fixup_tbl[] = {
7079         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7080         {}
7081 };
7082
7083 /*
7084  * ALC260 configurations
7085  */
7086 static const char *alc260_models[ALC260_MODEL_LAST] = {
7087         [ALC260_BASIC]          = "basic",
7088         [ALC260_HP]             = "hp",
7089         [ALC260_HP_3013]        = "hp-3013",
7090         [ALC260_HP_DC7600]      = "hp-dc7600",
7091         [ALC260_FUJITSU_S702X]  = "fujitsu",
7092         [ALC260_ACER]           = "acer",
7093         [ALC260_WILL]           = "will",
7094         [ALC260_REPLACER_672V]  = "replacer",
7095         [ALC260_FAVORIT100]     = "favorit100",
7096 #ifdef CONFIG_SND_DEBUG
7097         [ALC260_TEST]           = "test",
7098 #endif
7099         [ALC260_AUTO]           = "auto",
7100 };
7101
7102 static struct snd_pci_quirk alc260_cfg_tbl[] = {
7103         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7104         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7105         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7106         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7107         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7108         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7109         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7110         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7111         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7112         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7113         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7114         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7115         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7116         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7117         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7118         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7119         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7120         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7121         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7122         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7123         {}
7124 };
7125
7126 static struct alc_config_preset alc260_presets[] = {
7127         [ALC260_BASIC] = {
7128                 .mixers = { alc260_base_output_mixer,
7129                             alc260_input_mixer },
7130                 .init_verbs = { alc260_init_verbs },
7131                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7132                 .dac_nids = alc260_dac_nids,
7133                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7134                 .adc_nids = alc260_dual_adc_nids,
7135                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7136                 .channel_mode = alc260_modes,
7137                 .input_mux = &alc260_capture_source,
7138         },
7139         [ALC260_HP] = {
7140                 .mixers = { alc260_hp_output_mixer,
7141                             alc260_input_mixer },
7142                 .init_verbs = { alc260_init_verbs,
7143                                 alc260_hp_unsol_verbs },
7144                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7145                 .dac_nids = alc260_dac_nids,
7146                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7147                 .adc_nids = alc260_adc_nids_alt,
7148                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7149                 .channel_mode = alc260_modes,
7150                 .input_mux = &alc260_capture_source,
7151                 .unsol_event = alc260_hp_unsol_event,
7152                 .init_hook = alc260_hp_automute,
7153         },
7154         [ALC260_HP_DC7600] = {
7155                 .mixers = { alc260_hp_dc7600_mixer,
7156                             alc260_input_mixer },
7157                 .init_verbs = { alc260_init_verbs,
7158                                 alc260_hp_dc7600_verbs },
7159                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7160                 .dac_nids = alc260_dac_nids,
7161                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7162                 .adc_nids = alc260_adc_nids_alt,
7163                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7164                 .channel_mode = alc260_modes,
7165                 .input_mux = &alc260_capture_source,
7166                 .unsol_event = alc260_hp_3012_unsol_event,
7167                 .init_hook = alc260_hp_3012_automute,
7168         },
7169         [ALC260_HP_3013] = {
7170                 .mixers = { alc260_hp_3013_mixer,
7171                             alc260_input_mixer },
7172                 .init_verbs = { alc260_hp_3013_init_verbs,
7173                                 alc260_hp_3013_unsol_verbs },
7174                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7175                 .dac_nids = alc260_dac_nids,
7176                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7177                 .adc_nids = alc260_adc_nids_alt,
7178                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7179                 .channel_mode = alc260_modes,
7180                 .input_mux = &alc260_capture_source,
7181                 .unsol_event = alc260_hp_3013_unsol_event,
7182                 .init_hook = alc260_hp_3013_automute,
7183         },
7184         [ALC260_FUJITSU_S702X] = {
7185                 .mixers = { alc260_fujitsu_mixer },
7186                 .init_verbs = { alc260_fujitsu_init_verbs },
7187                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7188                 .dac_nids = alc260_dac_nids,
7189                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7190                 .adc_nids = alc260_dual_adc_nids,
7191                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7192                 .channel_mode = alc260_modes,
7193                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7194                 .input_mux = alc260_fujitsu_capture_sources,
7195         },
7196         [ALC260_ACER] = {
7197                 .mixers = { alc260_acer_mixer },
7198                 .init_verbs = { alc260_acer_init_verbs },
7199                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7200                 .dac_nids = alc260_dac_nids,
7201                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7202                 .adc_nids = alc260_dual_adc_nids,
7203                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7204                 .channel_mode = alc260_modes,
7205                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7206                 .input_mux = alc260_acer_capture_sources,
7207         },
7208         [ALC260_FAVORIT100] = {
7209                 .mixers = { alc260_favorit100_mixer },
7210                 .init_verbs = { alc260_favorit100_init_verbs },
7211                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7212                 .dac_nids = alc260_dac_nids,
7213                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7214                 .adc_nids = alc260_dual_adc_nids,
7215                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7216                 .channel_mode = alc260_modes,
7217                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7218                 .input_mux = alc260_favorit100_capture_sources,
7219         },
7220         [ALC260_WILL] = {
7221                 .mixers = { alc260_will_mixer },
7222                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7223                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7224                 .dac_nids = alc260_dac_nids,
7225                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7226                 .adc_nids = alc260_adc_nids,
7227                 .dig_out_nid = ALC260_DIGOUT_NID,
7228                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7229                 .channel_mode = alc260_modes,
7230                 .input_mux = &alc260_capture_source,
7231         },
7232         [ALC260_REPLACER_672V] = {
7233                 .mixers = { alc260_replacer_672v_mixer },
7234                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7235                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7236                 .dac_nids = alc260_dac_nids,
7237                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7238                 .adc_nids = alc260_adc_nids,
7239                 .dig_out_nid = ALC260_DIGOUT_NID,
7240                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7241                 .channel_mode = alc260_modes,
7242                 .input_mux = &alc260_capture_source,
7243                 .unsol_event = alc260_replacer_672v_unsol_event,
7244                 .init_hook = alc260_replacer_672v_automute,
7245         },
7246 #ifdef CONFIG_SND_DEBUG
7247         [ALC260_TEST] = {
7248                 .mixers = { alc260_test_mixer },
7249                 .init_verbs = { alc260_test_init_verbs },
7250                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7251                 .dac_nids = alc260_test_dac_nids,
7252                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7253                 .adc_nids = alc260_test_adc_nids,
7254                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7255                 .channel_mode = alc260_modes,
7256                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7257                 .input_mux = alc260_test_capture_sources,
7258         },
7259 #endif
7260 };
7261
7262 static int patch_alc260(struct hda_codec *codec)
7263 {
7264         struct alc_spec *spec;
7265         int err, board_config;
7266
7267         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7268         if (spec == NULL)
7269                 return -ENOMEM;
7270
7271         codec->spec = spec;
7272
7273         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7274                                                   alc260_models,
7275                                                   alc260_cfg_tbl);
7276         if (board_config < 0) {
7277                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7278                            codec->chip_name);
7279                 board_config = ALC260_AUTO;
7280         }
7281
7282         if (board_config == ALC260_AUTO)
7283                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7284
7285         if (board_config == ALC260_AUTO) {
7286                 /* automatic parse from the BIOS config */
7287                 err = alc260_parse_auto_config(codec);
7288                 if (err < 0) {
7289                         alc_free(codec);
7290                         return err;
7291                 } else if (!err) {
7292                         printk(KERN_INFO
7293                                "hda_codec: Cannot set up configuration "
7294                                "from BIOS.  Using base mode...\n");
7295                         board_config = ALC260_BASIC;
7296                 }
7297         }
7298
7299         err = snd_hda_attach_beep_device(codec, 0x1);
7300         if (err < 0) {
7301                 alc_free(codec);
7302                 return err;
7303         }
7304
7305         if (board_config != ALC260_AUTO)
7306                 setup_preset(codec, &alc260_presets[board_config]);
7307
7308         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7309         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7310         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7311
7312         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7313         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7314
7315         if (!spec->adc_nids && spec->input_mux) {
7316                 /* check whether NID 0x04 is valid */
7317                 unsigned int wcap = get_wcaps(codec, 0x04);
7318                 wcap = get_wcaps_type(wcap);
7319                 /* get type */
7320                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7321                         spec->adc_nids = alc260_adc_nids_alt;
7322                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7323                 } else {
7324                         spec->adc_nids = alc260_adc_nids;
7325                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7326                 }
7327         }
7328         set_capture_mixer(codec);
7329         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7330
7331         if (board_config == ALC260_AUTO)
7332                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7333
7334         spec->vmaster_nid = 0x08;
7335
7336         codec->patch_ops = alc_patch_ops;
7337         if (board_config == ALC260_AUTO)
7338                 spec->init_hook = alc260_auto_init;
7339 #ifdef CONFIG_SND_HDA_POWER_SAVE
7340         if (!spec->loopback.amplist)
7341                 spec->loopback.amplist = alc260_loopbacks;
7342 #endif
7343
7344         return 0;
7345 }
7346
7347
7348 /*
7349  * ALC882/883/885/888/889 support
7350  *
7351  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7352  * configuration.  Each pin widget can choose any input DACs and a mixer.
7353  * Each ADC is connected from a mixer of all inputs.  This makes possible
7354  * 6-channel independent captures.
7355  *
7356  * In addition, an independent DAC for the multi-playback (not used in this
7357  * driver yet).
7358  */
7359 #define ALC882_DIGOUT_NID       0x06
7360 #define ALC882_DIGIN_NID        0x0a
7361 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7362 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7363 #define ALC1200_DIGOUT_NID      0x10
7364
7365
7366 static struct hda_channel_mode alc882_ch_modes[1] = {
7367         { 8, NULL }
7368 };
7369
7370 /* DACs */
7371 static hda_nid_t alc882_dac_nids[4] = {
7372         /* front, rear, clfe, rear_surr */
7373         0x02, 0x03, 0x04, 0x05
7374 };
7375 #define alc883_dac_nids         alc882_dac_nids
7376
7377 /* ADCs */
7378 #define alc882_adc_nids         alc880_adc_nids
7379 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7380 #define alc883_adc_nids         alc882_adc_nids_alt
7381 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7382 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7383 #define alc889_adc_nids         alc880_adc_nids
7384
7385 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7386 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7387 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7388 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7389 #define alc889_capsrc_nids      alc882_capsrc_nids
7390
7391 /* input MUX */
7392 /* FIXME: should be a matrix-type input source selection */
7393
7394 static struct hda_input_mux alc882_capture_source = {
7395         .num_items = 4,
7396         .items = {
7397                 { "Mic", 0x0 },
7398                 { "Front Mic", 0x1 },
7399                 { "Line", 0x2 },
7400                 { "CD", 0x4 },
7401         },
7402 };
7403
7404 #define alc883_capture_source   alc882_capture_source
7405
7406 static struct hda_input_mux alc889_capture_source = {
7407         .num_items = 3,
7408         .items = {
7409                 { "Front Mic", 0x0 },
7410                 { "Mic", 0x3 },
7411                 { "Line", 0x2 },
7412         },
7413 };
7414
7415 static struct hda_input_mux mb5_capture_source = {
7416         .num_items = 3,
7417         .items = {
7418                 { "Mic", 0x1 },
7419                 { "Line", 0x7 },
7420                 { "CD", 0x4 },
7421         },
7422 };
7423
7424 static struct hda_input_mux macmini3_capture_source = {
7425         .num_items = 2,
7426         .items = {
7427                 { "Line", 0x2 },
7428                 { "CD", 0x4 },
7429         },
7430 };
7431
7432 static struct hda_input_mux alc883_3stack_6ch_intel = {
7433         .num_items = 4,
7434         .items = {
7435                 { "Mic", 0x1 },
7436                 { "Front Mic", 0x0 },
7437                 { "Line", 0x2 },
7438                 { "CD", 0x4 },
7439         },
7440 };
7441
7442 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7443         .num_items = 2,
7444         .items = {
7445                 { "Mic", 0x1 },
7446                 { "Line", 0x2 },
7447         },
7448 };
7449
7450 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7451         .num_items = 4,
7452         .items = {
7453                 { "Mic", 0x0 },
7454                 { "Int Mic", 0x1 },
7455                 { "Line", 0x2 },
7456                 { "CD", 0x4 },
7457         },
7458 };
7459
7460 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7461         .num_items = 2,
7462         .items = {
7463                 { "Mic", 0x0 },
7464                 { "Int Mic", 0x1 },
7465         },
7466 };
7467
7468 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7469         .num_items = 3,
7470         .items = {
7471                 { "Mic", 0x0 },
7472                 { "Front Mic", 0x1 },
7473                 { "Line", 0x4 },
7474         },
7475 };
7476
7477 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7478         .num_items = 2,
7479         .items = {
7480                 { "Mic", 0x0 },
7481                 { "Line", 0x2 },
7482         },
7483 };
7484
7485 static struct hda_input_mux alc889A_mb31_capture_source = {
7486         .num_items = 2,
7487         .items = {
7488                 { "Mic", 0x0 },
7489                 /* Front Mic (0x01) unused */
7490                 { "Line", 0x2 },
7491                 /* Line 2 (0x03) unused */
7492                 /* CD (0x04) unused? */
7493         },
7494 };
7495
7496 static struct hda_input_mux alc889A_imac91_capture_source = {
7497         .num_items = 2,
7498         .items = {
7499                 { "Mic", 0x01 },
7500                 { "Line", 0x2 }, /* Not sure! */
7501         },
7502 };
7503
7504 /*
7505  * 2ch mode
7506  */
7507 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7508         { 2, NULL }
7509 };
7510
7511 /*
7512  * 2ch mode
7513  */
7514 static struct hda_verb alc882_3ST_ch2_init[] = {
7515         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7516         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7517         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7518         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7519         { } /* end */
7520 };
7521
7522 /*
7523  * 4ch mode
7524  */
7525 static struct hda_verb alc882_3ST_ch4_init[] = {
7526         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7527         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7528         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7529         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7530         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7531         { } /* end */
7532 };
7533
7534 /*
7535  * 6ch mode
7536  */
7537 static struct hda_verb alc882_3ST_ch6_init[] = {
7538         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7539         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7540         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7541         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7542         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7543         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7544         { } /* end */
7545 };
7546
7547 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7548         { 2, alc882_3ST_ch2_init },
7549         { 4, alc882_3ST_ch4_init },
7550         { 6, alc882_3ST_ch6_init },
7551 };
7552
7553 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7554
7555 /*
7556  * 2ch mode
7557  */
7558 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7559         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7560         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7561         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7562         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7563         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7564         { } /* end */
7565 };
7566
7567 /*
7568  * 4ch mode
7569  */
7570 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7571         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7572         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7573         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7574         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7575         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7576         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7577         { } /* end */
7578 };
7579
7580 /*
7581  * 6ch mode
7582  */
7583 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7584         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7585         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7586         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7587         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7588         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7589         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7590         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7591         { } /* end */
7592 };
7593
7594 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7595         { 2, alc883_3ST_ch2_clevo_init },
7596         { 4, alc883_3ST_ch4_clevo_init },
7597         { 6, alc883_3ST_ch6_clevo_init },
7598 };
7599
7600
7601 /*
7602  * 6ch mode
7603  */
7604 static struct hda_verb alc882_sixstack_ch6_init[] = {
7605         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7606         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7607         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7608         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7609         { } /* end */
7610 };
7611
7612 /*
7613  * 8ch mode
7614  */
7615 static struct hda_verb alc882_sixstack_ch8_init[] = {
7616         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7617         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7618         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7619         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7620         { } /* end */
7621 };
7622
7623 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7624         { 6, alc882_sixstack_ch6_init },
7625         { 8, alc882_sixstack_ch8_init },
7626 };
7627
7628
7629 /* Macbook Air 2,1 */
7630
7631 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7632       { 2, NULL },
7633 };
7634
7635 /*
7636  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7637  */
7638
7639 /*
7640  * 2ch mode
7641  */
7642 static struct hda_verb alc885_mbp_ch2_init[] = {
7643         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7644         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7645         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7646         { } /* end */
7647 };
7648
7649 /*
7650  * 4ch mode
7651  */
7652 static struct hda_verb alc885_mbp_ch4_init[] = {
7653         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7654         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7655         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7656         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7657         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7658         { } /* end */
7659 };
7660
7661 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7662         { 2, alc885_mbp_ch2_init },
7663         { 4, alc885_mbp_ch4_init },
7664 };
7665
7666 /*
7667  * 2ch
7668  * Speakers/Woofer/HP = Front
7669  * LineIn = Input
7670  */
7671 static struct hda_verb alc885_mb5_ch2_init[] = {
7672         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7673         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7674         { } /* end */
7675 };
7676
7677 /*
7678  * 6ch mode
7679  * Speakers/HP = Front
7680  * Woofer = LFE
7681  * LineIn = Surround
7682  */
7683 static struct hda_verb alc885_mb5_ch6_init[] = {
7684         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7685         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7686         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7687         { } /* end */
7688 };
7689
7690 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7691         { 2, alc885_mb5_ch2_init },
7692         { 6, alc885_mb5_ch6_init },
7693 };
7694
7695 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7696
7697 /*
7698  * 2ch mode
7699  */
7700 static struct hda_verb alc883_4ST_ch2_init[] = {
7701         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7702         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7703         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7704         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7705         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7706         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7707         { } /* end */
7708 };
7709
7710 /*
7711  * 4ch mode
7712  */
7713 static struct hda_verb alc883_4ST_ch4_init[] = {
7714         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7715         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7716         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7717         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7718         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7719         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7720         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7721         { } /* end */
7722 };
7723
7724 /*
7725  * 6ch mode
7726  */
7727 static struct hda_verb alc883_4ST_ch6_init[] = {
7728         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7729         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7730         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7731         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7732         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7733         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7734         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7735         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7736         { } /* end */
7737 };
7738
7739 /*
7740  * 8ch mode
7741  */
7742 static struct hda_verb alc883_4ST_ch8_init[] = {
7743         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7744         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7745         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7746         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7747         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7748         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7749         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7750         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7751         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7752         { } /* end */
7753 };
7754
7755 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7756         { 2, alc883_4ST_ch2_init },
7757         { 4, alc883_4ST_ch4_init },
7758         { 6, alc883_4ST_ch6_init },
7759         { 8, alc883_4ST_ch8_init },
7760 };
7761
7762
7763 /*
7764  * 2ch mode
7765  */
7766 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7767         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7768         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7769         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7770         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7771         { } /* end */
7772 };
7773
7774 /*
7775  * 4ch mode
7776  */
7777 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7778         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7779         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7780         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7781         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7782         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7783         { } /* end */
7784 };
7785
7786 /*
7787  * 6ch mode
7788  */
7789 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7790         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7791         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7792         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7793         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7794         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7795         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7796         { } /* end */
7797 };
7798
7799 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7800         { 2, alc883_3ST_ch2_intel_init },
7801         { 4, alc883_3ST_ch4_intel_init },
7802         { 6, alc883_3ST_ch6_intel_init },
7803 };
7804
7805 /*
7806  * 2ch mode
7807  */
7808 static struct hda_verb alc889_ch2_intel_init[] = {
7809         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7810         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7811         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7812         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7813         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7814         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7815         { } /* end */
7816 };
7817
7818 /*
7819  * 6ch mode
7820  */
7821 static struct hda_verb alc889_ch6_intel_init[] = {
7822         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7823         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7824         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7825         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7826         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7827         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7828         { } /* end */
7829 };
7830
7831 /*
7832  * 8ch mode
7833  */
7834 static struct hda_verb alc889_ch8_intel_init[] = {
7835         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7836         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7837         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7838         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7839         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7840         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7841         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7842         { } /* end */
7843 };
7844
7845 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7846         { 2, alc889_ch2_intel_init },
7847         { 6, alc889_ch6_intel_init },
7848         { 8, alc889_ch8_intel_init },
7849 };
7850
7851 /*
7852  * 6ch mode
7853  */
7854 static struct hda_verb alc883_sixstack_ch6_init[] = {
7855         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7856         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7857         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7858         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7859         { } /* end */
7860 };
7861
7862 /*
7863  * 8ch mode
7864  */
7865 static struct hda_verb alc883_sixstack_ch8_init[] = {
7866         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7867         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7868         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7869         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7870         { } /* end */
7871 };
7872
7873 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7874         { 6, alc883_sixstack_ch6_init },
7875         { 8, alc883_sixstack_ch8_init },
7876 };
7877
7878
7879 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7880  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7881  */
7882 static struct snd_kcontrol_new alc882_base_mixer[] = {
7883         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7884         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7885         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7886         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7887         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7888         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7889         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7890         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7891         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7892         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7893         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7894         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7895         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7896         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7897         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7899         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7900         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7901         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7902         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7903         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7904         { } /* end */
7905 };
7906
7907 /* Macbook Air 2,1 same control for HP and internal Speaker */
7908
7909 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7910       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7911       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7912      { }
7913 };
7914
7915
7916 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7917         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7918         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7919         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7920         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7921         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7922         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7923         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7924         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7925         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7926         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7927         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7928         { } /* end */
7929 };
7930
7931 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7932         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7933         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7934         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7935         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7936         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7937         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7938         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7939         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7940         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7941         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7942         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7943         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7944         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7945         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7946         { } /* end */
7947 };
7948
7949 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7950         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7951         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7952         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7953         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7954         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7955         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7956         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7957         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7958         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7959         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7960         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7961         { } /* end */
7962 };
7963
7964 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7965         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7966         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7967         { } /* end */
7968 };
7969
7970
7971 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7972         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7973         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7974         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7975         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7976         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7977         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7978         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7979         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7980         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7981         { } /* end */
7982 };
7983
7984 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7985         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7986         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7987         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7988         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7989         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7990         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7991         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7992         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7993         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7995         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7996         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7997         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7998         { } /* end */
7999 };
8000
8001 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8002  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8003  */
8004 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8005         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8006         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8007         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8008         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8009         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8010         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8011         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8012         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8013         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8014         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8015         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8016         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8017         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8018         { } /* end */
8019 };
8020
8021 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8022         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8023         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8024         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8025         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8026         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8027         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8028         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8029         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8030         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8031         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8032         { } /* end */
8033 };
8034
8035 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
8036         {
8037                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8038                 .name = "Channel Mode",
8039                 .info = alc_ch_mode_info,
8040                 .get = alc_ch_mode_get,
8041                 .put = alc_ch_mode_put,
8042         },
8043         { } /* end */
8044 };
8045
8046 static struct hda_verb alc882_base_init_verbs[] = {
8047         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8048         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8049         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8050         /* Rear mixer */
8051         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8052         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8053         /* CLFE mixer */
8054         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8055         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8056         /* Side mixer */
8057         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8058         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8059
8060         /* Front Pin: output 0 (0x0c) */
8061         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8062         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8063         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8064         /* Rear Pin: output 1 (0x0d) */
8065         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8066         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8067         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8068         /* CLFE Pin: output 2 (0x0e) */
8069         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8070         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8071         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8072         /* Side Pin: output 3 (0x0f) */
8073         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8074         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8075         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8076         /* Mic (rear) pin: input vref at 80% */
8077         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8078         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8079         /* Front Mic pin: input vref at 80% */
8080         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8081         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8082         /* Line In pin: input */
8083         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8084         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8085         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8086         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8087         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8088         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8089         /* CD pin widget for input */
8090         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8091
8092         /* FIXME: use matrix-type input source selection */
8093         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8094         /* Input mixer2 */
8095         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8096         /* Input mixer3 */
8097         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8098         /* ADC2: mute amp left and right */
8099         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8100         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8101         /* ADC3: mute amp left and right */
8102         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8103         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8104
8105         { }
8106 };
8107
8108 static struct hda_verb alc882_adc1_init_verbs[] = {
8109         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8110         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8111         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8112         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8113         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8114         /* ADC1: mute amp left and right */
8115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8116         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8117         { }
8118 };
8119
8120 static struct hda_verb alc882_eapd_verbs[] = {
8121         /* change to EAPD mode */
8122         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8123         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8124         { }
8125 };
8126
8127 static struct hda_verb alc889_eapd_verbs[] = {
8128         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8129         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8130         { }
8131 };
8132
8133 static struct hda_verb alc_hp15_unsol_verbs[] = {
8134         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8135         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8136         {}
8137 };
8138
8139 static struct hda_verb alc885_init_verbs[] = {
8140         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8141         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8142         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8143         /* Rear mixer */
8144         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8145         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8146         /* CLFE mixer */
8147         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8148         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8149         /* Side mixer */
8150         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8151         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8152
8153         /* Front HP Pin: output 0 (0x0c) */
8154         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8155         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8156         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8157         /* Front Pin: output 0 (0x0c) */
8158         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8159         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8160         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8161         /* Rear Pin: output 1 (0x0d) */
8162         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8163         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8164         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8165         /* CLFE Pin: output 2 (0x0e) */
8166         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8167         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8168         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8169         /* Side Pin: output 3 (0x0f) */
8170         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8171         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8172         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8173         /* Mic (rear) pin: input vref at 80% */
8174         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8175         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8176         /* Front Mic pin: input vref at 80% */
8177         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8178         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8179         /* Line In pin: input */
8180         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8181         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8182
8183         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8184         /* Input mixer1 */
8185         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8186         /* Input mixer2 */
8187         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8188         /* Input mixer3 */
8189         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8190         /* ADC2: mute amp left and right */
8191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8192         /* ADC3: mute amp left and right */
8193         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8194
8195         { }
8196 };
8197
8198 static struct hda_verb alc885_init_input_verbs[] = {
8199         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8200         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8201         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8202         { }
8203 };
8204
8205
8206 /* Unmute Selector 24h and set the default input to front mic */
8207 static struct hda_verb alc889_init_input_verbs[] = {
8208         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8210         { }
8211 };
8212
8213
8214 #define alc883_init_verbs       alc882_base_init_verbs
8215
8216 /* Mac Pro test */
8217 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8218         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8219         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8221         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8222         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8223         /* FIXME: this looks suspicious...
8224         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8225         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8226         */
8227         { } /* end */
8228 };
8229
8230 static struct hda_verb alc882_macpro_init_verbs[] = {
8231         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8232         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8233         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8234         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8235         /* Front Pin: output 0 (0x0c) */
8236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8237         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8238         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8239         /* Front Mic pin: input vref at 80% */
8240         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8241         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8242         /* Speaker:  output */
8243         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8244         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8245         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8246         /* Headphone output (output 0 - 0x0c) */
8247         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8248         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8249         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8250
8251         /* FIXME: use matrix-type input source selection */
8252         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8253         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8254         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8255         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8256         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8257         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8258         /* Input mixer2 */
8259         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8260         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8261         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8262         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8263         /* Input mixer3 */
8264         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8265         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8266         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8267         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8268         /* ADC1: mute amp left and right */
8269         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8270         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8271         /* ADC2: mute amp left and right */
8272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8273         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8274         /* ADC3: mute amp left and right */
8275         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8276         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8277
8278         { }
8279 };
8280
8281 /* Macbook 5,1 */
8282 static struct hda_verb alc885_mb5_init_verbs[] = {
8283         /* DACs */
8284         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8285         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8286         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8287         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8288         /* Front mixer */
8289         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8290         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8291         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8292         /* Surround mixer */
8293         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8294         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8295         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8296         /* LFE mixer */
8297         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8298         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8299         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8300         /* HP mixer */
8301         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8302         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8303         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8304         /* Front Pin (0x0c) */
8305         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8306         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8307         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8308         /* LFE Pin (0x0e) */
8309         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8310         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8311         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8312         /* HP Pin (0x0f) */
8313         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8314         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8315         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8316         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8317         /* Front Mic pin: input vref at 80% */
8318         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8319         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8320         /* Line In pin */
8321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8323
8324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8326         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8327         { }
8328 };
8329
8330 /* Macmini 3,1 */
8331 static struct hda_verb alc885_macmini3_init_verbs[] = {
8332         /* DACs */
8333         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8334         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8335         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8336         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8337         /* Front mixer */
8338         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8339         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8340         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8341         /* Surround mixer */
8342         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8343         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8344         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8345         /* LFE mixer */
8346         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8348         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8349         /* HP mixer */
8350         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8351         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8352         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8353         /* Front Pin (0x0c) */
8354         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8355         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8356         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8357         /* LFE Pin (0x0e) */
8358         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8359         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8360         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8361         /* HP Pin (0x0f) */
8362         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8363         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8364         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8365         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8366         /* Line In pin */
8367         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8368         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8369
8370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8371         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8372         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8373         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8374         { }
8375 };
8376
8377
8378 static struct hda_verb alc885_mba21_init_verbs[] = {
8379         /*Internal and HP Speaker Mixer*/
8380         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8381         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8382         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8383         /*Internal Speaker Pin (0x0c)*/
8384         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8385         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8386         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8387         /* HP Pin: output 0 (0x0e) */
8388         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8389         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8390         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8391         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8392         /* Line in (is hp when jack connected)*/
8393         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8394         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8395
8396         { }
8397  };
8398
8399
8400 /* Macbook Pro rev3 */
8401 static struct hda_verb alc885_mbp3_init_verbs[] = {
8402         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8404         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8405         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8406         /* Rear mixer */
8407         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8408         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8409         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8410         /* HP mixer */
8411         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8412         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8413         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8414         /* Front Pin: output 0 (0x0c) */
8415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8416         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8417         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8418         /* HP Pin: output 0 (0x0e) */
8419         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8420         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8421         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8422         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8423         /* Mic (rear) pin: input vref at 80% */
8424         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8425         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8426         /* Front Mic pin: input vref at 80% */
8427         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8428         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8429         /* Line In pin: use output 1 when in LineOut mode */
8430         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8431         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8432         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8433
8434         /* FIXME: use matrix-type input source selection */
8435         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8436         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8438         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8439         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8440         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8441         /* Input mixer2 */
8442         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8443         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8444         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8445         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8446         /* Input mixer3 */
8447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8448         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8449         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8450         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8451         /* ADC1: mute amp left and right */
8452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8453         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8454         /* ADC2: mute amp left and right */
8455         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8456         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8457         /* ADC3: mute amp left and right */
8458         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8459         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8460
8461         { }
8462 };
8463
8464 /* iMac 9,1 */
8465 static struct hda_verb alc885_imac91_init_verbs[] = {
8466         /* Internal Speaker Pin (0x0c) */
8467         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8468         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8469         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8470         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8471         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8472         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8473         /* HP Pin: Rear */
8474         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8475         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8476         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8477         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8478         /* Line in Rear */
8479         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8480         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8481         /* Front Mic pin: input vref at 80% */
8482         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8483         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8484         /* Rear mixer */
8485         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8486         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8487         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8488         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8489         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8490         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8491         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8492         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8493         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8494         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8495         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8496         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8497         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8498         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8499         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8500         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8501         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8502         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8503         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8504         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8505         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8506         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8507         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8508         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8509         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8510         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8511         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8512         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8513         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8514         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8515         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8516         { }
8517 };
8518
8519 /* iMac 24 mixer. */
8520 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8521         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8522         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8523         { } /* end */
8524 };
8525
8526 /* iMac 24 init verbs. */
8527 static struct hda_verb alc885_imac24_init_verbs[] = {
8528         /* Internal speakers: output 0 (0x0c) */
8529         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8530         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8531         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8532         /* Internal speakers: output 0 (0x0c) */
8533         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8534         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8535         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8536         /* Headphone: output 0 (0x0c) */
8537         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8538         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8539         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8540         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8541         /* Front Mic: input vref at 80% */
8542         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8543         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8544         { }
8545 };
8546
8547 /* Toggle speaker-output according to the hp-jack state */
8548 static void alc885_imac24_setup(struct hda_codec *codec)
8549 {
8550         struct alc_spec *spec = codec->spec;
8551
8552         spec->autocfg.hp_pins[0] = 0x14;
8553         spec->autocfg.speaker_pins[0] = 0x18;
8554         spec->autocfg.speaker_pins[1] = 0x1a;
8555 }
8556
8557 #define alc885_mb5_setup        alc885_imac24_setup
8558 #define alc885_macmini3_setup   alc885_imac24_setup
8559
8560 /* Macbook Air 2,1 */
8561 static void alc885_mba21_setup(struct hda_codec *codec)
8562 {
8563        struct alc_spec *spec = codec->spec;
8564
8565        spec->autocfg.hp_pins[0] = 0x14;
8566        spec->autocfg.speaker_pins[0] = 0x18;
8567 }
8568
8569
8570
8571 static void alc885_mbp3_setup(struct hda_codec *codec)
8572 {
8573         struct alc_spec *spec = codec->spec;
8574
8575         spec->autocfg.hp_pins[0] = 0x15;
8576         spec->autocfg.speaker_pins[0] = 0x14;
8577 }
8578
8579 static void alc885_imac91_setup(struct hda_codec *codec)
8580 {
8581         struct alc_spec *spec = codec->spec;
8582
8583         spec->autocfg.hp_pins[0] = 0x14;
8584         spec->autocfg.speaker_pins[0] = 0x18;
8585         spec->autocfg.speaker_pins[1] = 0x1a;
8586 }
8587
8588 static struct hda_verb alc882_targa_verbs[] = {
8589         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8590         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8591
8592         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8593         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8594
8595         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8596         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8597         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8598
8599         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8600         { } /* end */
8601 };
8602
8603 /* toggle speaker-output according to the hp-jack state */
8604 static void alc882_targa_automute(struct hda_codec *codec)
8605 {
8606         struct alc_spec *spec = codec->spec;
8607         alc_automute_amp(codec);
8608         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8609                                   spec->jack_present ? 1 : 3);
8610 }
8611
8612 static void alc882_targa_setup(struct hda_codec *codec)
8613 {
8614         struct alc_spec *spec = codec->spec;
8615
8616         spec->autocfg.hp_pins[0] = 0x14;
8617         spec->autocfg.speaker_pins[0] = 0x1b;
8618 }
8619
8620 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8621 {
8622         if ((res >> 26) == ALC880_HP_EVENT)
8623                 alc882_targa_automute(codec);
8624 }
8625
8626 static struct hda_verb alc882_asus_a7j_verbs[] = {
8627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8628         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8629
8630         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8631         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8632         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8633
8634         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8635         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8636         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8637
8638         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8639         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8640         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8641         { } /* end */
8642 };
8643
8644 static struct hda_verb alc882_asus_a7m_verbs[] = {
8645         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8646         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8647
8648         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8650         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8651
8652         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8653         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8654         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8655
8656         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8657         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8658         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8659         { } /* end */
8660 };
8661
8662 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8663 {
8664         unsigned int gpiostate, gpiomask, gpiodir;
8665
8666         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8667                                        AC_VERB_GET_GPIO_DATA, 0);
8668
8669         if (!muted)
8670                 gpiostate |= (1 << pin);
8671         else
8672                 gpiostate &= ~(1 << pin);
8673
8674         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8675                                       AC_VERB_GET_GPIO_MASK, 0);
8676         gpiomask |= (1 << pin);
8677
8678         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8679                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8680         gpiodir |= (1 << pin);
8681
8682
8683         snd_hda_codec_write(codec, codec->afg, 0,
8684                             AC_VERB_SET_GPIO_MASK, gpiomask);
8685         snd_hda_codec_write(codec, codec->afg, 0,
8686                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8687
8688         msleep(1);
8689
8690         snd_hda_codec_write(codec, codec->afg, 0,
8691                             AC_VERB_SET_GPIO_DATA, gpiostate);
8692 }
8693
8694 /* set up GPIO at initialization */
8695 static void alc885_macpro_init_hook(struct hda_codec *codec)
8696 {
8697         alc882_gpio_mute(codec, 0, 0);
8698         alc882_gpio_mute(codec, 1, 0);
8699 }
8700
8701 /* set up GPIO and update auto-muting at initialization */
8702 static void alc885_imac24_init_hook(struct hda_codec *codec)
8703 {
8704         alc885_macpro_init_hook(codec);
8705         alc_automute_amp(codec);
8706 }
8707
8708 /*
8709  * generic initialization of ADC, input mixers and output mixers
8710  */
8711 static struct hda_verb alc883_auto_init_verbs[] = {
8712         /*
8713          * Unmute ADC0-2 and set the default input to mic-in
8714          */
8715         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8716         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8717         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8718         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8719
8720         /*
8721          * Set up output mixers (0x0c - 0x0f)
8722          */
8723         /* set vol=0 to output mixers */
8724         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8725         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8726         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8727         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8728         /* set up input amps for analog loopback */
8729         /* Amp Indices: DAC = 0, mixer = 1 */
8730         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8731         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8732         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8733         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8734         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8735         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8736         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8737         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8738         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8739         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8740
8741         /* FIXME: use matrix-type input source selection */
8742         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8743         /* Input mixer2 */
8744         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8745         /* Input mixer3 */
8746         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8747         { }
8748 };
8749
8750 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8751 static struct hda_verb alc889A_mb31_ch2_init[] = {
8752         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8753         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8754         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8755         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8756         { } /* end */
8757 };
8758
8759 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8760 static struct hda_verb alc889A_mb31_ch4_init[] = {
8761         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8762         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8763         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8764         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8765         { } /* end */
8766 };
8767
8768 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8769 static struct hda_verb alc889A_mb31_ch5_init[] = {
8770         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8771         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8772         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8773         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8774         { } /* end */
8775 };
8776
8777 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8778 static struct hda_verb alc889A_mb31_ch6_init[] = {
8779         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8780         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8781         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8782         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8783         { } /* end */
8784 };
8785
8786 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8787         { 2, alc889A_mb31_ch2_init },
8788         { 4, alc889A_mb31_ch4_init },
8789         { 5, alc889A_mb31_ch5_init },
8790         { 6, alc889A_mb31_ch6_init },
8791 };
8792
8793 static struct hda_verb alc883_medion_eapd_verbs[] = {
8794         /* eanable EAPD on medion laptop */
8795         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8796         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8797         { }
8798 };
8799
8800 #define alc883_base_mixer       alc882_base_mixer
8801
8802 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8803         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8804         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8805         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8806         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8807         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8808         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8809         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8811         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8813         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8814         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8815         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8816         { } /* end */
8817 };
8818
8819 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8820         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8821         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8822         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8823         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8824         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8825         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8826         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8827         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8828         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8829         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8830         { } /* end */
8831 };
8832
8833 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8834         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8835         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8836         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8837         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8838         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8839         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8840         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8841         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8842         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8843         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8844         { } /* end */
8845 };
8846
8847 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8848         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8849         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8850         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8851         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8852         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8853         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8854         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8855         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8856         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8858         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8859         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8860         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8861         { } /* end */
8862 };
8863
8864 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8865         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8866         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8867         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8868         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8869         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8870         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8871         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8872         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8873         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8874         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8875         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8876         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8877         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8878         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8879         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8880         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8881         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8882         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8883         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8884         { } /* end */
8885 };
8886
8887 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8888         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8889         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8890         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8891         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8892         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8893                               HDA_OUTPUT),
8894         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8895         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8896         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8897         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8898         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8899         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8903         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8904         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8905         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8906         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8907         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8908         { } /* end */
8909 };
8910
8911 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8912         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8913         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8914         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8915         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8916         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8917                               HDA_OUTPUT),
8918         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8919         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8920         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8921         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8922         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8923         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8924         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8925         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8926         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8927         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8928         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8929         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8930         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8931         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8932         { } /* end */
8933 };
8934
8935 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8936         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8937         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8938         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8939         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8940         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8941         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8942         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8943         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8945         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8946         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8947         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8948         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8949         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8950         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8951         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8952         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8953         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8954         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8955         { } /* end */
8956 };
8957
8958 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8959         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8960         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8961         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8962         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8963         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8964         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8965         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8966         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8967         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8968         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8969         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8970         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8971         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8972         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8973         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8974         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8976         { } /* end */
8977 };
8978
8979 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8980         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8981         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8982         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8983         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8984         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8985         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8986         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8987         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8988         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8989         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8990         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8991         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8992         { } /* end */
8993 };
8994
8995 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8996         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8997         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8998         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8999         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9000         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9001         { } /* end */
9002 };
9003
9004 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9005         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9006         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9007         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9008         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9009         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9010         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9011         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9012         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9013         { } /* end */
9014 };
9015
9016 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9017         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9018         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9019         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9020         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9021         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9022         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9023         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9024         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9025         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9026         { } /* end */
9027 };
9028
9029 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9030         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9031         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9032         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9033         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9034         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9035         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9036         { } /* end */
9037 };
9038
9039 static struct hda_verb alc883_medion_wim2160_verbs[] = {
9040         /* Unmute front mixer */
9041         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9042         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9043
9044         /* Set speaker pin to front mixer */
9045         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9046
9047         /* Init headphone pin */
9048         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9049         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9050         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9051         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9052
9053         { } /* end */
9054 };
9055
9056 /* toggle speaker-output according to the hp-jack state */
9057 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9058 {
9059         struct alc_spec *spec = codec->spec;
9060
9061         spec->autocfg.hp_pins[0] = 0x1a;
9062         spec->autocfg.speaker_pins[0] = 0x15;
9063 }
9064
9065 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9066         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9067         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9068         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9069         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9070         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9071         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9072         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9073         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9074         { } /* end */
9075 };
9076
9077 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9078         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9079         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9080         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9081         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9082         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9083         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9084         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9085         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9086         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9087         { } /* end */
9088 };
9089
9090 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9091         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9092         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9093         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9094         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9095         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9096                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9097         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9098         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9099         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9100         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9101         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9102         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9103         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9104         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9105         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9106         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9107         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9109         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9110         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9111         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9112         { } /* end */
9113 };
9114
9115 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9116         /* Output mixers */
9117         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9118         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9119         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9120         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9121         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9122                 HDA_OUTPUT),
9123         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9124         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9125         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9126         /* Output switches */
9127         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9128         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9129         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9130         /* Boost mixers */
9131         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
9132         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
9133         /* Input mixers */
9134         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9135         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9136         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9137         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9138         { } /* end */
9139 };
9140
9141 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9142         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9143         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9144         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9145         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9146         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9147         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9148         { } /* end */
9149 };
9150
9151 static struct hda_bind_ctls alc883_bind_cap_vol = {
9152         .ops = &snd_hda_bind_vol,
9153         .values = {
9154                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9155                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9156                 0
9157         },
9158 };
9159
9160 static struct hda_bind_ctls alc883_bind_cap_switch = {
9161         .ops = &snd_hda_bind_sw,
9162         .values = {
9163                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9164                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9165                 0
9166         },
9167 };
9168
9169 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9170         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9171         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9172         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9173         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9174         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9175         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9176         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9177         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9178         { } /* end */
9179 };
9180
9181 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9182         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9183         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9184         {
9185                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9186                 /* .name = "Capture Source", */
9187                 .name = "Input Source",
9188                 .count = 1,
9189                 .info = alc_mux_enum_info,
9190                 .get = alc_mux_enum_get,
9191                 .put = alc_mux_enum_put,
9192         },
9193         { } /* end */
9194 };
9195
9196 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9197         {
9198                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9199                 .name = "Channel Mode",
9200                 .info = alc_ch_mode_info,
9201                 .get = alc_ch_mode_get,
9202                 .put = alc_ch_mode_put,
9203         },
9204         { } /* end */
9205 };
9206
9207 /* toggle speaker-output according to the hp-jack state */
9208 static void alc883_mitac_setup(struct hda_codec *codec)
9209 {
9210         struct alc_spec *spec = codec->spec;
9211
9212         spec->autocfg.hp_pins[0] = 0x15;
9213         spec->autocfg.speaker_pins[0] = 0x14;
9214         spec->autocfg.speaker_pins[1] = 0x17;
9215 }
9216
9217 static struct hda_verb alc883_mitac_verbs[] = {
9218         /* HP */
9219         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9220         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9221         /* Subwoofer */
9222         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9223         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9224
9225         /* enable unsolicited event */
9226         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9227         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9228
9229         { } /* end */
9230 };
9231
9232 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9233         /* HP */
9234         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9235         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9236         /* Int speaker */
9237         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9238
9239         /* enable unsolicited event */
9240         /*
9241         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9242         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9243         */
9244
9245         { } /* end */
9246 };
9247
9248 static struct hda_verb alc883_clevo_m720_verbs[] = {
9249         /* HP */
9250         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9251         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9252         /* Int speaker */
9253         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9254         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9255
9256         /* enable unsolicited event */
9257         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9258         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9259
9260         { } /* end */
9261 };
9262
9263 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9264         /* HP */
9265         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9266         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9267         /* Subwoofer */
9268         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9269         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9270
9271         /* enable unsolicited event */
9272         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9273
9274         { } /* end */
9275 };
9276
9277 static struct hda_verb alc883_targa_verbs[] = {
9278         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9279         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9280
9281         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9282         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9283
9284 /* Connect Line-Out side jack (SPDIF) to Side */
9285         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9286         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9287         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9288 /* Connect Mic jack to CLFE */
9289         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9290         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9291         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9292 /* Connect Line-in jack to Surround */
9293         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9294         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9295         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9296 /* Connect HP out jack to Front */
9297         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9298         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9299         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9300
9301         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9302
9303         { } /* end */
9304 };
9305
9306 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9307         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9308         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9309         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9310         { } /* end */
9311 };
9312
9313 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9314         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9315         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9316         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9317         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9318         { } /* end */
9319 };
9320
9321 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9322         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9323         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9324         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9325         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9326         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9327         { } /* end */
9328 };
9329
9330 static struct hda_verb alc883_haier_w66_verbs[] = {
9331         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9332         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9333
9334         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9335
9336         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9337         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9338         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9339         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9340         { } /* end */
9341 };
9342
9343 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9344         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9346         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9348         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9349         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9350         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9351         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9352         { } /* end */
9353 };
9354
9355 static struct hda_verb alc888_6st_dell_verbs[] = {
9356         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9357         { }
9358 };
9359
9360 static struct hda_verb alc883_vaiott_verbs[] = {
9361         /* HP */
9362         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9363         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9364
9365         /* enable unsolicited event */
9366         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9367
9368         { } /* end */
9369 };
9370
9371 static void alc888_3st_hp_setup(struct hda_codec *codec)
9372 {
9373         struct alc_spec *spec = codec->spec;
9374
9375         spec->autocfg.hp_pins[0] = 0x1b;
9376         spec->autocfg.speaker_pins[0] = 0x14;
9377         spec->autocfg.speaker_pins[1] = 0x16;
9378         spec->autocfg.speaker_pins[2] = 0x18;
9379 }
9380
9381 static struct hda_verb alc888_3st_hp_verbs[] = {
9382         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9383         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9384         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9385         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9386         { } /* end */
9387 };
9388
9389 /*
9390  * 2ch mode
9391  */
9392 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9393         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9394         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9395         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9396         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9397         { } /* end */
9398 };
9399
9400 /*
9401  * 4ch mode
9402  */
9403 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9404         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9405         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9406         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9407         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9408         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9409         { } /* end */
9410 };
9411
9412 /*
9413  * 6ch mode
9414  */
9415 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9416         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9417         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9418         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9419         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9420         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9421         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9422         { } /* end */
9423 };
9424
9425 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9426         { 2, alc888_3st_hp_2ch_init },
9427         { 4, alc888_3st_hp_4ch_init },
9428         { 6, alc888_3st_hp_6ch_init },
9429 };
9430
9431 /* toggle front-jack and RCA according to the hp-jack state */
9432 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9433 {
9434         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9435
9436         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9437                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9438         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9439                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9440 }
9441
9442 /* toggle RCA according to the front-jack state */
9443 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9444 {
9445         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9446
9447         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9448                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9449 }
9450
9451 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9452                                              unsigned int res)
9453 {
9454         if ((res >> 26) == ALC880_HP_EVENT)
9455                 alc888_lenovo_ms7195_front_automute(codec);
9456         if ((res >> 26) == ALC880_FRONT_EVENT)
9457                 alc888_lenovo_ms7195_rca_automute(codec);
9458 }
9459
9460 /* toggle speaker-output according to the hp-jack state */
9461 static void alc883_lenovo_nb0763_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 }
9468
9469 /* toggle speaker-output according to the hp-jack state */
9470 #define alc883_targa_init_hook          alc882_targa_init_hook
9471 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9472
9473 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9474 {
9475         struct alc_spec *spec = codec->spec;
9476
9477         spec->autocfg.hp_pins[0] = 0x15;
9478         spec->autocfg.speaker_pins[0] = 0x14;
9479 }
9480
9481 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9482 {
9483         alc_automute_amp(codec);
9484         alc88x_simple_mic_automute(codec);
9485 }
9486
9487 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9488                                            unsigned int res)
9489 {
9490         switch (res >> 26) {
9491         case ALC880_MIC_EVENT:
9492                 alc88x_simple_mic_automute(codec);
9493                 break;
9494         default:
9495                 alc_automute_amp_unsol_event(codec, res);
9496                 break;
9497         }
9498 }
9499
9500 /* toggle speaker-output according to the hp-jack state */
9501 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9502 {
9503         struct alc_spec *spec = codec->spec;
9504
9505         spec->autocfg.hp_pins[0] = 0x14;
9506         spec->autocfg.speaker_pins[0] = 0x15;
9507 }
9508
9509 static void alc883_haier_w66_setup(struct hda_codec *codec)
9510 {
9511         struct alc_spec *spec = codec->spec;
9512
9513         spec->autocfg.hp_pins[0] = 0x1b;
9514         spec->autocfg.speaker_pins[0] = 0x14;
9515 }
9516
9517 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9518 {
9519         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9520
9521         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9522                                  HDA_AMP_MUTE, bits);
9523 }
9524
9525 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9526 {
9527         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9528
9529         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9530                                  HDA_AMP_MUTE, bits);
9531         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9532                                  HDA_AMP_MUTE, bits);
9533 }
9534
9535 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9536                                            unsigned int res)
9537 {
9538         if ((res >> 26) == ALC880_HP_EVENT)
9539                 alc883_lenovo_101e_all_automute(codec);
9540         if ((res >> 26) == ALC880_FRONT_EVENT)
9541                 alc883_lenovo_101e_ispeaker_automute(codec);
9542 }
9543
9544 /* toggle speaker-output according to the hp-jack state */
9545 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9546 {
9547         struct alc_spec *spec = codec->spec;
9548
9549         spec->autocfg.hp_pins[0] = 0x14;
9550         spec->autocfg.speaker_pins[0] = 0x15;
9551         spec->autocfg.speaker_pins[1] = 0x16;
9552 }
9553
9554 static struct hda_verb alc883_acer_eapd_verbs[] = {
9555         /* HP Pin: output 0 (0x0c) */
9556         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9557         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9558         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9559         /* Front Pin: output 0 (0x0c) */
9560         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9561         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9562         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9563         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9564         /* eanable EAPD on medion laptop */
9565         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9566         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9567         /* enable unsolicited event */
9568         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9569         { }
9570 };
9571
9572 static void alc888_6st_dell_setup(struct hda_codec *codec)
9573 {
9574         struct alc_spec *spec = codec->spec;
9575
9576         spec->autocfg.hp_pins[0] = 0x1b;
9577         spec->autocfg.speaker_pins[0] = 0x14;
9578         spec->autocfg.speaker_pins[1] = 0x15;
9579         spec->autocfg.speaker_pins[2] = 0x16;
9580         spec->autocfg.speaker_pins[3] = 0x17;
9581 }
9582
9583 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9584 {
9585         struct alc_spec *spec = codec->spec;
9586
9587         spec->autocfg.hp_pins[0] = 0x1b;
9588         spec->autocfg.speaker_pins[0] = 0x14;
9589         spec->autocfg.speaker_pins[1] = 0x15;
9590         spec->autocfg.speaker_pins[2] = 0x16;
9591         spec->autocfg.speaker_pins[3] = 0x17;
9592         spec->autocfg.speaker_pins[4] = 0x1a;
9593 }
9594
9595 static void alc883_vaiott_setup(struct hda_codec *codec)
9596 {
9597         struct alc_spec *spec = codec->spec;
9598
9599         spec->autocfg.hp_pins[0] = 0x15;
9600         spec->autocfg.speaker_pins[0] = 0x14;
9601         spec->autocfg.speaker_pins[1] = 0x17;
9602 }
9603
9604 static struct hda_verb alc888_asus_m90v_verbs[] = {
9605         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9606         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9607         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9608         /* enable unsolicited event */
9609         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9610         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9611         { } /* end */
9612 };
9613
9614 static void alc883_mode2_setup(struct hda_codec *codec)
9615 {
9616         struct alc_spec *spec = codec->spec;
9617
9618         spec->autocfg.hp_pins[0] = 0x1b;
9619         spec->autocfg.speaker_pins[0] = 0x14;
9620         spec->autocfg.speaker_pins[1] = 0x15;
9621         spec->autocfg.speaker_pins[2] = 0x16;
9622         spec->ext_mic.pin = 0x18;
9623         spec->int_mic.pin = 0x19;
9624         spec->ext_mic.mux_idx = 0;
9625         spec->int_mic.mux_idx = 1;
9626         spec->auto_mic = 1;
9627 }
9628
9629 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9630         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9631         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9632         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9633         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9634         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9635         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9636         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9637         /* enable unsolicited event */
9638         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9639         { } /* end */
9640 };
9641
9642 static void alc883_eee1601_inithook(struct hda_codec *codec)
9643 {
9644         struct alc_spec *spec = codec->spec;
9645
9646         spec->autocfg.hp_pins[0] = 0x14;
9647         spec->autocfg.speaker_pins[0] = 0x1b;
9648         alc_automute_pin(codec);
9649 }
9650
9651 static struct hda_verb alc889A_mb31_verbs[] = {
9652         /* Init rear pin (used as headphone output) */
9653         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9654         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9655         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9656         /* Init line pin (used as output in 4ch and 6ch mode) */
9657         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9658         /* Init line 2 pin (used as headphone out by default) */
9659         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9660         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9661         { } /* end */
9662 };
9663
9664 /* Mute speakers according to the headphone jack state */
9665 static void alc889A_mb31_automute(struct hda_codec *codec)
9666 {
9667         unsigned int present;
9668
9669         /* Mute only in 2ch or 4ch mode */
9670         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9671             == 0x00) {
9672                 present = snd_hda_jack_detect(codec, 0x15);
9673                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9674                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9675                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9676                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9677         }
9678 }
9679
9680 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9681 {
9682         if ((res >> 26) == ALC880_HP_EVENT)
9683                 alc889A_mb31_automute(codec);
9684 }
9685
9686
9687 #ifdef CONFIG_SND_HDA_POWER_SAVE
9688 #define alc882_loopbacks        alc880_loopbacks
9689 #endif
9690
9691 /* pcm configuration: identical with ALC880 */
9692 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9693 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9694 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9695 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9696
9697 static hda_nid_t alc883_slave_dig_outs[] = {
9698         ALC1200_DIGOUT_NID, 0,
9699 };
9700
9701 static hda_nid_t alc1200_slave_dig_outs[] = {
9702         ALC883_DIGOUT_NID, 0,
9703 };
9704
9705 /*
9706  * configuration and preset
9707  */
9708 static const char *alc882_models[ALC882_MODEL_LAST] = {
9709         [ALC882_3ST_DIG]        = "3stack-dig",
9710         [ALC882_6ST_DIG]        = "6stack-dig",
9711         [ALC882_ARIMA]          = "arima",
9712         [ALC882_W2JC]           = "w2jc",
9713         [ALC882_TARGA]          = "targa",
9714         [ALC882_ASUS_A7J]       = "asus-a7j",
9715         [ALC882_ASUS_A7M]       = "asus-a7m",
9716         [ALC885_MACPRO]         = "macpro",
9717         [ALC885_MB5]            = "mb5",
9718         [ALC885_MACMINI3]       = "macmini3",
9719         [ALC885_MBA21]          = "mba21",
9720         [ALC885_MBP3]           = "mbp3",
9721         [ALC885_IMAC24]         = "imac24",
9722         [ALC885_IMAC91]         = "imac91",
9723         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9724         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9725         [ALC883_3ST_6ch]        = "3stack-6ch",
9726         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9727         [ALC883_TARGA_DIG]      = "targa-dig",
9728         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9729         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9730         [ALC883_ACER]           = "acer",
9731         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9732         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9733         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9734         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9735         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9736         [ALC883_MEDION]         = "medion",
9737         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9738         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9739         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9740         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9741         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9742         [ALC888_LENOVO_SKY] = "lenovo-sky",
9743         [ALC883_HAIER_W66]      = "haier-w66",
9744         [ALC888_3ST_HP]         = "3stack-hp",
9745         [ALC888_6ST_DELL]       = "6stack-dell",
9746         [ALC883_MITAC]          = "mitac",
9747         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9748         [ALC883_CLEVO_M720]     = "clevo-m720",
9749         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9750         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9751         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9752         [ALC889A_INTEL]         = "intel-alc889a",
9753         [ALC889_INTEL]          = "intel-x58",
9754         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9755         [ALC889A_MB31]          = "mb31",
9756         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9757         [ALC882_AUTO]           = "auto",
9758 };
9759
9760 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9761         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9762
9763         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9764         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9765         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9766         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9767         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9768         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9769         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9770                 ALC888_ACER_ASPIRE_4930G),
9771         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9772                 ALC888_ACER_ASPIRE_4930G),
9773         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9774                 ALC888_ACER_ASPIRE_8930G),
9775         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9776                 ALC888_ACER_ASPIRE_8930G),
9777         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9778         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9779         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9780                 ALC888_ACER_ASPIRE_6530G),
9781         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9782                 ALC888_ACER_ASPIRE_6530G),
9783         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9784                 ALC888_ACER_ASPIRE_7730G),
9785         /* default Acer -- disabled as it causes more problems.
9786          *    model=auto should work fine now
9787          */
9788         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9789
9790         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9791
9792         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9793         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9794         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9795         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9796         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9797         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9798
9799         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9800         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9801         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9802         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9803         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9804         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9805         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9806         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9807         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9808         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9809         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9810
9811         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9812         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9813         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9814         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9815         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9816         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9817         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9818         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9819         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9820
9821         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9822         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9823         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9824         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9825         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9826         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9827         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9828         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9829         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9830         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9831         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9832         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9833         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9834         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9835         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9836         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9837         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9838         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9839         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9840         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9841         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9842         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9843         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9844         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9845         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9846         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9847         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9848         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9849         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9850         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9851         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9852
9853         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9854         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9855         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9856         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9857         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9858         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9859         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9860         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9861         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9862         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9863                       ALC883_FUJITSU_PI2515),
9864         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9865                 ALC888_FUJITSU_XA3530),
9866         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9867         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9868         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9869         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9870         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9871         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9872         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9873         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9874
9875         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9876         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9877         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9878         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9879         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9880         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9881         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9882
9883         {}
9884 };
9885
9886 /* codec SSID table for Intel Mac */
9887 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9888         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9889         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9890         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9891         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9892         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9893         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9894         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9895         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9896         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9897         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9898         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9899         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9900         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9901         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9902         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9903         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9904         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9905         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9906          * so apparently no perfect solution yet
9907          */
9908         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9909         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9910         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9911         {} /* terminator */
9912 };
9913
9914 static struct alc_config_preset alc882_presets[] = {
9915         [ALC882_3ST_DIG] = {
9916                 .mixers = { alc882_base_mixer },
9917                 .init_verbs = { alc882_base_init_verbs,
9918                                 alc882_adc1_init_verbs },
9919                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9920                 .dac_nids = alc882_dac_nids,
9921                 .dig_out_nid = ALC882_DIGOUT_NID,
9922                 .dig_in_nid = ALC882_DIGIN_NID,
9923                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9924                 .channel_mode = alc882_ch_modes,
9925                 .need_dac_fix = 1,
9926                 .input_mux = &alc882_capture_source,
9927         },
9928         [ALC882_6ST_DIG] = {
9929                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9930                 .init_verbs = { alc882_base_init_verbs,
9931                                 alc882_adc1_init_verbs },
9932                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9933                 .dac_nids = alc882_dac_nids,
9934                 .dig_out_nid = ALC882_DIGOUT_NID,
9935                 .dig_in_nid = ALC882_DIGIN_NID,
9936                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9937                 .channel_mode = alc882_sixstack_modes,
9938                 .input_mux = &alc882_capture_source,
9939         },
9940         [ALC882_ARIMA] = {
9941                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9942                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9943                                 alc882_eapd_verbs },
9944                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9945                 .dac_nids = alc882_dac_nids,
9946                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9947                 .channel_mode = alc882_sixstack_modes,
9948                 .input_mux = &alc882_capture_source,
9949         },
9950         [ALC882_W2JC] = {
9951                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9952                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9953                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9954                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9955                 .dac_nids = alc882_dac_nids,
9956                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9957                 .channel_mode = alc880_threestack_modes,
9958                 .need_dac_fix = 1,
9959                 .input_mux = &alc882_capture_source,
9960                 .dig_out_nid = ALC882_DIGOUT_NID,
9961         },
9962            [ALC885_MBA21] = {
9963                         .mixers = { alc885_mba21_mixer },
9964                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9965                         .num_dacs = 2,
9966                         .dac_nids = alc882_dac_nids,
9967                         .channel_mode = alc885_mba21_ch_modes,
9968                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9969                         .input_mux = &alc882_capture_source,
9970                         .unsol_event = alc_automute_amp_unsol_event,
9971                         .setup = alc885_mba21_setup,
9972                         .init_hook = alc_automute_amp,
9973        },
9974         [ALC885_MBP3] = {
9975                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9976                 .init_verbs = { alc885_mbp3_init_verbs,
9977                                 alc880_gpio1_init_verbs },
9978                 .num_dacs = 2,
9979                 .dac_nids = alc882_dac_nids,
9980                 .hp_nid = 0x04,
9981                 .channel_mode = alc885_mbp_4ch_modes,
9982                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9983                 .input_mux = &alc882_capture_source,
9984                 .dig_out_nid = ALC882_DIGOUT_NID,
9985                 .dig_in_nid = ALC882_DIGIN_NID,
9986                 .unsol_event = alc_automute_amp_unsol_event,
9987                 .setup = alc885_mbp3_setup,
9988                 .init_hook = alc_automute_amp,
9989         },
9990         [ALC885_MB5] = {
9991                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9992                 .init_verbs = { alc885_mb5_init_verbs,
9993                                 alc880_gpio1_init_verbs },
9994                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9995                 .dac_nids = alc882_dac_nids,
9996                 .channel_mode = alc885_mb5_6ch_modes,
9997                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9998                 .input_mux = &mb5_capture_source,
9999                 .dig_out_nid = ALC882_DIGOUT_NID,
10000                 .dig_in_nid = ALC882_DIGIN_NID,
10001                 .unsol_event = alc_automute_amp_unsol_event,
10002                 .setup = alc885_mb5_setup,
10003                 .init_hook = alc_automute_amp,
10004         },
10005         [ALC885_MACMINI3] = {
10006                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10007                 .init_verbs = { alc885_macmini3_init_verbs,
10008                                 alc880_gpio1_init_verbs },
10009                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10010                 .dac_nids = alc882_dac_nids,
10011                 .channel_mode = alc885_macmini3_6ch_modes,
10012                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10013                 .input_mux = &macmini3_capture_source,
10014                 .dig_out_nid = ALC882_DIGOUT_NID,
10015                 .dig_in_nid = ALC882_DIGIN_NID,
10016                 .unsol_event = alc_automute_amp_unsol_event,
10017                 .setup = alc885_macmini3_setup,
10018                 .init_hook = alc_automute_amp,
10019         },
10020         [ALC885_MACPRO] = {
10021                 .mixers = { alc882_macpro_mixer },
10022                 .init_verbs = { alc882_macpro_init_verbs },
10023                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10024                 .dac_nids = alc882_dac_nids,
10025                 .dig_out_nid = ALC882_DIGOUT_NID,
10026                 .dig_in_nid = ALC882_DIGIN_NID,
10027                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10028                 .channel_mode = alc882_ch_modes,
10029                 .input_mux = &alc882_capture_source,
10030                 .init_hook = alc885_macpro_init_hook,
10031         },
10032         [ALC885_IMAC24] = {
10033                 .mixers = { alc885_imac24_mixer },
10034                 .init_verbs = { alc885_imac24_init_verbs },
10035                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10036                 .dac_nids = alc882_dac_nids,
10037                 .dig_out_nid = ALC882_DIGOUT_NID,
10038                 .dig_in_nid = ALC882_DIGIN_NID,
10039                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10040                 .channel_mode = alc882_ch_modes,
10041                 .input_mux = &alc882_capture_source,
10042                 .unsol_event = alc_automute_amp_unsol_event,
10043                 .setup = alc885_imac24_setup,
10044                 .init_hook = alc885_imac24_init_hook,
10045         },
10046         [ALC885_IMAC91] = {
10047                 .mixers = {alc885_imac91_mixer},
10048                 .init_verbs = { alc885_imac91_init_verbs,
10049                                 alc880_gpio1_init_verbs },
10050                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10051                 .dac_nids = alc882_dac_nids,
10052                 .channel_mode = alc885_mba21_ch_modes,
10053                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10054                 .input_mux = &alc889A_imac91_capture_source,
10055                 .dig_out_nid = ALC882_DIGOUT_NID,
10056                 .dig_in_nid = ALC882_DIGIN_NID,
10057                 .unsol_event = alc_automute_amp_unsol_event,
10058                 .setup = alc885_imac91_setup,
10059                 .init_hook = alc_automute_amp,
10060         },
10061         [ALC882_TARGA] = {
10062                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10063                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10064                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10065                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10066                 .dac_nids = alc882_dac_nids,
10067                 .dig_out_nid = ALC882_DIGOUT_NID,
10068                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10069                 .adc_nids = alc882_adc_nids,
10070                 .capsrc_nids = alc882_capsrc_nids,
10071                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10072                 .channel_mode = alc882_3ST_6ch_modes,
10073                 .need_dac_fix = 1,
10074                 .input_mux = &alc882_capture_source,
10075                 .unsol_event = alc882_targa_unsol_event,
10076                 .setup = alc882_targa_setup,
10077                 .init_hook = alc882_targa_automute,
10078         },
10079         [ALC882_ASUS_A7J] = {
10080                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10081                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10082                                 alc882_asus_a7j_verbs},
10083                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10084                 .dac_nids = alc882_dac_nids,
10085                 .dig_out_nid = ALC882_DIGOUT_NID,
10086                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10087                 .adc_nids = alc882_adc_nids,
10088                 .capsrc_nids = alc882_capsrc_nids,
10089                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10090                 .channel_mode = alc882_3ST_6ch_modes,
10091                 .need_dac_fix = 1,
10092                 .input_mux = &alc882_capture_source,
10093         },
10094         [ALC882_ASUS_A7M] = {
10095                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10096                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10097                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10098                                 alc882_asus_a7m_verbs },
10099                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10100                 .dac_nids = alc882_dac_nids,
10101                 .dig_out_nid = ALC882_DIGOUT_NID,
10102                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10103                 .channel_mode = alc880_threestack_modes,
10104                 .need_dac_fix = 1,
10105                 .input_mux = &alc882_capture_source,
10106         },
10107         [ALC883_3ST_2ch_DIG] = {
10108                 .mixers = { alc883_3ST_2ch_mixer },
10109                 .init_verbs = { alc883_init_verbs },
10110                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10111                 .dac_nids = alc883_dac_nids,
10112                 .dig_out_nid = ALC883_DIGOUT_NID,
10113                 .dig_in_nid = ALC883_DIGIN_NID,
10114                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10115                 .channel_mode = alc883_3ST_2ch_modes,
10116                 .input_mux = &alc883_capture_source,
10117         },
10118         [ALC883_3ST_6ch_DIG] = {
10119                 .mixers = { alc883_3ST_6ch_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_3ST_6ch_modes),
10126                 .channel_mode = alc883_3ST_6ch_modes,
10127                 .need_dac_fix = 1,
10128                 .input_mux = &alc883_capture_source,
10129         },
10130         [ALC883_3ST_6ch] = {
10131                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10132                 .init_verbs = { alc883_init_verbs },
10133                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10134                 .dac_nids = alc883_dac_nids,
10135                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10136                 .channel_mode = alc883_3ST_6ch_modes,
10137                 .need_dac_fix = 1,
10138                 .input_mux = &alc883_capture_source,
10139         },
10140         [ALC883_3ST_6ch_INTEL] = {
10141                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10142                 .init_verbs = { alc883_init_verbs },
10143                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10144                 .dac_nids = alc883_dac_nids,
10145                 .dig_out_nid = ALC883_DIGOUT_NID,
10146                 .dig_in_nid = ALC883_DIGIN_NID,
10147                 .slave_dig_outs = alc883_slave_dig_outs,
10148                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10149                 .channel_mode = alc883_3ST_6ch_intel_modes,
10150                 .need_dac_fix = 1,
10151                 .input_mux = &alc883_3stack_6ch_intel,
10152         },
10153         [ALC889A_INTEL] = {
10154                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10155                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10156                                 alc_hp15_unsol_verbs },
10157                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10158                 .dac_nids = alc883_dac_nids,
10159                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10160                 .adc_nids = alc889_adc_nids,
10161                 .dig_out_nid = ALC883_DIGOUT_NID,
10162                 .dig_in_nid = ALC883_DIGIN_NID,
10163                 .slave_dig_outs = alc883_slave_dig_outs,
10164                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10165                 .channel_mode = alc889_8ch_intel_modes,
10166                 .capsrc_nids = alc889_capsrc_nids,
10167                 .input_mux = &alc889_capture_source,
10168                 .setup = alc889_automute_setup,
10169                 .init_hook = alc_automute_amp,
10170                 .unsol_event = alc_automute_amp_unsol_event,
10171                 .need_dac_fix = 1,
10172         },
10173         [ALC889_INTEL] = {
10174                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10175                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10176                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10177                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10178                 .dac_nids = alc883_dac_nids,
10179                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10180                 .adc_nids = alc889_adc_nids,
10181                 .dig_out_nid = ALC883_DIGOUT_NID,
10182                 .dig_in_nid = ALC883_DIGIN_NID,
10183                 .slave_dig_outs = alc883_slave_dig_outs,
10184                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10185                 .channel_mode = alc889_8ch_intel_modes,
10186                 .capsrc_nids = alc889_capsrc_nids,
10187                 .input_mux = &alc889_capture_source,
10188                 .setup = alc889_automute_setup,
10189                 .init_hook = alc889_intel_init_hook,
10190                 .unsol_event = alc_automute_amp_unsol_event,
10191                 .need_dac_fix = 1,
10192         },
10193         [ALC883_6ST_DIG] = {
10194                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10195                 .init_verbs = { alc883_init_verbs },
10196                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10197                 .dac_nids = alc883_dac_nids,
10198                 .dig_out_nid = ALC883_DIGOUT_NID,
10199                 .dig_in_nid = ALC883_DIGIN_NID,
10200                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10201                 .channel_mode = alc883_sixstack_modes,
10202                 .input_mux = &alc883_capture_source,
10203         },
10204         [ALC883_TARGA_DIG] = {
10205                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10206                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10207                                 alc883_targa_verbs},
10208                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10209                 .dac_nids = alc883_dac_nids,
10210                 .dig_out_nid = ALC883_DIGOUT_NID,
10211                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10212                 .channel_mode = alc883_3ST_6ch_modes,
10213                 .need_dac_fix = 1,
10214                 .input_mux = &alc883_capture_source,
10215                 .unsol_event = alc883_targa_unsol_event,
10216                 .setup = alc882_targa_setup,
10217                 .init_hook = alc882_targa_automute,
10218         },
10219         [ALC883_TARGA_2ch_DIG] = {
10220                 .mixers = { alc883_targa_2ch_mixer},
10221                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10222                                 alc883_targa_verbs},
10223                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10224                 .dac_nids = alc883_dac_nids,
10225                 .adc_nids = alc883_adc_nids_alt,
10226                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10227                 .capsrc_nids = alc883_capsrc_nids,
10228                 .dig_out_nid = ALC883_DIGOUT_NID,
10229                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10230                 .channel_mode = alc883_3ST_2ch_modes,
10231                 .input_mux = &alc883_capture_source,
10232                 .unsol_event = alc883_targa_unsol_event,
10233                 .setup = alc882_targa_setup,
10234                 .init_hook = alc882_targa_automute,
10235         },
10236         [ALC883_TARGA_8ch_DIG] = {
10237                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10238                             alc883_chmode_mixer },
10239                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10240                                 alc883_targa_verbs },
10241                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10242                 .dac_nids = alc883_dac_nids,
10243                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10244                 .adc_nids = alc883_adc_nids_rev,
10245                 .capsrc_nids = alc883_capsrc_nids_rev,
10246                 .dig_out_nid = ALC883_DIGOUT_NID,
10247                 .dig_in_nid = ALC883_DIGIN_NID,
10248                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10249                 .channel_mode = alc883_4ST_8ch_modes,
10250                 .need_dac_fix = 1,
10251                 .input_mux = &alc883_capture_source,
10252                 .unsol_event = alc883_targa_unsol_event,
10253                 .setup = alc882_targa_setup,
10254                 .init_hook = alc882_targa_automute,
10255         },
10256         [ALC883_ACER] = {
10257                 .mixers = { alc883_base_mixer },
10258                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10259                  * and the headphone jack.  Turn this on and rely on the
10260                  * standard mute methods whenever the user wants to turn
10261                  * these outputs off.
10262                  */
10263                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10264                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10265                 .dac_nids = alc883_dac_nids,
10266                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10267                 .channel_mode = alc883_3ST_2ch_modes,
10268                 .input_mux = &alc883_capture_source,
10269         },
10270         [ALC883_ACER_ASPIRE] = {
10271                 .mixers = { alc883_acer_aspire_mixer },
10272                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10273                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10274                 .dac_nids = alc883_dac_nids,
10275                 .dig_out_nid = ALC883_DIGOUT_NID,
10276                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10277                 .channel_mode = alc883_3ST_2ch_modes,
10278                 .input_mux = &alc883_capture_source,
10279                 .unsol_event = alc_automute_amp_unsol_event,
10280                 .setup = alc883_acer_aspire_setup,
10281                 .init_hook = alc_automute_amp,
10282         },
10283         [ALC888_ACER_ASPIRE_4930G] = {
10284                 .mixers = { alc888_base_mixer,
10285                                 alc883_chmode_mixer },
10286                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10287                                 alc888_acer_aspire_4930g_verbs },
10288                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10289                 .dac_nids = alc883_dac_nids,
10290                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10291                 .adc_nids = alc883_adc_nids_rev,
10292                 .capsrc_nids = alc883_capsrc_nids_rev,
10293                 .dig_out_nid = ALC883_DIGOUT_NID,
10294                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10295                 .channel_mode = alc883_3ST_6ch_modes,
10296                 .need_dac_fix = 1,
10297                 .const_channel_count = 6,
10298                 .num_mux_defs =
10299                         ARRAY_SIZE(alc888_2_capture_sources),
10300                 .input_mux = alc888_2_capture_sources,
10301                 .unsol_event = alc_automute_amp_unsol_event,
10302                 .setup = alc888_acer_aspire_4930g_setup,
10303                 .init_hook = alc_automute_amp,
10304         },
10305         [ALC888_ACER_ASPIRE_6530G] = {
10306                 .mixers = { alc888_acer_aspire_6530_mixer },
10307                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10308                                 alc888_acer_aspire_6530g_verbs },
10309                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10310                 .dac_nids = alc883_dac_nids,
10311                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10312                 .adc_nids = alc883_adc_nids_rev,
10313                 .capsrc_nids = alc883_capsrc_nids_rev,
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                 .num_mux_defs =
10318                         ARRAY_SIZE(alc888_2_capture_sources),
10319                 .input_mux = alc888_acer_aspire_6530_sources,
10320                 .unsol_event = alc_automute_amp_unsol_event,
10321                 .setup = alc888_acer_aspire_6530g_setup,
10322                 .init_hook = alc_automute_amp,
10323         },
10324         [ALC888_ACER_ASPIRE_8930G] = {
10325                 .mixers = { alc889_acer_aspire_8930g_mixer,
10326                                 alc883_chmode_mixer },
10327                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10328                                 alc889_acer_aspire_8930g_verbs,
10329                                 alc889_eapd_verbs},
10330                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10331                 .dac_nids = alc883_dac_nids,
10332                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10333                 .adc_nids = alc889_adc_nids,
10334                 .capsrc_nids = alc889_capsrc_nids,
10335                 .dig_out_nid = ALC883_DIGOUT_NID,
10336                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10337                 .channel_mode = alc883_3ST_6ch_modes,
10338                 .need_dac_fix = 1,
10339                 .const_channel_count = 6,
10340                 .num_mux_defs =
10341                         ARRAY_SIZE(alc889_capture_sources),
10342                 .input_mux = alc889_capture_sources,
10343                 .unsol_event = alc_automute_amp_unsol_event,
10344                 .setup = alc889_acer_aspire_8930g_setup,
10345                 .init_hook = alc_automute_amp,
10346 #ifdef CONFIG_SND_HDA_POWER_SAVE
10347                 .power_hook = alc_power_eapd,
10348 #endif
10349         },
10350         [ALC888_ACER_ASPIRE_7730G] = {
10351                 .mixers = { alc883_3ST_6ch_mixer,
10352                                 alc883_chmode_mixer },
10353                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10354                                 alc888_acer_aspire_7730G_verbs },
10355                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10356                 .dac_nids = alc883_dac_nids,
10357                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10358                 .adc_nids = alc883_adc_nids_rev,
10359                 .capsrc_nids = alc883_capsrc_nids_rev,
10360                 .dig_out_nid = ALC883_DIGOUT_NID,
10361                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10362                 .channel_mode = alc883_3ST_6ch_modes,
10363                 .need_dac_fix = 1,
10364                 .const_channel_count = 6,
10365                 .input_mux = &alc883_capture_source,
10366                 .unsol_event = alc_automute_amp_unsol_event,
10367                 .setup = alc888_acer_aspire_7730g_setup,
10368                 .init_hook = alc_automute_amp,
10369         },
10370         [ALC883_MEDION] = {
10371                 .mixers = { alc883_fivestack_mixer,
10372                             alc883_chmode_mixer },
10373                 .init_verbs = { alc883_init_verbs,
10374                                 alc883_medion_eapd_verbs },
10375                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10376                 .dac_nids = alc883_dac_nids,
10377                 .adc_nids = alc883_adc_nids_alt,
10378                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10379                 .capsrc_nids = alc883_capsrc_nids,
10380                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10381                 .channel_mode = alc883_sixstack_modes,
10382                 .input_mux = &alc883_capture_source,
10383         },
10384         [ALC883_MEDION_WIM2160] = {
10385                 .mixers = { alc883_medion_wim2160_mixer },
10386                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10387                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10388                 .dac_nids = alc883_dac_nids,
10389                 .dig_out_nid = ALC883_DIGOUT_NID,
10390                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10391                 .adc_nids = alc883_adc_nids,
10392                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10393                 .channel_mode = alc883_3ST_2ch_modes,
10394                 .input_mux = &alc883_capture_source,
10395                 .unsol_event = alc_automute_amp_unsol_event,
10396                 .setup = alc883_medion_wim2160_setup,
10397                 .init_hook = alc_automute_amp,
10398         },
10399         [ALC883_LAPTOP_EAPD] = {
10400                 .mixers = { alc883_base_mixer },
10401                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10402                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10403                 .dac_nids = alc883_dac_nids,
10404                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10405                 .channel_mode = alc883_3ST_2ch_modes,
10406                 .input_mux = &alc883_capture_source,
10407         },
10408         [ALC883_CLEVO_M540R] = {
10409                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10410                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10411                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10412                 .dac_nids = alc883_dac_nids,
10413                 .dig_out_nid = ALC883_DIGOUT_NID,
10414                 .dig_in_nid = ALC883_DIGIN_NID,
10415                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10416                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10417                 .need_dac_fix = 1,
10418                 .input_mux = &alc883_capture_source,
10419                 /* This machine has the hardware HP auto-muting, thus
10420                  * we need no software mute via unsol event
10421                  */
10422         },
10423         [ALC883_CLEVO_M720] = {
10424                 .mixers = { alc883_clevo_m720_mixer },
10425                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10426                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10427                 .dac_nids = alc883_dac_nids,
10428                 .dig_out_nid = ALC883_DIGOUT_NID,
10429                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10430                 .channel_mode = alc883_3ST_2ch_modes,
10431                 .input_mux = &alc883_capture_source,
10432                 .unsol_event = alc883_clevo_m720_unsol_event,
10433                 .setup = alc883_clevo_m720_setup,
10434                 .init_hook = alc883_clevo_m720_init_hook,
10435         },
10436         [ALC883_LENOVO_101E_2ch] = {
10437                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10438                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10439                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10440                 .dac_nids = alc883_dac_nids,
10441                 .adc_nids = alc883_adc_nids_alt,
10442                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10443                 .capsrc_nids = alc883_capsrc_nids,
10444                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10445                 .channel_mode = alc883_3ST_2ch_modes,
10446                 .input_mux = &alc883_lenovo_101e_capture_source,
10447                 .unsol_event = alc883_lenovo_101e_unsol_event,
10448                 .init_hook = alc883_lenovo_101e_all_automute,
10449         },
10450         [ALC883_LENOVO_NB0763] = {
10451                 .mixers = { alc883_lenovo_nb0763_mixer },
10452                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10453                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10454                 .dac_nids = alc883_dac_nids,
10455                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10456                 .channel_mode = alc883_3ST_2ch_modes,
10457                 .need_dac_fix = 1,
10458                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10459                 .unsol_event = alc_automute_amp_unsol_event,
10460                 .setup = alc883_lenovo_nb0763_setup,
10461                 .init_hook = alc_automute_amp,
10462         },
10463         [ALC888_LENOVO_MS7195_DIG] = {
10464                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10465                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10466                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10467                 .dac_nids = alc883_dac_nids,
10468                 .dig_out_nid = ALC883_DIGOUT_NID,
10469                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10470                 .channel_mode = alc883_3ST_6ch_modes,
10471                 .need_dac_fix = 1,
10472                 .input_mux = &alc883_capture_source,
10473                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10474                 .init_hook = alc888_lenovo_ms7195_front_automute,
10475         },
10476         [ALC883_HAIER_W66] = {
10477                 .mixers = { alc883_targa_2ch_mixer},
10478                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10479                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10480                 .dac_nids = alc883_dac_nids,
10481                 .dig_out_nid = ALC883_DIGOUT_NID,
10482                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10483                 .channel_mode = alc883_3ST_2ch_modes,
10484                 .input_mux = &alc883_capture_source,
10485                 .unsol_event = alc_automute_amp_unsol_event,
10486                 .setup = alc883_haier_w66_setup,
10487                 .init_hook = alc_automute_amp,
10488         },
10489         [ALC888_3ST_HP] = {
10490                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10491                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10492                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10493                 .dac_nids = alc883_dac_nids,
10494                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10495                 .channel_mode = alc888_3st_hp_modes,
10496                 .need_dac_fix = 1,
10497                 .input_mux = &alc883_capture_source,
10498                 .unsol_event = alc_automute_amp_unsol_event,
10499                 .setup = alc888_3st_hp_setup,
10500                 .init_hook = alc_automute_amp,
10501         },
10502         [ALC888_6ST_DELL] = {
10503                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10504                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10505                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10506                 .dac_nids = alc883_dac_nids,
10507                 .dig_out_nid = ALC883_DIGOUT_NID,
10508                 .dig_in_nid = ALC883_DIGIN_NID,
10509                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10510                 .channel_mode = alc883_sixstack_modes,
10511                 .input_mux = &alc883_capture_source,
10512                 .unsol_event = alc_automute_amp_unsol_event,
10513                 .setup = alc888_6st_dell_setup,
10514                 .init_hook = alc_automute_amp,
10515         },
10516         [ALC883_MITAC] = {
10517                 .mixers = { alc883_mitac_mixer },
10518                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10519                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10520                 .dac_nids = alc883_dac_nids,
10521                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10522                 .channel_mode = alc883_3ST_2ch_modes,
10523                 .input_mux = &alc883_capture_source,
10524                 .unsol_event = alc_automute_amp_unsol_event,
10525                 .setup = alc883_mitac_setup,
10526                 .init_hook = alc_automute_amp,
10527         },
10528         [ALC883_FUJITSU_PI2515] = {
10529                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10530                 .init_verbs = { alc883_init_verbs,
10531                                 alc883_2ch_fujitsu_pi2515_verbs},
10532                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10533                 .dac_nids = alc883_dac_nids,
10534                 .dig_out_nid = ALC883_DIGOUT_NID,
10535                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10536                 .channel_mode = alc883_3ST_2ch_modes,
10537                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10538                 .unsol_event = alc_automute_amp_unsol_event,
10539                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10540                 .init_hook = alc_automute_amp,
10541         },
10542         [ALC888_FUJITSU_XA3530] = {
10543                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10544                 .init_verbs = { alc883_init_verbs,
10545                         alc888_fujitsu_xa3530_verbs },
10546                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10547                 .dac_nids = alc883_dac_nids,
10548                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10549                 .adc_nids = alc883_adc_nids_rev,
10550                 .capsrc_nids = alc883_capsrc_nids_rev,
10551                 .dig_out_nid = ALC883_DIGOUT_NID,
10552                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10553                 .channel_mode = alc888_4ST_8ch_intel_modes,
10554                 .num_mux_defs =
10555                         ARRAY_SIZE(alc888_2_capture_sources),
10556                 .input_mux = alc888_2_capture_sources,
10557                 .unsol_event = alc_automute_amp_unsol_event,
10558                 .setup = alc888_fujitsu_xa3530_setup,
10559                 .init_hook = alc_automute_amp,
10560         },
10561         [ALC888_LENOVO_SKY] = {
10562                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10563                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10564                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10565                 .dac_nids = alc883_dac_nids,
10566                 .dig_out_nid = ALC883_DIGOUT_NID,
10567                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10568                 .channel_mode = alc883_sixstack_modes,
10569                 .need_dac_fix = 1,
10570                 .input_mux = &alc883_lenovo_sky_capture_source,
10571                 .unsol_event = alc_automute_amp_unsol_event,
10572                 .setup = alc888_lenovo_sky_setup,
10573                 .init_hook = alc_automute_amp,
10574         },
10575         [ALC888_ASUS_M90V] = {
10576                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10577                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10578                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10579                 .dac_nids = alc883_dac_nids,
10580                 .dig_out_nid = ALC883_DIGOUT_NID,
10581                 .dig_in_nid = ALC883_DIGIN_NID,
10582                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10583                 .channel_mode = alc883_3ST_6ch_modes,
10584                 .need_dac_fix = 1,
10585                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10586                 .unsol_event = alc_sku_unsol_event,
10587                 .setup = alc883_mode2_setup,
10588                 .init_hook = alc_inithook,
10589         },
10590         [ALC888_ASUS_EEE1601] = {
10591                 .mixers = { alc883_asus_eee1601_mixer },
10592                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10593                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10594                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10595                 .dac_nids = alc883_dac_nids,
10596                 .dig_out_nid = ALC883_DIGOUT_NID,
10597                 .dig_in_nid = ALC883_DIGIN_NID,
10598                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10599                 .channel_mode = alc883_3ST_2ch_modes,
10600                 .need_dac_fix = 1,
10601                 .input_mux = &alc883_asus_eee1601_capture_source,
10602                 .unsol_event = alc_sku_unsol_event,
10603                 .init_hook = alc883_eee1601_inithook,
10604         },
10605         [ALC1200_ASUS_P5Q] = {
10606                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10607                 .init_verbs = { alc883_init_verbs },
10608                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10609                 .dac_nids = alc883_dac_nids,
10610                 .dig_out_nid = ALC1200_DIGOUT_NID,
10611                 .dig_in_nid = ALC883_DIGIN_NID,
10612                 .slave_dig_outs = alc1200_slave_dig_outs,
10613                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10614                 .channel_mode = alc883_sixstack_modes,
10615                 .input_mux = &alc883_capture_source,
10616         },
10617         [ALC889A_MB31] = {
10618                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10619                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10620                         alc880_gpio1_init_verbs },
10621                 .adc_nids = alc883_adc_nids,
10622                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10623                 .capsrc_nids = alc883_capsrc_nids,
10624                 .dac_nids = alc883_dac_nids,
10625                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10626                 .channel_mode = alc889A_mb31_6ch_modes,
10627                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10628                 .input_mux = &alc889A_mb31_capture_source,
10629                 .dig_out_nid = ALC883_DIGOUT_NID,
10630                 .unsol_event = alc889A_mb31_unsol_event,
10631                 .init_hook = alc889A_mb31_automute,
10632         },
10633         [ALC883_SONY_VAIO_TT] = {
10634                 .mixers = { alc883_vaiott_mixer },
10635                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10636                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10637                 .dac_nids = alc883_dac_nids,
10638                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10639                 .channel_mode = alc883_3ST_2ch_modes,
10640                 .input_mux = &alc883_capture_source,
10641                 .unsol_event = alc_automute_amp_unsol_event,
10642                 .setup = alc883_vaiott_setup,
10643                 .init_hook = alc_automute_amp,
10644         },
10645 };
10646
10647
10648 /*
10649  * Pin config fixes
10650  */
10651 enum {
10652         PINFIX_ABIT_AW9D_MAX,
10653         PINFIX_PB_M5210,
10654         PINFIX_ACER_ASPIRE_7736,
10655 };
10656
10657 static const struct alc_fixup alc882_fixups[] = {
10658         [PINFIX_ABIT_AW9D_MAX] = {
10659                 .pins = (const struct alc_pincfg[]) {
10660                         { 0x15, 0x01080104 }, /* side */
10661                         { 0x16, 0x01011012 }, /* rear */
10662                         { 0x17, 0x01016011 }, /* clfe */
10663                         { }
10664                 }
10665         },
10666         [PINFIX_PB_M5210] = {
10667                 .verbs = (const struct hda_verb[]) {
10668                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10669                         {}
10670                 }
10671         },
10672         [PINFIX_ACER_ASPIRE_7736] = {
10673                 .sku = ALC_FIXUP_SKU_IGNORE,
10674         },
10675 };
10676
10677 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10678         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10679         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10680         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10681         {}
10682 };
10683
10684 /*
10685  * BIOS auto configuration
10686  */
10687 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10688                                                 const struct auto_pin_cfg *cfg)
10689 {
10690         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10691 }
10692
10693 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10694                                               hda_nid_t nid, int pin_type,
10695                                               hda_nid_t dac)
10696 {
10697         int idx;
10698
10699         /* set as output */
10700         alc_set_pin_output(codec, nid, pin_type);
10701
10702         if (dac == 0x25)
10703                 idx = 4;
10704         else if (dac >= 0x02 && dac <= 0x05)
10705                 idx = dac - 2;
10706         else
10707                 return;
10708         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10709 }
10710
10711 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10712 {
10713         struct alc_spec *spec = codec->spec;
10714         int i;
10715
10716         for (i = 0; i <= HDA_SIDE; i++) {
10717                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10718                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10719                 if (nid)
10720                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10721                                         spec->multiout.dac_nids[i]);
10722         }
10723 }
10724
10725 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10726 {
10727         struct alc_spec *spec = codec->spec;
10728         hda_nid_t pin, dac;
10729         int i;
10730
10731         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10732                 pin = spec->autocfg.hp_pins[i];
10733                 if (!pin)
10734                         break;
10735                 dac = spec->multiout.hp_nid;
10736                 if (!dac)
10737                         dac = spec->multiout.dac_nids[0]; /* to front */
10738                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10739         }
10740         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10741                 pin = spec->autocfg.speaker_pins[i];
10742                 if (!pin)
10743                         break;
10744                 dac = spec->multiout.extra_out_nid[0];
10745                 if (!dac)
10746                         dac = spec->multiout.dac_nids[0]; /* to front */
10747                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10748         }
10749 }
10750
10751 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10752 {
10753         struct alc_spec *spec = codec->spec;
10754         struct auto_pin_cfg *cfg = &spec->autocfg;
10755         int i;
10756
10757         for (i = 0; i < cfg->num_inputs; i++) {
10758                 hda_nid_t nid = cfg->inputs[i].pin;
10759                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10760                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10761                         snd_hda_codec_write(codec, nid, 0,
10762                                             AC_VERB_SET_AMP_GAIN_MUTE,
10763                                             AMP_OUT_MUTE);
10764         }
10765 }
10766
10767 static void alc882_auto_init_input_src(struct hda_codec *codec)
10768 {
10769         struct alc_spec *spec = codec->spec;
10770         int c;
10771
10772         for (c = 0; c < spec->num_adc_nids; c++) {
10773                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10774                 hda_nid_t nid = spec->capsrc_nids[c];
10775                 unsigned int mux_idx;
10776                 const struct hda_input_mux *imux;
10777                 int conns, mute, idx, item;
10778
10779                 conns = snd_hda_get_connections(codec, nid, conn_list,
10780                                                 ARRAY_SIZE(conn_list));
10781                 if (conns < 0)
10782                         continue;
10783                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10784                 imux = &spec->input_mux[mux_idx];
10785                 if (!imux->num_items && mux_idx > 0)
10786                         imux = &spec->input_mux[0];
10787                 for (idx = 0; idx < conns; idx++) {
10788                         /* if the current connection is the selected one,
10789                          * unmute it as default - otherwise mute it
10790                          */
10791                         mute = AMP_IN_MUTE(idx);
10792                         for (item = 0; item < imux->num_items; item++) {
10793                                 if (imux->items[item].index == idx) {
10794                                         if (spec->cur_mux[c] == item)
10795                                                 mute = AMP_IN_UNMUTE(idx);
10796                                         break;
10797                                 }
10798                         }
10799                         /* check if we have a selector or mixer
10800                          * we could check for the widget type instead, but
10801                          * just check for Amp-In presence (in case of mixer
10802                          * without amp-in there is something wrong, this
10803                          * function shouldn't be used or capsrc nid is wrong)
10804                          */
10805                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10806                                 snd_hda_codec_write(codec, nid, 0,
10807                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10808                                                     mute);
10809                         else if (mute != AMP_IN_MUTE(idx))
10810                                 snd_hda_codec_write(codec, nid, 0,
10811                                                     AC_VERB_SET_CONNECT_SEL,
10812                                                     idx);
10813                 }
10814         }
10815 }
10816
10817 /* add mic boosts if needed */
10818 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10819 {
10820         struct alc_spec *spec = codec->spec;
10821         struct auto_pin_cfg *cfg = &spec->autocfg;
10822         int i, err, type;
10823         int type_idx = 0;
10824         hda_nid_t nid;
10825
10826         for (i = 0; i < cfg->num_inputs; i++) {
10827                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
10828                         break;
10829                 nid = cfg->inputs[i].pin;
10830                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10831                         char label[32];
10832                         type = cfg->inputs[i].type;
10833                         if (i > 0 && type == cfg->inputs[i - 1].type)
10834                                 type_idx++;
10835                         else
10836                                 type_idx = 0;
10837                         snprintf(label, sizeof(label), "%s Boost",
10838                                  hda_get_autocfg_input_label(codec, cfg, i));
10839                         err = add_control(spec, ALC_CTL_WIDGET_VOL, label,
10840                                           type_idx,
10841                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10842                         if (err < 0)
10843                                 return err;
10844                 }
10845         }
10846         return 0;
10847 }
10848
10849 /* almost identical with ALC880 parser... */
10850 static int alc882_parse_auto_config(struct hda_codec *codec)
10851 {
10852         struct alc_spec *spec = codec->spec;
10853         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10854         int err;
10855
10856         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10857                                            alc882_ignore);
10858         if (err < 0)
10859                 return err;
10860         if (!spec->autocfg.line_outs)
10861                 return 0; /* can't find valid BIOS pin config */
10862
10863         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10864         if (err < 0)
10865                 return err;
10866         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10867         if (err < 0)
10868                 return err;
10869         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10870                                            "Headphone");
10871         if (err < 0)
10872                 return err;
10873         err = alc880_auto_create_extra_out(spec,
10874                                            spec->autocfg.speaker_pins[0],
10875                                            "Speaker");
10876         if (err < 0)
10877                 return err;
10878         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10879         if (err < 0)
10880                 return err;
10881
10882         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10883
10884         alc_auto_parse_digital(codec);
10885
10886         if (spec->kctls.list)
10887                 add_mixer(spec, spec->kctls.list);
10888
10889         add_verb(spec, alc883_auto_init_verbs);
10890         /* if ADC 0x07 is available, initialize it, too */
10891         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10892                 add_verb(spec, alc882_adc1_init_verbs);
10893
10894         spec->num_mux_defs = 1;
10895         spec->input_mux = &spec->private_imux[0];
10896
10897         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10898
10899         err = alc_auto_add_mic_boost(codec);
10900         if (err < 0)
10901                 return err;
10902
10903         return 1; /* config found */
10904 }
10905
10906 /* additional initialization for auto-configuration model */
10907 static void alc882_auto_init(struct hda_codec *codec)
10908 {
10909         struct alc_spec *spec = codec->spec;
10910         alc882_auto_init_multi_out(codec);
10911         alc882_auto_init_hp_out(codec);
10912         alc882_auto_init_analog_input(codec);
10913         alc882_auto_init_input_src(codec);
10914         alc_auto_init_digital(codec);
10915         if (spec->unsol_event)
10916                 alc_inithook(codec);
10917 }
10918
10919 static int patch_alc882(struct hda_codec *codec)
10920 {
10921         struct alc_spec *spec;
10922         int err, board_config;
10923
10924         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10925         if (spec == NULL)
10926                 return -ENOMEM;
10927
10928         codec->spec = spec;
10929
10930         switch (codec->vendor_id) {
10931         case 0x10ec0882:
10932         case 0x10ec0885:
10933                 break;
10934         default:
10935                 /* ALC883 and variants */
10936                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10937                 break;
10938         }
10939
10940         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10941                                                   alc882_models,
10942                                                   alc882_cfg_tbl);
10943
10944         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10945                 board_config = snd_hda_check_board_codec_sid_config(codec,
10946                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10947
10948         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10949                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10950                        codec->chip_name);
10951                 board_config = ALC882_AUTO;
10952         }
10953
10954         if (board_config == ALC882_AUTO)
10955                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10956
10957         alc_auto_parse_customize_define(codec);
10958
10959         if (board_config == ALC882_AUTO) {
10960                 /* automatic parse from the BIOS config */
10961                 err = alc882_parse_auto_config(codec);
10962                 if (err < 0) {
10963                         alc_free(codec);
10964                         return err;
10965                 } else if (!err) {
10966                         printk(KERN_INFO
10967                                "hda_codec: Cannot set up configuration "
10968                                "from BIOS.  Using base mode...\n");
10969                         board_config = ALC882_3ST_DIG;
10970                 }
10971         }
10972
10973         if (has_cdefine_beep(codec)) {
10974                 err = snd_hda_attach_beep_device(codec, 0x1);
10975                 if (err < 0) {
10976                         alc_free(codec);
10977                         return err;
10978                 }
10979         }
10980
10981         if (board_config != ALC882_AUTO)
10982                 setup_preset(codec, &alc882_presets[board_config]);
10983
10984         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10985         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10986         /* FIXME: setup DAC5 */
10987         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10988         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10989
10990         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10991         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10992
10993         if (!spec->adc_nids && spec->input_mux) {
10994                 int i, j;
10995                 spec->num_adc_nids = 0;
10996                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10997                         const struct hda_input_mux *imux = spec->input_mux;
10998                         hda_nid_t cap;
10999                         hda_nid_t items[16];
11000                         hda_nid_t nid = alc882_adc_nids[i];
11001                         unsigned int wcap = get_wcaps(codec, nid);
11002                         /* get type */
11003                         wcap = get_wcaps_type(wcap);
11004                         if (wcap != AC_WID_AUD_IN)
11005                                 continue;
11006                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11007                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11008                         if (err < 0)
11009                                 continue;
11010                         err = snd_hda_get_connections(codec, cap, items,
11011                                                       ARRAY_SIZE(items));
11012                         if (err < 0)
11013                                 continue;
11014                         for (j = 0; j < imux->num_items; j++)
11015                                 if (imux->items[j].index >= err)
11016                                         break;
11017                         if (j < imux->num_items)
11018                                 continue;
11019                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11020                         spec->num_adc_nids++;
11021                 }
11022                 spec->adc_nids = spec->private_adc_nids;
11023                 spec->capsrc_nids = spec->private_capsrc_nids;
11024         }
11025
11026         set_capture_mixer(codec);
11027
11028         if (has_cdefine_beep(codec))
11029                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11030
11031         if (board_config == ALC882_AUTO)
11032                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
11033
11034         spec->vmaster_nid = 0x0c;
11035
11036         codec->patch_ops = alc_patch_ops;
11037         if (board_config == ALC882_AUTO)
11038                 spec->init_hook = alc882_auto_init;
11039
11040         alc_init_jacks(codec);
11041 #ifdef CONFIG_SND_HDA_POWER_SAVE
11042         if (!spec->loopback.amplist)
11043                 spec->loopback.amplist = alc882_loopbacks;
11044 #endif
11045
11046         return 0;
11047 }
11048
11049
11050 /*
11051  * ALC262 support
11052  */
11053
11054 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11055 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11056
11057 #define alc262_dac_nids         alc260_dac_nids
11058 #define alc262_adc_nids         alc882_adc_nids
11059 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11060 #define alc262_capsrc_nids      alc882_capsrc_nids
11061 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11062
11063 #define alc262_modes            alc260_modes
11064 #define alc262_capture_source   alc882_capture_source
11065
11066 static hda_nid_t alc262_dmic_adc_nids[1] = {
11067         /* ADC0 */
11068         0x09
11069 };
11070
11071 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11072
11073 static struct snd_kcontrol_new alc262_base_mixer[] = {
11074         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11075         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11076         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11077         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11078         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11079         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11080         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11081         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11082         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11083         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11084         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11085         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11086         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11087         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11088         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11089         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11090         { } /* end */
11091 };
11092
11093 /* update HP, line and mono-out pins according to the master switch */
11094 static void alc262_hp_master_update(struct hda_codec *codec)
11095 {
11096         struct alc_spec *spec = codec->spec;
11097         int val = spec->master_sw;
11098
11099         /* HP & line-out */
11100         snd_hda_codec_write_cache(codec, 0x1b, 0,
11101                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11102                                   val ? PIN_HP : 0);
11103         snd_hda_codec_write_cache(codec, 0x15, 0,
11104                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11105                                   val ? PIN_HP : 0);
11106         /* mono (speaker) depending on the HP jack sense */
11107         val = val && !spec->jack_present;
11108         snd_hda_codec_write_cache(codec, 0x16, 0,
11109                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11110                                   val ? PIN_OUT : 0);
11111 }
11112
11113 static void alc262_hp_bpc_automute(struct hda_codec *codec)
11114 {
11115         struct alc_spec *spec = codec->spec;
11116
11117         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11118         alc262_hp_master_update(codec);
11119 }
11120
11121 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11122 {
11123         if ((res >> 26) != ALC880_HP_EVENT)
11124                 return;
11125         alc262_hp_bpc_automute(codec);
11126 }
11127
11128 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11129 {
11130         struct alc_spec *spec = codec->spec;
11131
11132         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11133         alc262_hp_master_update(codec);
11134 }
11135
11136 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11137                                            unsigned int res)
11138 {
11139         if ((res >> 26) != ALC880_HP_EVENT)
11140                 return;
11141         alc262_hp_wildwest_automute(codec);
11142 }
11143
11144 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11145
11146 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11147                                    struct snd_ctl_elem_value *ucontrol)
11148 {
11149         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11150         struct alc_spec *spec = codec->spec;
11151         int val = !!*ucontrol->value.integer.value;
11152
11153         if (val == spec->master_sw)
11154                 return 0;
11155         spec->master_sw = val;
11156         alc262_hp_master_update(codec);
11157         return 1;
11158 }
11159
11160 #define ALC262_HP_MASTER_SWITCH                                 \
11161         {                                                       \
11162                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11163                 .name = "Master Playback Switch",               \
11164                 .info = snd_ctl_boolean_mono_info,              \
11165                 .get = alc262_hp_master_sw_get,                 \
11166                 .put = alc262_hp_master_sw_put,                 \
11167         }, \
11168         {                                                       \
11169                 .iface = NID_MAPPING,                           \
11170                 .name = "Master Playback Switch",               \
11171                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11172         }
11173
11174
11175 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11176         ALC262_HP_MASTER_SWITCH,
11177         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11178         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11179         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11180         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11181                               HDA_OUTPUT),
11182         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11183                             HDA_OUTPUT),
11184         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11185         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11186         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11187         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11188         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11189         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11190         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11191         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11192         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11193         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11194         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11195         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11196         { } /* end */
11197 };
11198
11199 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11200         ALC262_HP_MASTER_SWITCH,
11201         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11202         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11203         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11204         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11205         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11206                               HDA_OUTPUT),
11207         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11208                             HDA_OUTPUT),
11209         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11210         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11211         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
11212         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11213         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11214         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11215         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11216         { } /* end */
11217 };
11218
11219 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11220         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11221         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11222         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
11223         { } /* end */
11224 };
11225
11226 /* mute/unmute internal speaker according to the hp jack and mute state */
11227 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11228 {
11229         struct alc_spec *spec = codec->spec;
11230
11231         spec->autocfg.hp_pins[0] = 0x15;
11232         spec->autocfg.speaker_pins[0] = 0x14;
11233 }
11234
11235 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11236         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11237         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11238         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11239         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11241         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11242         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11243         { } /* end */
11244 };
11245
11246 static struct hda_verb alc262_hp_t5735_verbs[] = {
11247         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11248         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11249
11250         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11251         { }
11252 };
11253
11254 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11255         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11256         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11257         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11258         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11259         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11260         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11261         { } /* end */
11262 };
11263
11264 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11265         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11266         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11267         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11268         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11269         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11270         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11271         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11272         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11273         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11274         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11275         {}
11276 };
11277
11278 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11279         .num_items = 1,
11280         .items = {
11281                 { "Line", 0x1 },
11282         },
11283 };
11284
11285 /* bind hp and internal speaker mute (with plug check) as master switch */
11286 static void alc262_hippo_master_update(struct hda_codec *codec)
11287 {
11288         struct alc_spec *spec = codec->spec;
11289         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11290         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11291         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11292         unsigned int mute;
11293
11294         /* HP */
11295         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11296         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11297                                  HDA_AMP_MUTE, mute);
11298         /* mute internal speaker per jack sense */
11299         if (spec->jack_present)
11300                 mute = HDA_AMP_MUTE;
11301         if (line_nid)
11302                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11303                                          HDA_AMP_MUTE, mute);
11304         if (speaker_nid && speaker_nid != line_nid)
11305                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11306                                          HDA_AMP_MUTE, mute);
11307 }
11308
11309 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11310
11311 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11312                                       struct snd_ctl_elem_value *ucontrol)
11313 {
11314         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11315         struct alc_spec *spec = codec->spec;
11316         int val = !!*ucontrol->value.integer.value;
11317
11318         if (val == spec->master_sw)
11319                 return 0;
11320         spec->master_sw = val;
11321         alc262_hippo_master_update(codec);
11322         return 1;
11323 }
11324
11325 #define ALC262_HIPPO_MASTER_SWITCH                              \
11326         {                                                       \
11327                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11328                 .name = "Master Playback Switch",               \
11329                 .info = snd_ctl_boolean_mono_info,              \
11330                 .get = alc262_hippo_master_sw_get,              \
11331                 .put = alc262_hippo_master_sw_put,              \
11332         },                                                      \
11333         {                                                       \
11334                 .iface = NID_MAPPING,                           \
11335                 .name = "Master Playback Switch",               \
11336                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11337                              (SUBDEV_SPEAKER(0) << 16), \
11338         }
11339
11340 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11341         ALC262_HIPPO_MASTER_SWITCH,
11342         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11343         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11344         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11345         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11346         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11348         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11349         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11350         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11351         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11352         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11353         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11354         { } /* end */
11355 };
11356
11357 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11358         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11359         ALC262_HIPPO_MASTER_SWITCH,
11360         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11361         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11362         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11363         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11364         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11365         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11366         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11367         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11368         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11369         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11370         { } /* end */
11371 };
11372
11373 /* mute/unmute internal speaker according to the hp jack and mute state */
11374 static void alc262_hippo_automute(struct hda_codec *codec)
11375 {
11376         struct alc_spec *spec = codec->spec;
11377         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11378
11379         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11380         alc262_hippo_master_update(codec);
11381 }
11382
11383 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11384 {
11385         if ((res >> 26) != ALC880_HP_EVENT)
11386                 return;
11387         alc262_hippo_automute(codec);
11388 }
11389
11390 static void alc262_hippo_setup(struct hda_codec *codec)
11391 {
11392         struct alc_spec *spec = codec->spec;
11393
11394         spec->autocfg.hp_pins[0] = 0x15;
11395         spec->autocfg.speaker_pins[0] = 0x14;
11396 }
11397
11398 static void alc262_hippo1_setup(struct hda_codec *codec)
11399 {
11400         struct alc_spec *spec = codec->spec;
11401
11402         spec->autocfg.hp_pins[0] = 0x1b;
11403         spec->autocfg.speaker_pins[0] = 0x14;
11404 }
11405
11406
11407 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11408         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11409         ALC262_HIPPO_MASTER_SWITCH,
11410         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11411         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11412         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11413         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11414         { } /* end */
11415 };
11416
11417 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11418         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11419         ALC262_HIPPO_MASTER_SWITCH,
11420         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11421         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11422         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11423         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11424         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11425         { } /* end */
11426 };
11427
11428 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11429         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11430         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11431         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11432         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11433         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11434         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11435         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11436         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11437         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11438         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11439         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11440         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11441         { } /* end */
11442 };
11443
11444 static struct hda_verb alc262_tyan_verbs[] = {
11445         /* Headphone automute */
11446         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11447         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11448         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11449
11450         /* P11 AUX_IN, white 4-pin connector */
11451         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11452         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11453         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11454         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11455
11456         {}
11457 };
11458
11459 /* unsolicited event for HP jack sensing */
11460 static void alc262_tyan_setup(struct hda_codec *codec)
11461 {
11462         struct alc_spec *spec = codec->spec;
11463
11464         spec->autocfg.hp_pins[0] = 0x1b;
11465         spec->autocfg.speaker_pins[0] = 0x15;
11466 }
11467
11468
11469 #define alc262_capture_mixer            alc882_capture_mixer
11470 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11471
11472 /*
11473  * generic initialization of ADC, input mixers and output mixers
11474  */
11475 static struct hda_verb alc262_init_verbs[] = {
11476         /*
11477          * Unmute ADC0-2 and set the default input to mic-in
11478          */
11479         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11480         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11481         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11482         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11483         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11484         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11485
11486         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11487          * mixer widget
11488          * Note: PASD motherboards uses the Line In 2 as the input for
11489          * front panel mic (mic 2)
11490          */
11491         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11492         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11493         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11494         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11495         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11496         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11497
11498         /*
11499          * Set up output mixers (0x0c - 0x0e)
11500          */
11501         /* set vol=0 to output mixers */
11502         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11503         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11504         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11505         /* set up input amps for analog loopback */
11506         /* Amp Indices: DAC = 0, mixer = 1 */
11507         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11510         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11511         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11512         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11513
11514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11515         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11516         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11517         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11518         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11519         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11520
11521         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11522         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11523         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11524         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11525         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11526
11527         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11528         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11529
11530         /* FIXME: use matrix-type input source selection */
11531         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11532         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11533         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11534         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11535         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11536         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11537         /* Input mixer2 */
11538         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11539         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11540         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11541         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11542         /* Input mixer3 */
11543         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11544         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11545         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11546         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11547
11548         { }
11549 };
11550
11551 static struct hda_verb alc262_eapd_verbs[] = {
11552         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11553         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11554         { }
11555 };
11556
11557 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11558         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11559         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11560         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11561
11562         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11563         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11564         {}
11565 };
11566
11567 static struct hda_verb alc262_sony_unsol_verbs[] = {
11568         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11569         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11570         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11571
11572         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11573         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11574         {}
11575 };
11576
11577 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11578         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11579         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11580         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11581         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11582         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11583         { } /* end */
11584 };
11585
11586 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11587         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11590         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11591         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11592         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11593         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11594         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11595         {}
11596 };
11597
11598 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11599 {
11600         struct alc_spec *spec = codec->spec;
11601
11602         spec->autocfg.hp_pins[0] = 0x15;
11603         spec->autocfg.speaker_pins[0] = 0x14;
11604         spec->ext_mic.pin = 0x18;
11605         spec->ext_mic.mux_idx = 0;
11606         spec->int_mic.pin = 0x12;
11607         spec->int_mic.mux_idx = 9;
11608         spec->auto_mic = 1;
11609 }
11610
11611 /*
11612  * nec model
11613  *  0x15 = headphone
11614  *  0x16 = internal speaker
11615  *  0x18 = external mic
11616  */
11617
11618 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11619         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11620         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11621
11622         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11623         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11624         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11625
11626         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11627         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11628         { } /* end */
11629 };
11630
11631 static struct hda_verb alc262_nec_verbs[] = {
11632         /* Unmute Speaker */
11633         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11634
11635         /* Headphone */
11636         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11637         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11638
11639         /* External mic to headphone */
11640         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11641         /* External mic to speaker */
11642         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11643         {}
11644 };
11645
11646 /*
11647  * fujitsu model
11648  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11649  *  0x1b = port replicator headphone out
11650  */
11651
11652 #define ALC_HP_EVENT    0x37
11653
11654 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11655         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11656         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11657         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11658         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11659         {}
11660 };
11661
11662 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11663         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11664         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11665         {}
11666 };
11667
11668 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11669         /* Front Mic pin: input vref at 50% */
11670         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11671         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11672         {}
11673 };
11674
11675 static struct hda_input_mux alc262_fujitsu_capture_source = {
11676         .num_items = 3,
11677         .items = {
11678                 { "Mic", 0x0 },
11679                 { "Int Mic", 0x1 },
11680                 { "CD", 0x4 },
11681         },
11682 };
11683
11684 static struct hda_input_mux alc262_HP_capture_source = {
11685         .num_items = 5,
11686         .items = {
11687                 { "Mic", 0x0 },
11688                 { "Front Mic", 0x1 },
11689                 { "Line", 0x2 },
11690                 { "CD", 0x4 },
11691                 { "AUX IN", 0x6 },
11692         },
11693 };
11694
11695 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11696         .num_items = 4,
11697         .items = {
11698                 { "Mic", 0x0 },
11699                 { "Front Mic", 0x2 },
11700                 { "Line", 0x1 },
11701                 { "CD", 0x4 },
11702         },
11703 };
11704
11705 /* mute/unmute internal speaker according to the hp jacks and mute state */
11706 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11707 {
11708         struct alc_spec *spec = codec->spec;
11709         unsigned int mute;
11710
11711         if (force || !spec->sense_updated) {
11712                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11713                                      snd_hda_jack_detect(codec, 0x1b);
11714                 spec->sense_updated = 1;
11715         }
11716         /* unmute internal speaker only if both HPs are unplugged and
11717          * master switch is on
11718          */
11719         if (spec->jack_present)
11720                 mute = HDA_AMP_MUTE;
11721         else
11722                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11723         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11724                                  HDA_AMP_MUTE, mute);
11725 }
11726
11727 /* unsolicited event for HP jack sensing */
11728 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11729                                        unsigned int res)
11730 {
11731         if ((res >> 26) != ALC_HP_EVENT)
11732                 return;
11733         alc262_fujitsu_automute(codec, 1);
11734 }
11735
11736 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11737 {
11738         alc262_fujitsu_automute(codec, 1);
11739 }
11740
11741 /* bind volumes of both NID 0x0c and 0x0d */
11742 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11743         .ops = &snd_hda_bind_vol,
11744         .values = {
11745                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11746                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11747                 0
11748         },
11749 };
11750
11751 /* mute/unmute internal speaker according to the hp jack and mute state */
11752 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11753 {
11754         struct alc_spec *spec = codec->spec;
11755         unsigned int mute;
11756
11757         if (force || !spec->sense_updated) {
11758                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11759                 spec->sense_updated = 1;
11760         }
11761         if (spec->jack_present) {
11762                 /* mute internal speaker */
11763                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11764                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11765                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11766                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11767         } else {
11768                 /* unmute internal speaker if necessary */
11769                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11770                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11771                                          HDA_AMP_MUTE, mute);
11772                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11773                                          HDA_AMP_MUTE, mute);
11774         }
11775 }
11776
11777 /* unsolicited event for HP jack sensing */
11778 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11779                                        unsigned int res)
11780 {
11781         if ((res >> 26) != ALC_HP_EVENT)
11782                 return;
11783         alc262_lenovo_3000_automute(codec, 1);
11784 }
11785
11786 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11787                                   int dir, int idx, long *valp)
11788 {
11789         int i, change = 0;
11790
11791         for (i = 0; i < 2; i++, valp++)
11792                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11793                                                    HDA_AMP_MUTE,
11794                                                    *valp ? 0 : HDA_AMP_MUTE);
11795         return change;
11796 }
11797
11798 /* bind hp and internal speaker mute (with plug check) */
11799 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11800                                          struct snd_ctl_elem_value *ucontrol)
11801 {
11802         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11803         long *valp = ucontrol->value.integer.value;
11804         int change;
11805
11806         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11807         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11808         if (change)
11809                 alc262_fujitsu_automute(codec, 0);
11810         return change;
11811 }
11812
11813 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11814         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11815         {
11816                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11817                 .name = "Master Playback Switch",
11818                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11819                 .info = snd_hda_mixer_amp_switch_info,
11820                 .get = snd_hda_mixer_amp_switch_get,
11821                 .put = alc262_fujitsu_master_sw_put,
11822                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11823         },
11824         {
11825                 .iface = NID_MAPPING,
11826                 .name = "Master Playback Switch",
11827                 .private_value = 0x1b,
11828         },
11829         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11830         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11831         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11832         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11833         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11834         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11835         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11836         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11837         { } /* end */
11838 };
11839
11840 /* bind hp and internal speaker mute (with plug check) */
11841 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11842                                          struct snd_ctl_elem_value *ucontrol)
11843 {
11844         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11845         long *valp = ucontrol->value.integer.value;
11846         int change;
11847
11848         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11849         if (change)
11850                 alc262_lenovo_3000_automute(codec, 0);
11851         return change;
11852 }
11853
11854 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11855         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11856         {
11857                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11858                 .name = "Master Playback Switch",
11859                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11860                 .info = snd_hda_mixer_amp_switch_info,
11861                 .get = snd_hda_mixer_amp_switch_get,
11862                 .put = alc262_lenovo_3000_master_sw_put,
11863                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11864         },
11865         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11866         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11867         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11868         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11869         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11870         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11871         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11872         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11873         { } /* end */
11874 };
11875
11876 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11877         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11878         ALC262_HIPPO_MASTER_SWITCH,
11879         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11880         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11881         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11882         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11883         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11884         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11885         { } /* end */
11886 };
11887
11888 /* additional init verbs for Benq laptops */
11889 static struct hda_verb alc262_EAPD_verbs[] = {
11890         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11891         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11892         {}
11893 };
11894
11895 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11896         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11897         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11898
11899         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11900         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11901         {}
11902 };
11903
11904 /* Samsung Q1 Ultra Vista model setup */
11905 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11906         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11907         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11908         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11909         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11910         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11911         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11912         { } /* end */
11913 };
11914
11915 static struct hda_verb alc262_ultra_verbs[] = {
11916         /* output mixer */
11917         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11918         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11919         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11920         /* speaker */
11921         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11922         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11923         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11924         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11925         /* HP */
11926         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11927         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11928         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11929         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11930         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11931         /* internal mic */
11932         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11933         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11934         /* ADC, choose mic */
11935         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11936         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11937         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11938         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11939         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11940         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11941         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11942         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11943         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11944         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11945         {}
11946 };
11947
11948 /* mute/unmute internal speaker according to the hp jack and mute state */
11949 static void alc262_ultra_automute(struct hda_codec *codec)
11950 {
11951         struct alc_spec *spec = codec->spec;
11952         unsigned int mute;
11953
11954         mute = 0;
11955         /* auto-mute only when HP is used as HP */
11956         if (!spec->cur_mux[0]) {
11957                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11958                 if (spec->jack_present)
11959                         mute = HDA_AMP_MUTE;
11960         }
11961         /* mute/unmute internal speaker */
11962         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11963                                  HDA_AMP_MUTE, mute);
11964         /* mute/unmute HP */
11965         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11966                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11967 }
11968
11969 /* unsolicited event for HP jack sensing */
11970 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11971                                        unsigned int res)
11972 {
11973         if ((res >> 26) != ALC880_HP_EVENT)
11974                 return;
11975         alc262_ultra_automute(codec);
11976 }
11977
11978 static struct hda_input_mux alc262_ultra_capture_source = {
11979         .num_items = 2,
11980         .items = {
11981                 { "Mic", 0x1 },
11982                 { "Headphone", 0x7 },
11983         },
11984 };
11985
11986 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11987                                      struct snd_ctl_elem_value *ucontrol)
11988 {
11989         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11990         struct alc_spec *spec = codec->spec;
11991         int ret;
11992
11993         ret = alc_mux_enum_put(kcontrol, ucontrol);
11994         if (!ret)
11995                 return 0;
11996         /* reprogram the HP pin as mic or HP according to the input source */
11997         snd_hda_codec_write_cache(codec, 0x15, 0,
11998                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11999                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12000         alc262_ultra_automute(codec); /* mute/unmute HP */
12001         return ret;
12002 }
12003
12004 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12005         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12006         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12007         {
12008                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12009                 .name = "Capture Source",
12010                 .info = alc_mux_enum_info,
12011                 .get = alc_mux_enum_get,
12012                 .put = alc262_ultra_mux_enum_put,
12013         },
12014         {
12015                 .iface = NID_MAPPING,
12016                 .name = "Capture Source",
12017                 .private_value = 0x15,
12018         },
12019         { } /* end */
12020 };
12021
12022 /* We use two mixers depending on the output pin; 0x16 is a mono output
12023  * and thus it's bound with a different mixer.
12024  * This function returns which mixer amp should be used.
12025  */
12026 static int alc262_check_volbit(hda_nid_t nid)
12027 {
12028         if (!nid)
12029                 return 0;
12030         else if (nid == 0x16)
12031                 return 2;
12032         else
12033                 return 1;
12034 }
12035
12036 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12037                                   const char *pfx, int *vbits, int idx)
12038 {
12039         unsigned long val;
12040         int vbit;
12041
12042         vbit = alc262_check_volbit(nid);
12043         if (!vbit)
12044                 return 0;
12045         if (*vbits & vbit) /* a volume control for this mixer already there */
12046                 return 0;
12047         *vbits |= vbit;
12048         if (vbit == 2)
12049                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12050         else
12051                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12052         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12053 }
12054
12055 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12056                                  const char *pfx, int idx)
12057 {
12058         unsigned long val;
12059
12060         if (!nid)
12061                 return 0;
12062         if (nid == 0x16)
12063                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12064         else
12065                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12066         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12067 }
12068
12069 /* add playback controls from the parsed DAC table */
12070 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12071                                              const struct auto_pin_cfg *cfg)
12072 {
12073         const char *pfx;
12074         int vbits;
12075         int i, err;
12076
12077         spec->multiout.num_dacs = 1;    /* only use one dac */
12078         spec->multiout.dac_nids = spec->private_dac_nids;
12079         spec->multiout.dac_nids[0] = 2;
12080
12081         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
12082                 pfx = "Master";
12083         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12084                 pfx = "Speaker";
12085         else if (cfg->line_out_type == AUTO_PIN_HP_OUT)
12086                 pfx = "Headphone";
12087         else
12088                 pfx = "Front";
12089         for (i = 0; i < 2; i++) {
12090                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12091                 if (err < 0)
12092                         return err;
12093                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12094                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12095                                                     "Speaker", i);
12096                         if (err < 0)
12097                                 return err;
12098                 }
12099                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12100                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12101                                                     "Headphone", i);
12102                         if (err < 0)
12103                                 return err;
12104                 }
12105         }
12106
12107         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12108                 alc262_check_volbit(cfg->speaker_pins[0]) |
12109                 alc262_check_volbit(cfg->hp_pins[0]);
12110         if (vbits == 1 || vbits == 2)
12111                 pfx = "Master"; /* only one mixer is used */
12112         vbits = 0;
12113         for (i = 0; i < 2; i++) {
12114                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12115                                              &vbits, i);
12116                 if (err < 0)
12117                         return err;
12118                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12119                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12120                                                      "Speaker", &vbits, i);
12121                         if (err < 0)
12122                                 return err;
12123                 }
12124                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12125                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12126                                                      "Headphone", &vbits, i);
12127                         if (err < 0)
12128                                 return err;
12129                 }
12130         }
12131         return 0;
12132 }
12133
12134 #define alc262_auto_create_input_ctls \
12135         alc882_auto_create_input_ctls
12136
12137 /*
12138  * generic initialization of ADC, input mixers and output mixers
12139  */
12140 static struct hda_verb alc262_volume_init_verbs[] = {
12141         /*
12142          * Unmute ADC0-2 and set the default input to mic-in
12143          */
12144         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12145         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12146         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12147         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12148         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12150
12151         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12152          * mixer widget
12153          * Note: PASD motherboards uses the Line In 2 as the input for
12154          * front panel mic (mic 2)
12155          */
12156         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12157         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12158         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12159         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12160         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12161         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12162
12163         /*
12164          * Set up output mixers (0x0c - 0x0f)
12165          */
12166         /* set vol=0 to output mixers */
12167         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12168         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12169         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12170
12171         /* set up input amps for analog loopback */
12172         /* Amp Indices: DAC = 0, mixer = 1 */
12173         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12174         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12175         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12176         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12177         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12178         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12179
12180         /* FIXME: use matrix-type input source selection */
12181         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12182         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12183         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12184         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12185         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12186         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12187         /* Input mixer2 */
12188         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12189         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12190         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12191         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12192         /* Input mixer3 */
12193         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12194         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12195         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12196         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12197
12198         { }
12199 };
12200
12201 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12202         /*
12203          * Unmute ADC0-2 and set the default input to mic-in
12204          */
12205         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12206         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12207         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12208         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12209         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12210         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12211
12212         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12213          * mixer widget
12214          * Note: PASD motherboards uses the Line In 2 as the input for
12215          * front panel mic (mic 2)
12216          */
12217         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12218         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12219         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12220         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12221         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12222         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12223         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12224         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12225
12226         /*
12227          * Set up output mixers (0x0c - 0x0e)
12228          */
12229         /* set vol=0 to output mixers */
12230         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12231         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12232         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12233
12234         /* set up input amps for analog loopback */
12235         /* Amp Indices: DAC = 0, mixer = 1 */
12236         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12237         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12238         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12239         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12240         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12241         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12242
12243         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12244         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12245         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12246
12247         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12248         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12249
12250         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12251         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12252
12253         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12254         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12255         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12256         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12257         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12258
12259         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12260         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12261         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12262         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12263         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12264         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12265
12266
12267         /* FIXME: use matrix-type input source selection */
12268         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12269         /* Input mixer1: only unmute Mic */
12270         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12271         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12272         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12273         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12274         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12275         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12276         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12277         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12278         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12279         /* Input mixer2 */
12280         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12281         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12282         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12283         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12284         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12285         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12286         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12287         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12288         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12289         /* Input mixer3 */
12290         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12291         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12292         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12293         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12294         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12295         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12296         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12297         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12298         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12299
12300         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12301
12302         { }
12303 };
12304
12305 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12306         /*
12307          * Unmute ADC0-2 and set the default input to mic-in
12308          */
12309         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12310         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12311         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12312         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12313         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12314         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12315
12316         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12317          * mixer widget
12318          * Note: PASD motherboards uses the Line In 2 as the input for front
12319          * panel mic (mic 2)
12320          */
12321         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12322         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12323         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12324         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12325         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12326         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12327         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12328         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12329         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12330         /*
12331          * Set up output mixers (0x0c - 0x0e)
12332          */
12333         /* set vol=0 to output mixers */
12334         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12335         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12336         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12337
12338         /* set up input amps for analog loopback */
12339         /* Amp Indices: DAC = 0, mixer = 1 */
12340         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12341         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12342         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12343         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12344         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12345         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12346
12347
12348         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12349         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12350         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12351         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12352         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12353         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12354         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12355
12356         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12357         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12358
12359         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12360         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12361
12362         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12363         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12364         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12365         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12366         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12367         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12368
12369         /* FIXME: use matrix-type input source selection */
12370         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12371         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12372         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12373         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12374         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12375         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12376         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12377         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12378         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12379         /* Input mixer2 */
12380         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12381         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12382         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12383         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12384         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12385         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12386         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12387         /* Input mixer3 */
12388         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12389         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12390         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12391         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12392         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12393         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12394         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12395
12396         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12397
12398         { }
12399 };
12400
12401 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12402
12403         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12404         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12405         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12406
12407         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12408         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12409         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12410         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12411
12412         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12413         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12414         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12415         {}
12416 };
12417
12418 /*
12419  * Pin config fixes
12420  */
12421 enum {
12422         PINFIX_FSC_H270,
12423 };
12424
12425 static const struct alc_fixup alc262_fixups[] = {
12426         [PINFIX_FSC_H270] = {
12427                 .pins = (const struct alc_pincfg[]) {
12428                         { 0x14, 0x99130110 }, /* speaker */
12429                         { 0x15, 0x0221142f }, /* front HP */
12430                         { 0x1b, 0x0121141f }, /* rear HP */
12431                         { }
12432                 }
12433         },
12434         [PINFIX_PB_M5210] = {
12435                 .verbs = (const struct hda_verb[]) {
12436                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
12437                         {}
12438                 }
12439         },
12440 };
12441
12442 static struct snd_pci_quirk alc262_fixup_tbl[] = {
12443         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12444         {}
12445 };
12446
12447
12448 #ifdef CONFIG_SND_HDA_POWER_SAVE
12449 #define alc262_loopbacks        alc880_loopbacks
12450 #endif
12451
12452 /* pcm configuration: identical with ALC880 */
12453 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12454 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12455 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12456 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12457
12458 /*
12459  * BIOS auto configuration
12460  */
12461 static int alc262_parse_auto_config(struct hda_codec *codec)
12462 {
12463         struct alc_spec *spec = codec->spec;
12464         int err;
12465         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12466
12467         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12468                                            alc262_ignore);
12469         if (err < 0)
12470                 return err;
12471         if (!spec->autocfg.line_outs) {
12472                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12473                         spec->multiout.max_channels = 2;
12474                         spec->no_analog = 1;
12475                         goto dig_only;
12476                 }
12477                 return 0; /* can't find valid BIOS pin config */
12478         }
12479         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12480         if (err < 0)
12481                 return err;
12482         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12483         if (err < 0)
12484                 return err;
12485
12486         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12487
12488  dig_only:
12489         alc_auto_parse_digital(codec);
12490
12491         if (spec->kctls.list)
12492                 add_mixer(spec, spec->kctls.list);
12493
12494         add_verb(spec, alc262_volume_init_verbs);
12495         spec->num_mux_defs = 1;
12496         spec->input_mux = &spec->private_imux[0];
12497
12498         err = alc_auto_add_mic_boost(codec);
12499         if (err < 0)
12500                 return err;
12501
12502         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12503
12504         return 1;
12505 }
12506
12507 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12508 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12509 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12510 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12511
12512
12513 /* init callback for auto-configuration model -- overriding the default init */
12514 static void alc262_auto_init(struct hda_codec *codec)
12515 {
12516         struct alc_spec *spec = codec->spec;
12517         alc262_auto_init_multi_out(codec);
12518         alc262_auto_init_hp_out(codec);
12519         alc262_auto_init_analog_input(codec);
12520         alc262_auto_init_input_src(codec);
12521         alc_auto_init_digital(codec);
12522         if (spec->unsol_event)
12523                 alc_inithook(codec);
12524 }
12525
12526 /*
12527  * configuration and preset
12528  */
12529 static const char *alc262_models[ALC262_MODEL_LAST] = {
12530         [ALC262_BASIC]          = "basic",
12531         [ALC262_HIPPO]          = "hippo",
12532         [ALC262_HIPPO_1]        = "hippo_1",
12533         [ALC262_FUJITSU]        = "fujitsu",
12534         [ALC262_HP_BPC]         = "hp-bpc",
12535         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12536         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12537         [ALC262_HP_RP5700]      = "hp-rp5700",
12538         [ALC262_BENQ_ED8]       = "benq",
12539         [ALC262_BENQ_T31]       = "benq-t31",
12540         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12541         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12542         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12543         [ALC262_ULTRA]          = "ultra",
12544         [ALC262_LENOVO_3000]    = "lenovo-3000",
12545         [ALC262_NEC]            = "nec",
12546         [ALC262_TYAN]           = "tyan",
12547         [ALC262_AUTO]           = "auto",
12548 };
12549
12550 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12551         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12552         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12553         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12554                            ALC262_HP_BPC),
12555         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12556                            ALC262_HP_BPC),
12557         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12558                            ALC262_HP_BPC),
12559         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12560         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12561         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12562         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12563         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12564         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12565         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12566         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12567         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12568         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12569         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12570         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12571                       ALC262_HP_TC_T5735),
12572         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12573         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12574         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12575         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12576         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12577         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12578         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12579         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12580 #if 0 /* disable the quirk since model=auto works better in recent versions */
12581         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12582                            ALC262_SONY_ASSAMD),
12583 #endif
12584         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12585                       ALC262_TOSHIBA_RX1),
12586         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12587         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12588         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12589         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12590         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12591                            ALC262_ULTRA),
12592         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12593         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12594         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12595         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12596         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12597         {}
12598 };
12599
12600 static struct alc_config_preset alc262_presets[] = {
12601         [ALC262_BASIC] = {
12602                 .mixers = { alc262_base_mixer },
12603                 .init_verbs = { alc262_init_verbs },
12604                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12605                 .dac_nids = alc262_dac_nids,
12606                 .hp_nid = 0x03,
12607                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12608                 .channel_mode = alc262_modes,
12609                 .input_mux = &alc262_capture_source,
12610         },
12611         [ALC262_HIPPO] = {
12612                 .mixers = { alc262_hippo_mixer },
12613                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12614                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12615                 .dac_nids = alc262_dac_nids,
12616                 .hp_nid = 0x03,
12617                 .dig_out_nid = ALC262_DIGOUT_NID,
12618                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12619                 .channel_mode = alc262_modes,
12620                 .input_mux = &alc262_capture_source,
12621                 .unsol_event = alc262_hippo_unsol_event,
12622                 .setup = alc262_hippo_setup,
12623                 .init_hook = alc262_hippo_automute,
12624         },
12625         [ALC262_HIPPO_1] = {
12626                 .mixers = { alc262_hippo1_mixer },
12627                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12628                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12629                 .dac_nids = alc262_dac_nids,
12630                 .hp_nid = 0x02,
12631                 .dig_out_nid = ALC262_DIGOUT_NID,
12632                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12633                 .channel_mode = alc262_modes,
12634                 .input_mux = &alc262_capture_source,
12635                 .unsol_event = alc262_hippo_unsol_event,
12636                 .setup = alc262_hippo1_setup,
12637                 .init_hook = alc262_hippo_automute,
12638         },
12639         [ALC262_FUJITSU] = {
12640                 .mixers = { alc262_fujitsu_mixer },
12641                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12642                                 alc262_fujitsu_unsol_verbs },
12643                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12644                 .dac_nids = alc262_dac_nids,
12645                 .hp_nid = 0x03,
12646                 .dig_out_nid = ALC262_DIGOUT_NID,
12647                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12648                 .channel_mode = alc262_modes,
12649                 .input_mux = &alc262_fujitsu_capture_source,
12650                 .unsol_event = alc262_fujitsu_unsol_event,
12651                 .init_hook = alc262_fujitsu_init_hook,
12652         },
12653         [ALC262_HP_BPC] = {
12654                 .mixers = { alc262_HP_BPC_mixer },
12655                 .init_verbs = { alc262_HP_BPC_init_verbs },
12656                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12657                 .dac_nids = alc262_dac_nids,
12658                 .hp_nid = 0x03,
12659                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12660                 .channel_mode = alc262_modes,
12661                 .input_mux = &alc262_HP_capture_source,
12662                 .unsol_event = alc262_hp_bpc_unsol_event,
12663                 .init_hook = alc262_hp_bpc_automute,
12664         },
12665         [ALC262_HP_BPC_D7000_WF] = {
12666                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12667                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12668                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12669                 .dac_nids = alc262_dac_nids,
12670                 .hp_nid = 0x03,
12671                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12672                 .channel_mode = alc262_modes,
12673                 .input_mux = &alc262_HP_D7000_capture_source,
12674                 .unsol_event = alc262_hp_wildwest_unsol_event,
12675                 .init_hook = alc262_hp_wildwest_automute,
12676         },
12677         [ALC262_HP_BPC_D7000_WL] = {
12678                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12679                             alc262_HP_BPC_WildWest_option_mixer },
12680                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12681                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12682                 .dac_nids = alc262_dac_nids,
12683                 .hp_nid = 0x03,
12684                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12685                 .channel_mode = alc262_modes,
12686                 .input_mux = &alc262_HP_D7000_capture_source,
12687                 .unsol_event = alc262_hp_wildwest_unsol_event,
12688                 .init_hook = alc262_hp_wildwest_automute,
12689         },
12690         [ALC262_HP_TC_T5735] = {
12691                 .mixers = { alc262_hp_t5735_mixer },
12692                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12693                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12694                 .dac_nids = alc262_dac_nids,
12695                 .hp_nid = 0x03,
12696                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12697                 .channel_mode = alc262_modes,
12698                 .input_mux = &alc262_capture_source,
12699                 .unsol_event = alc_sku_unsol_event,
12700                 .setup = alc262_hp_t5735_setup,
12701                 .init_hook = alc_inithook,
12702         },
12703         [ALC262_HP_RP5700] = {
12704                 .mixers = { alc262_hp_rp5700_mixer },
12705                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12706                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12707                 .dac_nids = alc262_dac_nids,
12708                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12709                 .channel_mode = alc262_modes,
12710                 .input_mux = &alc262_hp_rp5700_capture_source,
12711         },
12712         [ALC262_BENQ_ED8] = {
12713                 .mixers = { alc262_base_mixer },
12714                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12715                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12716                 .dac_nids = alc262_dac_nids,
12717                 .hp_nid = 0x03,
12718                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12719                 .channel_mode = alc262_modes,
12720                 .input_mux = &alc262_capture_source,
12721         },
12722         [ALC262_SONY_ASSAMD] = {
12723                 .mixers = { alc262_sony_mixer },
12724                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12725                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12726                 .dac_nids = alc262_dac_nids,
12727                 .hp_nid = 0x02,
12728                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12729                 .channel_mode = alc262_modes,
12730                 .input_mux = &alc262_capture_source,
12731                 .unsol_event = alc262_hippo_unsol_event,
12732                 .setup = alc262_hippo_setup,
12733                 .init_hook = alc262_hippo_automute,
12734         },
12735         [ALC262_BENQ_T31] = {
12736                 .mixers = { alc262_benq_t31_mixer },
12737                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12738                                 alc_hp15_unsol_verbs },
12739                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12740                 .dac_nids = alc262_dac_nids,
12741                 .hp_nid = 0x03,
12742                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12743                 .channel_mode = alc262_modes,
12744                 .input_mux = &alc262_capture_source,
12745                 .unsol_event = alc262_hippo_unsol_event,
12746                 .setup = alc262_hippo_setup,
12747                 .init_hook = alc262_hippo_automute,
12748         },
12749         [ALC262_ULTRA] = {
12750                 .mixers = { alc262_ultra_mixer },
12751                 .cap_mixer = alc262_ultra_capture_mixer,
12752                 .init_verbs = { alc262_ultra_verbs },
12753                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12754                 .dac_nids = alc262_dac_nids,
12755                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12756                 .channel_mode = alc262_modes,
12757                 .input_mux = &alc262_ultra_capture_source,
12758                 .adc_nids = alc262_adc_nids, /* ADC0 */
12759                 .capsrc_nids = alc262_capsrc_nids,
12760                 .num_adc_nids = 1, /* single ADC */
12761                 .unsol_event = alc262_ultra_unsol_event,
12762                 .init_hook = alc262_ultra_automute,
12763         },
12764         [ALC262_LENOVO_3000] = {
12765                 .mixers = { alc262_lenovo_3000_mixer },
12766                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12767                                 alc262_lenovo_3000_unsol_verbs,
12768                                 alc262_lenovo_3000_init_verbs },
12769                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12770                 .dac_nids = alc262_dac_nids,
12771                 .hp_nid = 0x03,
12772                 .dig_out_nid = ALC262_DIGOUT_NID,
12773                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12774                 .channel_mode = alc262_modes,
12775                 .input_mux = &alc262_fujitsu_capture_source,
12776                 .unsol_event = alc262_lenovo_3000_unsol_event,
12777         },
12778         [ALC262_NEC] = {
12779                 .mixers = { alc262_nec_mixer },
12780                 .init_verbs = { alc262_nec_verbs },
12781                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12782                 .dac_nids = alc262_dac_nids,
12783                 .hp_nid = 0x03,
12784                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12785                 .channel_mode = alc262_modes,
12786                 .input_mux = &alc262_capture_source,
12787         },
12788         [ALC262_TOSHIBA_S06] = {
12789                 .mixers = { alc262_toshiba_s06_mixer },
12790                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12791                                                         alc262_eapd_verbs },
12792                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12793                 .capsrc_nids = alc262_dmic_capsrc_nids,
12794                 .dac_nids = alc262_dac_nids,
12795                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12796                 .num_adc_nids = 1, /* single ADC */
12797                 .dig_out_nid = ALC262_DIGOUT_NID,
12798                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12799                 .channel_mode = alc262_modes,
12800                 .unsol_event = alc_sku_unsol_event,
12801                 .setup = alc262_toshiba_s06_setup,
12802                 .init_hook = alc_inithook,
12803         },
12804         [ALC262_TOSHIBA_RX1] = {
12805                 .mixers = { alc262_toshiba_rx1_mixer },
12806                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12807                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12808                 .dac_nids = alc262_dac_nids,
12809                 .hp_nid = 0x03,
12810                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12811                 .channel_mode = alc262_modes,
12812                 .input_mux = &alc262_capture_source,
12813                 .unsol_event = alc262_hippo_unsol_event,
12814                 .setup = alc262_hippo_setup,
12815                 .init_hook = alc262_hippo_automute,
12816         },
12817         [ALC262_TYAN] = {
12818                 .mixers = { alc262_tyan_mixer },
12819                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12820                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12821                 .dac_nids = alc262_dac_nids,
12822                 .hp_nid = 0x02,
12823                 .dig_out_nid = ALC262_DIGOUT_NID,
12824                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12825                 .channel_mode = alc262_modes,
12826                 .input_mux = &alc262_capture_source,
12827                 .unsol_event = alc_automute_amp_unsol_event,
12828                 .setup = alc262_tyan_setup,
12829                 .init_hook = alc_automute_amp,
12830         },
12831 };
12832
12833 static int patch_alc262(struct hda_codec *codec)
12834 {
12835         struct alc_spec *spec;
12836         int board_config;
12837         int err;
12838
12839         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12840         if (spec == NULL)
12841                 return -ENOMEM;
12842
12843         codec->spec = spec;
12844 #if 0
12845         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12846          * under-run
12847          */
12848         {
12849         int tmp;
12850         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12851         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12852         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12853         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12854         }
12855 #endif
12856         alc_auto_parse_customize_define(codec);
12857
12858         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12859
12860         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12861                                                   alc262_models,
12862                                                   alc262_cfg_tbl);
12863
12864         if (board_config < 0) {
12865                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12866                        codec->chip_name);
12867                 board_config = ALC262_AUTO;
12868         }
12869
12870         if (board_config == ALC262_AUTO)
12871                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1);
12872
12873         if (board_config == ALC262_AUTO) {
12874                 /* automatic parse from the BIOS config */
12875                 err = alc262_parse_auto_config(codec);
12876                 if (err < 0) {
12877                         alc_free(codec);
12878                         return err;
12879                 } else if (!err) {
12880                         printk(KERN_INFO
12881                                "hda_codec: Cannot set up configuration "
12882                                "from BIOS.  Using base mode...\n");
12883                         board_config = ALC262_BASIC;
12884                 }
12885         }
12886
12887         if (!spec->no_analog && has_cdefine_beep(codec)) {
12888                 err = snd_hda_attach_beep_device(codec, 0x1);
12889                 if (err < 0) {
12890                         alc_free(codec);
12891                         return err;
12892                 }
12893         }
12894
12895         if (board_config != ALC262_AUTO)
12896                 setup_preset(codec, &alc262_presets[board_config]);
12897
12898         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12899         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12900
12901         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12902         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12903
12904         if (!spec->adc_nids && spec->input_mux) {
12905                 int i;
12906                 /* check whether the digital-mic has to be supported */
12907                 for (i = 0; i < spec->input_mux->num_items; i++) {
12908                         if (spec->input_mux->items[i].index >= 9)
12909                                 break;
12910                 }
12911                 if (i < spec->input_mux->num_items) {
12912                         /* use only ADC0 */
12913                         spec->adc_nids = alc262_dmic_adc_nids;
12914                         spec->num_adc_nids = 1;
12915                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12916                 } else {
12917                         /* all analog inputs */
12918                         /* check whether NID 0x07 is valid */
12919                         unsigned int wcap = get_wcaps(codec, 0x07);
12920
12921                         /* get type */
12922                         wcap = get_wcaps_type(wcap);
12923                         if (wcap != AC_WID_AUD_IN) {
12924                                 spec->adc_nids = alc262_adc_nids_alt;
12925                                 spec->num_adc_nids =
12926                                         ARRAY_SIZE(alc262_adc_nids_alt);
12927                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12928                         } else {
12929                                 spec->adc_nids = alc262_adc_nids;
12930                                 spec->num_adc_nids =
12931                                         ARRAY_SIZE(alc262_adc_nids);
12932                                 spec->capsrc_nids = alc262_capsrc_nids;
12933                         }
12934                 }
12935         }
12936         if (!spec->cap_mixer && !spec->no_analog)
12937                 set_capture_mixer(codec);
12938         if (!spec->no_analog && has_cdefine_beep(codec))
12939                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12940
12941         if (board_config == ALC262_AUTO)
12942                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0);
12943
12944         spec->vmaster_nid = 0x0c;
12945
12946         codec->patch_ops = alc_patch_ops;
12947         if (board_config == ALC262_AUTO)
12948                 spec->init_hook = alc262_auto_init;
12949
12950         alc_init_jacks(codec);
12951 #ifdef CONFIG_SND_HDA_POWER_SAVE
12952         if (!spec->loopback.amplist)
12953                 spec->loopback.amplist = alc262_loopbacks;
12954 #endif
12955
12956         return 0;
12957 }
12958
12959 /*
12960  *  ALC268 channel source setting (2 channel)
12961  */
12962 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12963 #define alc268_modes            alc260_modes
12964
12965 static hda_nid_t alc268_dac_nids[2] = {
12966         /* front, hp */
12967         0x02, 0x03
12968 };
12969
12970 static hda_nid_t alc268_adc_nids[2] = {
12971         /* ADC0-1 */
12972         0x08, 0x07
12973 };
12974
12975 static hda_nid_t alc268_adc_nids_alt[1] = {
12976         /* ADC0 */
12977         0x08
12978 };
12979
12980 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12981
12982 static struct snd_kcontrol_new alc268_base_mixer[] = {
12983         /* output mixer control */
12984         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12985         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12986         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12987         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12988         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12989         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12990         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12991         { }
12992 };
12993
12994 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12995         /* output mixer control */
12996         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12997         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12998         ALC262_HIPPO_MASTER_SWITCH,
12999         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13000         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13001         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13002         { }
13003 };
13004
13005 /* bind Beep switches of both NID 0x0f and 0x10 */
13006 static struct hda_bind_ctls alc268_bind_beep_sw = {
13007         .ops = &snd_hda_bind_sw,
13008         .values = {
13009                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13010                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13011                 0
13012         },
13013 };
13014
13015 static struct snd_kcontrol_new alc268_beep_mixer[] = {
13016         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13017         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13018         { }
13019 };
13020
13021 static struct hda_verb alc268_eapd_verbs[] = {
13022         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13023         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13024         { }
13025 };
13026
13027 /* Toshiba specific */
13028 static struct hda_verb alc268_toshiba_verbs[] = {
13029         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13030         { } /* end */
13031 };
13032
13033 /* Acer specific */
13034 /* bind volumes of both NID 0x02 and 0x03 */
13035 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13036         .ops = &snd_hda_bind_vol,
13037         .values = {
13038                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13039                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13040                 0
13041         },
13042 };
13043
13044 /* mute/unmute internal speaker according to the hp jack and mute state */
13045 static void alc268_acer_automute(struct hda_codec *codec, int force)
13046 {
13047         struct alc_spec *spec = codec->spec;
13048         unsigned int mute;
13049
13050         if (force || !spec->sense_updated) {
13051                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13052                 spec->sense_updated = 1;
13053         }
13054         if (spec->jack_present)
13055                 mute = HDA_AMP_MUTE; /* mute internal speaker */
13056         else /* unmute internal speaker if necessary */
13057                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13058         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13059                                  HDA_AMP_MUTE, mute);
13060 }
13061
13062
13063 /* bind hp and internal speaker mute (with plug check) */
13064 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13065                                      struct snd_ctl_elem_value *ucontrol)
13066 {
13067         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13068         long *valp = ucontrol->value.integer.value;
13069         int change;
13070
13071         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13072         if (change)
13073                 alc268_acer_automute(codec, 0);
13074         return change;
13075 }
13076
13077 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13078         /* output mixer control */
13079         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13080         {
13081                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13082                 .name = "Master Playback Switch",
13083                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13084                 .info = snd_hda_mixer_amp_switch_info,
13085                 .get = snd_hda_mixer_amp_switch_get,
13086                 .put = alc268_acer_master_sw_put,
13087                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13088         },
13089         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13090         { }
13091 };
13092
13093 static struct snd_kcontrol_new alc268_acer_mixer[] = {
13094         /* output mixer control */
13095         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13096         {
13097                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13098                 .name = "Master Playback Switch",
13099                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13100                 .info = snd_hda_mixer_amp_switch_info,
13101                 .get = snd_hda_mixer_amp_switch_get,
13102                 .put = alc268_acer_master_sw_put,
13103                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13104         },
13105         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13106         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13107         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13108         { }
13109 };
13110
13111 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13112         /* output mixer control */
13113         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13114         {
13115                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13116                 .name = "Master Playback Switch",
13117                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13118                 .info = snd_hda_mixer_amp_switch_info,
13119                 .get = snd_hda_mixer_amp_switch_get,
13120                 .put = alc268_acer_master_sw_put,
13121                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13122         },
13123         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13124         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13125         { }
13126 };
13127
13128 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13129         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13130         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13131         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13132         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13133         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13134         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13135         { }
13136 };
13137
13138 static struct hda_verb alc268_acer_verbs[] = {
13139         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13140         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13141         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13142         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13143         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13144         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13145         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13146         { }
13147 };
13148
13149 /* unsolicited event for HP jack sensing */
13150 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
13151 #define alc268_toshiba_setup            alc262_hippo_setup
13152 #define alc268_toshiba_automute         alc262_hippo_automute
13153
13154 static void alc268_acer_unsol_event(struct hda_codec *codec,
13155                                        unsigned int res)
13156 {
13157         if ((res >> 26) != ALC880_HP_EVENT)
13158                 return;
13159         alc268_acer_automute(codec, 1);
13160 }
13161
13162 static void alc268_acer_init_hook(struct hda_codec *codec)
13163 {
13164         alc268_acer_automute(codec, 1);
13165 }
13166
13167 /* toggle speaker-output according to the hp-jack state */
13168 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13169 {
13170         unsigned int present;
13171         unsigned char bits;
13172
13173         present = snd_hda_jack_detect(codec, 0x15);
13174         bits = present ? HDA_AMP_MUTE : 0;
13175         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13176                                  HDA_AMP_MUTE, bits);
13177         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13178                                  HDA_AMP_MUTE, bits);
13179 }
13180
13181 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13182                                     unsigned int res)
13183 {
13184         switch (res >> 26) {
13185         case ALC880_HP_EVENT:
13186                 alc268_aspire_one_speaker_automute(codec);
13187                 break;
13188         case ALC880_MIC_EVENT:
13189                 alc_mic_automute(codec);
13190                 break;
13191         }
13192 }
13193
13194 static void alc268_acer_lc_setup(struct hda_codec *codec)
13195 {
13196         struct alc_spec *spec = codec->spec;
13197         spec->ext_mic.pin = 0x18;
13198         spec->ext_mic.mux_idx = 0;
13199         spec->int_mic.pin = 0x12;
13200         spec->int_mic.mux_idx = 6;
13201         spec->auto_mic = 1;
13202 }
13203
13204 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13205 {
13206         alc268_aspire_one_speaker_automute(codec);
13207         alc_mic_automute(codec);
13208 }
13209
13210 static struct snd_kcontrol_new alc268_dell_mixer[] = {
13211         /* output mixer control */
13212         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13213         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13214         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13215         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13216         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13217         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13218         { }
13219 };
13220
13221 static struct hda_verb alc268_dell_verbs[] = {
13222         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13223         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13224         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13225         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13226         { }
13227 };
13228
13229 /* mute/unmute internal speaker according to the hp jack and mute state */
13230 static void alc268_dell_setup(struct hda_codec *codec)
13231 {
13232         struct alc_spec *spec = codec->spec;
13233
13234         spec->autocfg.hp_pins[0] = 0x15;
13235         spec->autocfg.speaker_pins[0] = 0x14;
13236         spec->ext_mic.pin = 0x18;
13237         spec->ext_mic.mux_idx = 0;
13238         spec->int_mic.pin = 0x19;
13239         spec->int_mic.mux_idx = 1;
13240         spec->auto_mic = 1;
13241 }
13242
13243 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13244         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13245         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13246         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13247         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13248         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13249         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13250         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13251         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13252         { }
13253 };
13254
13255 static struct hda_verb alc267_quanta_il1_verbs[] = {
13256         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13257         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13258         { }
13259 };
13260
13261 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13262 {
13263         struct alc_spec *spec = codec->spec;
13264         spec->autocfg.hp_pins[0] = 0x15;
13265         spec->autocfg.speaker_pins[0] = 0x14;
13266         spec->ext_mic.pin = 0x18;
13267         spec->ext_mic.mux_idx = 0;
13268         spec->int_mic.pin = 0x19;
13269         spec->int_mic.mux_idx = 1;
13270         spec->auto_mic = 1;
13271 }
13272
13273 /*
13274  * generic initialization of ADC, input mixers and output mixers
13275  */
13276 static struct hda_verb alc268_base_init_verbs[] = {
13277         /* Unmute DAC0-1 and set vol = 0 */
13278         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13279         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13280
13281         /*
13282          * Set up output mixers (0x0c - 0x0e)
13283          */
13284         /* set vol=0 to output mixers */
13285         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13286         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13287
13288         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13289         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13290
13291         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13292         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13293         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13294         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13295         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13296         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13297         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13298         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13299
13300         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13301         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13302         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13303         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13304         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13305
13306         /* set PCBEEP vol = 0, mute connections */
13307         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13308         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13309         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13310
13311         /* Unmute Selector 23h,24h and set the default input to mic-in */
13312
13313         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13314         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13315         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13316         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13317
13318         { }
13319 };
13320
13321 /*
13322  * generic initialization of ADC, input mixers and output mixers
13323  */
13324 static struct hda_verb alc268_volume_init_verbs[] = {
13325         /* set output DAC */
13326         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13327         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13328
13329         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13330         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13331         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13332         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13333         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13334
13335         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13336         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13337         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13338
13339         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13340         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13341
13342         /* set PCBEEP vol = 0, mute connections */
13343         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13344         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13345         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13346
13347         { }
13348 };
13349
13350 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13351         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13352         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13353         { } /* end */
13354 };
13355
13356 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13357         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13358         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13359         _DEFINE_CAPSRC(1),
13360         { } /* end */
13361 };
13362
13363 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13364         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13365         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13366         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13367         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13368         _DEFINE_CAPSRC(2),
13369         { } /* end */
13370 };
13371
13372 static struct hda_input_mux alc268_capture_source = {
13373         .num_items = 4,
13374         .items = {
13375                 { "Mic", 0x0 },
13376                 { "Front Mic", 0x1 },
13377                 { "Line", 0x2 },
13378                 { "CD", 0x3 },
13379         },
13380 };
13381
13382 static struct hda_input_mux alc268_acer_capture_source = {
13383         .num_items = 3,
13384         .items = {
13385                 { "Mic", 0x0 },
13386                 { "Internal Mic", 0x1 },
13387                 { "Line", 0x2 },
13388         },
13389 };
13390
13391 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13392         .num_items = 3,
13393         .items = {
13394                 { "Mic", 0x0 },
13395                 { "Internal Mic", 0x6 },
13396                 { "Line", 0x2 },
13397         },
13398 };
13399
13400 #ifdef CONFIG_SND_DEBUG
13401 static struct snd_kcontrol_new alc268_test_mixer[] = {
13402         /* Volume widgets */
13403         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13404         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13405         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13406         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13407         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13408         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13409         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13410         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13411         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13412         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13413         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13414         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13415         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13416         /* The below appears problematic on some hardwares */
13417         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13418         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13419         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13420         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13421         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13422
13423         /* Modes for retasking pin widgets */
13424         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13425         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13426         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13427         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13428
13429         /* Controls for GPIO pins, assuming they are configured as outputs */
13430         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13431         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13432         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13433         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13434
13435         /* Switches to allow the digital SPDIF output pin to be enabled.
13436          * The ALC268 does not have an SPDIF input.
13437          */
13438         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13439
13440         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13441          * this output to turn on an external amplifier.
13442          */
13443         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13444         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13445
13446         { } /* end */
13447 };
13448 #endif
13449
13450 /* create input playback/capture controls for the given pin */
13451 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13452                                     const char *ctlname, int idx)
13453 {
13454         hda_nid_t dac;
13455         int err;
13456
13457         switch (nid) {
13458         case 0x14:
13459         case 0x16:
13460                 dac = 0x02;
13461                 break;
13462         case 0x15:
13463         case 0x1a: /* ALC259/269 only */
13464         case 0x1b: /* ALC259/269 only */
13465         case 0x21: /* ALC269vb has this pin, too */
13466                 dac = 0x03;
13467                 break;
13468         default:
13469                 snd_printd(KERN_WARNING "hda_codec: "
13470                            "ignoring pin 0x%x as unknown\n", nid);
13471                 return 0;
13472         }
13473         if (spec->multiout.dac_nids[0] != dac &&
13474             spec->multiout.dac_nids[1] != dac) {
13475                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13476                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13477                                                       HDA_OUTPUT));
13478                 if (err < 0)
13479                         return err;
13480                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13481         }
13482
13483         if (nid != 0x16)
13484                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13485                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13486         else /* mono */
13487                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13488                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13489         if (err < 0)
13490                 return err;
13491         return 0;
13492 }
13493
13494 /* add playback controls from the parsed DAC table */
13495 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13496                                              const struct auto_pin_cfg *cfg)
13497 {
13498         hda_nid_t nid;
13499         int err;
13500
13501         spec->multiout.dac_nids = spec->private_dac_nids;
13502
13503         nid = cfg->line_out_pins[0];
13504         if (nid) {
13505                 const char *name;
13506                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13507                         name = "Speaker";
13508                 else
13509                         name = "Front";
13510                 err = alc268_new_analog_output(spec, nid, name, 0);
13511                 if (err < 0)
13512                         return err;
13513         }
13514
13515         nid = cfg->speaker_pins[0];
13516         if (nid == 0x1d) {
13517                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13518                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13519                 if (err < 0)
13520                         return err;
13521         } else if (nid) {
13522                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13523                 if (err < 0)
13524                         return err;
13525         }
13526         nid = cfg->hp_pins[0];
13527         if (nid) {
13528                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13529                 if (err < 0)
13530                         return err;
13531         }
13532
13533         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13534         if (nid == 0x16) {
13535                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13536                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13537                 if (err < 0)
13538                         return err;
13539         }
13540         return 0;
13541 }
13542
13543 /* create playback/capture controls for input pins */
13544 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13545                                                 const struct auto_pin_cfg *cfg)
13546 {
13547         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13548 }
13549
13550 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13551                                               hda_nid_t nid, int pin_type)
13552 {
13553         int idx;
13554
13555         alc_set_pin_output(codec, nid, pin_type);
13556         if (nid == 0x14 || nid == 0x16)
13557                 idx = 0;
13558         else
13559                 idx = 1;
13560         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13561 }
13562
13563 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13564 {
13565         struct alc_spec *spec = codec->spec;
13566         int i;
13567
13568         for (i = 0; i < spec->autocfg.line_outs; i++) {
13569                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13570                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13571                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13572         }
13573 }
13574
13575 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13576 {
13577         struct alc_spec *spec = codec->spec;
13578         hda_nid_t pin;
13579         int i;
13580
13581         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13582                 pin = spec->autocfg.hp_pins[i];
13583                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13584         }
13585         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13586                 pin = spec->autocfg.speaker_pins[i];
13587                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13588         }
13589         if (spec->autocfg.mono_out_pin)
13590                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13591                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13592 }
13593
13594 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13595 {
13596         struct alc_spec *spec = codec->spec;
13597         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13598         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13599         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13600         unsigned int    dac_vol1, dac_vol2;
13601
13602         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13603                 snd_hda_codec_write(codec, speaker_nid, 0,
13604                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13605                 /* mute mixer inputs from 0x1d */
13606                 snd_hda_codec_write(codec, 0x0f, 0,
13607                                     AC_VERB_SET_AMP_GAIN_MUTE,
13608                                     AMP_IN_UNMUTE(1));
13609                 snd_hda_codec_write(codec, 0x10, 0,
13610                                     AC_VERB_SET_AMP_GAIN_MUTE,
13611                                     AMP_IN_UNMUTE(1));
13612         } else {
13613                 /* unmute mixer inputs from 0x1d */
13614                 snd_hda_codec_write(codec, 0x0f, 0,
13615                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13616                 snd_hda_codec_write(codec, 0x10, 0,
13617                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13618         }
13619
13620         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13621         if (line_nid == 0x14)
13622                 dac_vol2 = AMP_OUT_ZERO;
13623         else if (line_nid == 0x15)
13624                 dac_vol1 = AMP_OUT_ZERO;
13625         if (hp_nid == 0x14)
13626                 dac_vol2 = AMP_OUT_ZERO;
13627         else if (hp_nid == 0x15)
13628                 dac_vol1 = AMP_OUT_ZERO;
13629         if (line_nid != 0x16 || hp_nid != 0x16 ||
13630             spec->autocfg.line_out_pins[1] != 0x16 ||
13631             spec->autocfg.line_out_pins[2] != 0x16)
13632                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13633
13634         snd_hda_codec_write(codec, 0x02, 0,
13635                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13636         snd_hda_codec_write(codec, 0x03, 0,
13637                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13638 }
13639
13640 /* pcm configuration: identical with ALC880 */
13641 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13642 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13643 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13644 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13645
13646 /*
13647  * BIOS auto configuration
13648  */
13649 static int alc268_parse_auto_config(struct hda_codec *codec)
13650 {
13651         struct alc_spec *spec = codec->spec;
13652         int err;
13653         static hda_nid_t alc268_ignore[] = { 0 };
13654
13655         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13656                                            alc268_ignore);
13657         if (err < 0)
13658                 return err;
13659         if (!spec->autocfg.line_outs) {
13660                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13661                         spec->multiout.max_channels = 2;
13662                         spec->no_analog = 1;
13663                         goto dig_only;
13664                 }
13665                 return 0; /* can't find valid BIOS pin config */
13666         }
13667         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13668         if (err < 0)
13669                 return err;
13670         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13671         if (err < 0)
13672                 return err;
13673
13674         spec->multiout.max_channels = 2;
13675
13676  dig_only:
13677         /* digital only support output */
13678         alc_auto_parse_digital(codec);
13679         if (spec->kctls.list)
13680                 add_mixer(spec, spec->kctls.list);
13681
13682         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13683                 add_mixer(spec, alc268_beep_mixer);
13684
13685         add_verb(spec, alc268_volume_init_verbs);
13686         spec->num_mux_defs = 2;
13687         spec->input_mux = &spec->private_imux[0];
13688
13689         err = alc_auto_add_mic_boost(codec);
13690         if (err < 0)
13691                 return err;
13692
13693         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13694
13695         return 1;
13696 }
13697
13698 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13699
13700 /* init callback for auto-configuration model -- overriding the default init */
13701 static void alc268_auto_init(struct hda_codec *codec)
13702 {
13703         struct alc_spec *spec = codec->spec;
13704         alc268_auto_init_multi_out(codec);
13705         alc268_auto_init_hp_out(codec);
13706         alc268_auto_init_mono_speaker_out(codec);
13707         alc268_auto_init_analog_input(codec);
13708         alc_auto_init_digital(codec);
13709         if (spec->unsol_event)
13710                 alc_inithook(codec);
13711 }
13712
13713 /*
13714  * configuration and preset
13715  */
13716 static const char *alc268_models[ALC268_MODEL_LAST] = {
13717         [ALC267_QUANTA_IL1]     = "quanta-il1",
13718         [ALC268_3ST]            = "3stack",
13719         [ALC268_TOSHIBA]        = "toshiba",
13720         [ALC268_ACER]           = "acer",
13721         [ALC268_ACER_DMIC]      = "acer-dmic",
13722         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13723         [ALC268_DELL]           = "dell",
13724         [ALC268_ZEPTO]          = "zepto",
13725 #ifdef CONFIG_SND_DEBUG
13726         [ALC268_TEST]           = "test",
13727 #endif
13728         [ALC268_AUTO]           = "auto",
13729 };
13730
13731 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13732         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13733         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13734         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13735         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13736         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13737         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13738                                                 ALC268_ACER_ASPIRE_ONE),
13739         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13740         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13741                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13742         /* almost compatible with toshiba but with optional digital outs;
13743          * auto-probing seems working fine
13744          */
13745         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13746                            ALC268_AUTO),
13747         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13748         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13749         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13750         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13751         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13752         {}
13753 };
13754
13755 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13756 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13757         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13758         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13759         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13760                            ALC268_TOSHIBA),
13761         {}
13762 };
13763
13764 static struct alc_config_preset alc268_presets[] = {
13765         [ALC267_QUANTA_IL1] = {
13766                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13767                             alc268_capture_nosrc_mixer },
13768                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13769                                 alc267_quanta_il1_verbs },
13770                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13771                 .dac_nids = alc268_dac_nids,
13772                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13773                 .adc_nids = alc268_adc_nids_alt,
13774                 .hp_nid = 0x03,
13775                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13776                 .channel_mode = alc268_modes,
13777                 .unsol_event = alc_sku_unsol_event,
13778                 .setup = alc267_quanta_il1_setup,
13779                 .init_hook = alc_inithook,
13780         },
13781         [ALC268_3ST] = {
13782                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13783                             alc268_beep_mixer },
13784                 .init_verbs = { alc268_base_init_verbs },
13785                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13786                 .dac_nids = alc268_dac_nids,
13787                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13788                 .adc_nids = alc268_adc_nids_alt,
13789                 .capsrc_nids = alc268_capsrc_nids,
13790                 .hp_nid = 0x03,
13791                 .dig_out_nid = ALC268_DIGOUT_NID,
13792                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13793                 .channel_mode = alc268_modes,
13794                 .input_mux = &alc268_capture_source,
13795         },
13796         [ALC268_TOSHIBA] = {
13797                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13798                             alc268_beep_mixer },
13799                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13800                                 alc268_toshiba_verbs },
13801                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13802                 .dac_nids = alc268_dac_nids,
13803                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13804                 .adc_nids = alc268_adc_nids_alt,
13805                 .capsrc_nids = alc268_capsrc_nids,
13806                 .hp_nid = 0x03,
13807                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13808                 .channel_mode = alc268_modes,
13809                 .input_mux = &alc268_capture_source,
13810                 .unsol_event = alc268_toshiba_unsol_event,
13811                 .setup = alc268_toshiba_setup,
13812                 .init_hook = alc268_toshiba_automute,
13813         },
13814         [ALC268_ACER] = {
13815                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13816                             alc268_beep_mixer },
13817                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13818                                 alc268_acer_verbs },
13819                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13820                 .dac_nids = alc268_dac_nids,
13821                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13822                 .adc_nids = alc268_adc_nids_alt,
13823                 .capsrc_nids = alc268_capsrc_nids,
13824                 .hp_nid = 0x02,
13825                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13826                 .channel_mode = alc268_modes,
13827                 .input_mux = &alc268_acer_capture_source,
13828                 .unsol_event = alc268_acer_unsol_event,
13829                 .init_hook = alc268_acer_init_hook,
13830         },
13831         [ALC268_ACER_DMIC] = {
13832                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13833                             alc268_beep_mixer },
13834                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13835                                 alc268_acer_verbs },
13836                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13837                 .dac_nids = alc268_dac_nids,
13838                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13839                 .adc_nids = alc268_adc_nids_alt,
13840                 .capsrc_nids = alc268_capsrc_nids,
13841                 .hp_nid = 0x02,
13842                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13843                 .channel_mode = alc268_modes,
13844                 .input_mux = &alc268_acer_dmic_capture_source,
13845                 .unsol_event = alc268_acer_unsol_event,
13846                 .init_hook = alc268_acer_init_hook,
13847         },
13848         [ALC268_ACER_ASPIRE_ONE] = {
13849                 .mixers = { alc268_acer_aspire_one_mixer,
13850                             alc268_beep_mixer,
13851                             alc268_capture_nosrc_mixer },
13852                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13853                                 alc268_acer_aspire_one_verbs },
13854                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13855                 .dac_nids = alc268_dac_nids,
13856                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13857                 .adc_nids = alc268_adc_nids_alt,
13858                 .capsrc_nids = alc268_capsrc_nids,
13859                 .hp_nid = 0x03,
13860                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13861                 .channel_mode = alc268_modes,
13862                 .unsol_event = alc268_acer_lc_unsol_event,
13863                 .setup = alc268_acer_lc_setup,
13864                 .init_hook = alc268_acer_lc_init_hook,
13865         },
13866         [ALC268_DELL] = {
13867                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13868                             alc268_capture_nosrc_mixer },
13869                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13870                                 alc268_dell_verbs },
13871                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13872                 .dac_nids = alc268_dac_nids,
13873                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13874                 .adc_nids = alc268_adc_nids_alt,
13875                 .capsrc_nids = alc268_capsrc_nids,
13876                 .hp_nid = 0x02,
13877                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13878                 .channel_mode = alc268_modes,
13879                 .unsol_event = alc_sku_unsol_event,
13880                 .setup = alc268_dell_setup,
13881                 .init_hook = alc_inithook,
13882         },
13883         [ALC268_ZEPTO] = {
13884                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13885                             alc268_beep_mixer },
13886                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13887                                 alc268_toshiba_verbs },
13888                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13889                 .dac_nids = alc268_dac_nids,
13890                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13891                 .adc_nids = alc268_adc_nids_alt,
13892                 .capsrc_nids = alc268_capsrc_nids,
13893                 .hp_nid = 0x03,
13894                 .dig_out_nid = ALC268_DIGOUT_NID,
13895                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13896                 .channel_mode = alc268_modes,
13897                 .input_mux = &alc268_capture_source,
13898                 .setup = alc268_toshiba_setup,
13899                 .init_hook = alc268_toshiba_automute,
13900         },
13901 #ifdef CONFIG_SND_DEBUG
13902         [ALC268_TEST] = {
13903                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13904                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13905                                 alc268_volume_init_verbs },
13906                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13907                 .dac_nids = alc268_dac_nids,
13908                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13909                 .adc_nids = alc268_adc_nids_alt,
13910                 .capsrc_nids = alc268_capsrc_nids,
13911                 .hp_nid = 0x03,
13912                 .dig_out_nid = ALC268_DIGOUT_NID,
13913                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13914                 .channel_mode = alc268_modes,
13915                 .input_mux = &alc268_capture_source,
13916         },
13917 #endif
13918 };
13919
13920 static int patch_alc268(struct hda_codec *codec)
13921 {
13922         struct alc_spec *spec;
13923         int board_config;
13924         int i, has_beep, err;
13925
13926         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13927         if (spec == NULL)
13928                 return -ENOMEM;
13929
13930         codec->spec = spec;
13931
13932         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13933                                                   alc268_models,
13934                                                   alc268_cfg_tbl);
13935
13936         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13937                 board_config = snd_hda_check_board_codec_sid_config(codec,
13938                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13939
13940         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13941                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13942                        codec->chip_name);
13943                 board_config = ALC268_AUTO;
13944         }
13945
13946         if (board_config == ALC268_AUTO) {
13947                 /* automatic parse from the BIOS config */
13948                 err = alc268_parse_auto_config(codec);
13949                 if (err < 0) {
13950                         alc_free(codec);
13951                         return err;
13952                 } else if (!err) {
13953                         printk(KERN_INFO
13954                                "hda_codec: Cannot set up configuration "
13955                                "from BIOS.  Using base mode...\n");
13956                         board_config = ALC268_3ST;
13957                 }
13958         }
13959
13960         if (board_config != ALC268_AUTO)
13961                 setup_preset(codec, &alc268_presets[board_config]);
13962
13963         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13964         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13965         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13966
13967         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13968
13969         has_beep = 0;
13970         for (i = 0; i < spec->num_mixers; i++) {
13971                 if (spec->mixers[i] == alc268_beep_mixer) {
13972                         has_beep = 1;
13973                         break;
13974                 }
13975         }
13976
13977         if (has_beep) {
13978                 err = snd_hda_attach_beep_device(codec, 0x1);
13979                 if (err < 0) {
13980                         alc_free(codec);
13981                         return err;
13982                 }
13983                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13984                         /* override the amp caps for beep generator */
13985                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13986                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13987                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13988                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13989                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13990         }
13991
13992         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13993                 /* check whether NID 0x07 is valid */
13994                 unsigned int wcap = get_wcaps(codec, 0x07);
13995                 int i;
13996
13997                 spec->capsrc_nids = alc268_capsrc_nids;
13998                 /* get type */
13999                 wcap = get_wcaps_type(wcap);
14000                 if (spec->auto_mic ||
14001                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14002                         spec->adc_nids = alc268_adc_nids_alt;
14003                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14004                         if (spec->auto_mic)
14005                                 fixup_automic_adc(codec);
14006                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14007                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14008                         else
14009                                 add_mixer(spec, alc268_capture_alt_mixer);
14010                 } else {
14011                         spec->adc_nids = alc268_adc_nids;
14012                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14013                         add_mixer(spec, alc268_capture_mixer);
14014                 }
14015                 /* set default input source */
14016                 for (i = 0; i < spec->num_adc_nids; i++)
14017                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
14018                                 0, AC_VERB_SET_CONNECT_SEL,
14019                                 i < spec->num_mux_defs ?
14020                                 spec->input_mux[i].items[0].index :
14021                                 spec->input_mux->items[0].index);
14022         }
14023
14024         spec->vmaster_nid = 0x02;
14025
14026         codec->patch_ops = alc_patch_ops;
14027         if (board_config == ALC268_AUTO)
14028                 spec->init_hook = alc268_auto_init;
14029
14030         alc_init_jacks(codec);
14031
14032         return 0;
14033 }
14034
14035 /*
14036  *  ALC269 channel source setting (2 channel)
14037  */
14038 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14039
14040 #define alc269_dac_nids         alc260_dac_nids
14041
14042 static hda_nid_t alc269_adc_nids[1] = {
14043         /* ADC1 */
14044         0x08,
14045 };
14046
14047 static hda_nid_t alc269_capsrc_nids[1] = {
14048         0x23,
14049 };
14050
14051 static hda_nid_t alc269vb_adc_nids[1] = {
14052         /* ADC1 */
14053         0x09,
14054 };
14055
14056 static hda_nid_t alc269vb_capsrc_nids[1] = {
14057         0x22,
14058 };
14059
14060 static hda_nid_t alc269_adc_candidates[] = {
14061         0x08, 0x09, 0x07,
14062 };
14063
14064 #define alc269_modes            alc260_modes
14065 #define alc269_capture_source   alc880_lg_lw_capture_source
14066
14067 static struct snd_kcontrol_new alc269_base_mixer[] = {
14068         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14069         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14070         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14071         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14072         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14073         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14074         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14075         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14076         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14077         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14078         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14079         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14080         { } /* end */
14081 };
14082
14083 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14084         /* output mixer control */
14085         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14086         {
14087                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14088                 .name = "Master Playback Switch",
14089                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14090                 .info = snd_hda_mixer_amp_switch_info,
14091                 .get = snd_hda_mixer_amp_switch_get,
14092                 .put = alc268_acer_master_sw_put,
14093                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14094         },
14095         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14096         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14097         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14098         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14099         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14100         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14101         { }
14102 };
14103
14104 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14105         /* output mixer control */
14106         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14107         {
14108                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14109                 .name = "Master Playback Switch",
14110                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14111                 .info = snd_hda_mixer_amp_switch_info,
14112                 .get = snd_hda_mixer_amp_switch_get,
14113                 .put = alc268_acer_master_sw_put,
14114                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14115         },
14116         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14117         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14118         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14119         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14120         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14121         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14122         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14123         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14124         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
14125         { }
14126 };
14127
14128 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14129         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14130         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14131         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14132         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14133         { } /* end */
14134 };
14135
14136 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14137         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14138         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14139         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14140         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14141         { } /* end */
14142 };
14143
14144 static struct snd_kcontrol_new alc269_asus_mixer[] = {
14145         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14146         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14147         { } /* end */
14148 };
14149
14150 /* capture mixer elements */
14151 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14152         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14153         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14154         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14155         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14156         { } /* end */
14157 };
14158
14159 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14160         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14161         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14162         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14163         { } /* end */
14164 };
14165
14166 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14167         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14168         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14169         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14170         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14171         { } /* end */
14172 };
14173
14174 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14175         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14176         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14177         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14178         { } /* end */
14179 };
14180
14181 /* FSC amilo */
14182 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14183
14184 static struct hda_verb alc269_quanta_fl1_verbs[] = {
14185         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14186         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14187         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14188         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14189         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14190         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14191         { }
14192 };
14193
14194 static struct hda_verb alc269_lifebook_verbs[] = {
14195         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14196         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14197         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14198         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14199         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14200         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14201         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14202         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14203         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14204         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14205         { }
14206 };
14207
14208 /* toggle speaker-output according to the hp-jack state */
14209 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14210 {
14211         unsigned int present;
14212         unsigned char bits;
14213
14214         present = snd_hda_jack_detect(codec, 0x15);
14215         bits = present ? HDA_AMP_MUTE : 0;
14216         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14217                                  HDA_AMP_MUTE, bits);
14218         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14219                                  HDA_AMP_MUTE, bits);
14220
14221         snd_hda_codec_write(codec, 0x20, 0,
14222                         AC_VERB_SET_COEF_INDEX, 0x0c);
14223         snd_hda_codec_write(codec, 0x20, 0,
14224                         AC_VERB_SET_PROC_COEF, 0x680);
14225
14226         snd_hda_codec_write(codec, 0x20, 0,
14227                         AC_VERB_SET_COEF_INDEX, 0x0c);
14228         snd_hda_codec_write(codec, 0x20, 0,
14229                         AC_VERB_SET_PROC_COEF, 0x480);
14230 }
14231
14232 /* toggle speaker-output according to the hp-jacks state */
14233 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14234 {
14235         unsigned int present;
14236         unsigned char bits;
14237
14238         /* Check laptop headphone socket */
14239         present = snd_hda_jack_detect(codec, 0x15);
14240
14241         /* Check port replicator headphone socket */
14242         present |= snd_hda_jack_detect(codec, 0x1a);
14243
14244         bits = present ? HDA_AMP_MUTE : 0;
14245         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14246                                  HDA_AMP_MUTE, bits);
14247         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14248                                  HDA_AMP_MUTE, bits);
14249
14250         snd_hda_codec_write(codec, 0x20, 0,
14251                         AC_VERB_SET_COEF_INDEX, 0x0c);
14252         snd_hda_codec_write(codec, 0x20, 0,
14253                         AC_VERB_SET_PROC_COEF, 0x680);
14254
14255         snd_hda_codec_write(codec, 0x20, 0,
14256                         AC_VERB_SET_COEF_INDEX, 0x0c);
14257         snd_hda_codec_write(codec, 0x20, 0,
14258                         AC_VERB_SET_PROC_COEF, 0x480);
14259 }
14260
14261 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14262 {
14263         unsigned int present_laptop;
14264         unsigned int present_dock;
14265
14266         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14267         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14268
14269         /* Laptop mic port overrides dock mic port, design decision */
14270         if (present_dock)
14271                 snd_hda_codec_write(codec, 0x23, 0,
14272                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14273         if (present_laptop)
14274                 snd_hda_codec_write(codec, 0x23, 0,
14275                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14276         if (!present_dock && !present_laptop)
14277                 snd_hda_codec_write(codec, 0x23, 0,
14278                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14279 }
14280
14281 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14282                                     unsigned int res)
14283 {
14284         switch (res >> 26) {
14285         case ALC880_HP_EVENT:
14286                 alc269_quanta_fl1_speaker_automute(codec);
14287                 break;
14288         case ALC880_MIC_EVENT:
14289                 alc_mic_automute(codec);
14290                 break;
14291         }
14292 }
14293
14294 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14295                                         unsigned int res)
14296 {
14297         if ((res >> 26) == ALC880_HP_EVENT)
14298                 alc269_lifebook_speaker_automute(codec);
14299         if ((res >> 26) == ALC880_MIC_EVENT)
14300                 alc269_lifebook_mic_autoswitch(codec);
14301 }
14302
14303 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14304 {
14305         struct alc_spec *spec = codec->spec;
14306         spec->autocfg.hp_pins[0] = 0x15;
14307         spec->autocfg.speaker_pins[0] = 0x14;
14308         spec->ext_mic.pin = 0x18;
14309         spec->ext_mic.mux_idx = 0;
14310         spec->int_mic.pin = 0x19;
14311         spec->int_mic.mux_idx = 1;
14312         spec->auto_mic = 1;
14313 }
14314
14315 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14316 {
14317         alc269_quanta_fl1_speaker_automute(codec);
14318         alc_mic_automute(codec);
14319 }
14320
14321 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14322 {
14323         alc269_lifebook_speaker_automute(codec);
14324         alc269_lifebook_mic_autoswitch(codec);
14325 }
14326
14327 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14328         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14329         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14330         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14331         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14332         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14333         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14334         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14335         {}
14336 };
14337
14338 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14339         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14340         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14341         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14342         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14343         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14344         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14345         {}
14346 };
14347
14348 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14349         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14350         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14351         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14352         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14353         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14354         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14355         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14356         {}
14357 };
14358
14359 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14360         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14361         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14362         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14363         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14364         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14365         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14366         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14367         {}
14368 };
14369
14370 static struct hda_verb alc271_acer_dmic_verbs[] = {
14371         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14372         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14373         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14374         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14375         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14376         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14377         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14378         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14379         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14380         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14381         { }
14382 };
14383
14384 /* toggle speaker-output according to the hp-jack state */
14385 static void alc269_speaker_automute(struct hda_codec *codec)
14386 {
14387         struct alc_spec *spec = codec->spec;
14388         unsigned int nid = spec->autocfg.hp_pins[0];
14389         unsigned int present;
14390         unsigned char bits;
14391
14392         present = snd_hda_jack_detect(codec, nid);
14393         bits = present ? HDA_AMP_MUTE : 0;
14394         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14395                                  HDA_AMP_MUTE, bits);
14396         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14397                                  HDA_AMP_MUTE, bits);
14398         alc_report_jack(codec, nid);
14399 }
14400
14401 /* unsolicited event for HP jack sensing */
14402 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14403                                      unsigned int res)
14404 {
14405         switch (res >> 26) {
14406         case ALC880_HP_EVENT:
14407                 alc269_speaker_automute(codec);
14408                 break;
14409         case ALC880_MIC_EVENT:
14410                 alc_mic_automute(codec);
14411                 break;
14412         }
14413 }
14414
14415 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14416 {
14417         struct alc_spec *spec = codec->spec;
14418         spec->autocfg.hp_pins[0] = 0x15;
14419         spec->autocfg.speaker_pins[0] = 0x14;
14420         spec->ext_mic.pin = 0x18;
14421         spec->ext_mic.mux_idx = 0;
14422         spec->int_mic.pin = 0x19;
14423         spec->int_mic.mux_idx = 1;
14424         spec->auto_mic = 1;
14425 }
14426
14427 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14428 {
14429         struct alc_spec *spec = codec->spec;
14430         spec->autocfg.hp_pins[0] = 0x15;
14431         spec->autocfg.speaker_pins[0] = 0x14;
14432         spec->ext_mic.pin = 0x18;
14433         spec->ext_mic.mux_idx = 0;
14434         spec->int_mic.pin = 0x12;
14435         spec->int_mic.mux_idx = 5;
14436         spec->auto_mic = 1;
14437 }
14438
14439 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14440 {
14441         struct alc_spec *spec = codec->spec;
14442         spec->autocfg.hp_pins[0] = 0x21;
14443         spec->autocfg.speaker_pins[0] = 0x14;
14444         spec->ext_mic.pin = 0x18;
14445         spec->ext_mic.mux_idx = 0;
14446         spec->int_mic.pin = 0x19;
14447         spec->int_mic.mux_idx = 1;
14448         spec->auto_mic = 1;
14449 }
14450
14451 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14452 {
14453         struct alc_spec *spec = codec->spec;
14454         spec->autocfg.hp_pins[0] = 0x21;
14455         spec->autocfg.speaker_pins[0] = 0x14;
14456         spec->ext_mic.pin = 0x18;
14457         spec->ext_mic.mux_idx = 0;
14458         spec->int_mic.pin = 0x12;
14459         spec->int_mic.mux_idx = 6;
14460         spec->auto_mic = 1;
14461 }
14462
14463 static void alc269_laptop_inithook(struct hda_codec *codec)
14464 {
14465         alc269_speaker_automute(codec);
14466         alc_mic_automute(codec);
14467 }
14468
14469 /*
14470  * generic initialization of ADC, input mixers and output mixers
14471  */
14472 static struct hda_verb alc269_init_verbs[] = {
14473         /*
14474          * Unmute ADC0 and set the default input to mic-in
14475          */
14476         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14477
14478         /*
14479          * Set up output mixers (0x02 - 0x03)
14480          */
14481         /* set vol=0 to output mixers */
14482         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14483         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14484
14485         /* set up input amps for analog loopback */
14486         /* Amp Indices: DAC = 0, mixer = 1 */
14487         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14488         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14489         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14490         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14491         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14492         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14493
14494         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14495         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14496         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14497         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14498         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14499         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14500         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14501
14502         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14503         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14504
14505         /* FIXME: use Mux-type input source selection */
14506         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14507         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14508         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14509
14510         /* set EAPD */
14511         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14512         { }
14513 };
14514
14515 static struct hda_verb alc269vb_init_verbs[] = {
14516         /*
14517          * Unmute ADC0 and set the default input to mic-in
14518          */
14519         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14520
14521         /*
14522          * Set up output mixers (0x02 - 0x03)
14523          */
14524         /* set vol=0 to output mixers */
14525         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14526         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14527
14528         /* set up input amps for analog loopback */
14529         /* Amp Indices: DAC = 0, mixer = 1 */
14530         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14531         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14532         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14533         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14534         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14535         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14536
14537         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14538         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14539         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14540         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14541         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14542         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14543         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14544
14545         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14546         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14547
14548         /* FIXME: use Mux-type input source selection */
14549         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14550         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14551         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14552
14553         /* set EAPD */
14554         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14555         { }
14556 };
14557
14558 #define alc269_auto_create_multi_out_ctls \
14559         alc268_auto_create_multi_out_ctls
14560 #define alc269_auto_create_input_ctls \
14561         alc268_auto_create_input_ctls
14562
14563 #ifdef CONFIG_SND_HDA_POWER_SAVE
14564 #define alc269_loopbacks        alc880_loopbacks
14565 #endif
14566
14567 /* pcm configuration: identical with ALC880 */
14568 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14569 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14570 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14571 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14572
14573 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14574         .substreams = 1,
14575         .channels_min = 2,
14576         .channels_max = 8,
14577         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14578         /* NID is set in alc_build_pcms */
14579         .ops = {
14580                 .open = alc880_playback_pcm_open,
14581                 .prepare = alc880_playback_pcm_prepare,
14582                 .cleanup = alc880_playback_pcm_cleanup
14583         },
14584 };
14585
14586 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14587         .substreams = 1,
14588         .channels_min = 2,
14589         .channels_max = 2,
14590         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14591         /* NID is set in alc_build_pcms */
14592 };
14593
14594 #ifdef CONFIG_SND_HDA_POWER_SAVE
14595 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14596 {
14597         switch (codec->subsystem_id) {
14598         case 0x103c1586:
14599                 return 1;
14600         }
14601         return 0;
14602 }
14603
14604 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14605 {
14606         /* update mute-LED according to the speaker mute state */
14607         if (nid == 0x01 || nid == 0x14) {
14608                 int pinval;
14609                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14610                     HDA_AMP_MUTE)
14611                         pinval = 0x24;
14612                 else
14613                         pinval = 0x20;
14614                 /* mic2 vref pin is used for mute LED control */
14615                 snd_hda_codec_update_cache(codec, 0x19, 0,
14616                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14617                                            pinval);
14618         }
14619         return alc_check_power_status(codec, nid);
14620 }
14621 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14622
14623 static int alc275_setup_dual_adc(struct hda_codec *codec)
14624 {
14625         struct alc_spec *spec = codec->spec;
14626
14627         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14628                 return 0;
14629         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14630             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14631                 if (spec->ext_mic.pin <= 0x12) {
14632                         spec->private_adc_nids[0] = 0x08;
14633                         spec->private_adc_nids[1] = 0x11;
14634                         spec->private_capsrc_nids[0] = 0x23;
14635                         spec->private_capsrc_nids[1] = 0x22;
14636                 } else {
14637                         spec->private_adc_nids[0] = 0x11;
14638                         spec->private_adc_nids[1] = 0x08;
14639                         spec->private_capsrc_nids[0] = 0x22;
14640                         spec->private_capsrc_nids[1] = 0x23;
14641                 }
14642                 spec->adc_nids = spec->private_adc_nids;
14643                 spec->capsrc_nids = spec->private_capsrc_nids;
14644                 spec->num_adc_nids = 2;
14645                 spec->dual_adc_switch = 1;
14646                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14647                             spec->adc_nids[0], spec->adc_nids[1]);
14648                 return 1;
14649         }
14650         return 0;
14651 }
14652
14653 /* different alc269-variants */
14654 enum {
14655         ALC269_TYPE_NORMAL,
14656         ALC269_TYPE_ALC258,
14657         ALC269_TYPE_ALC259,
14658         ALC269_TYPE_ALC269VB,
14659         ALC269_TYPE_ALC270,
14660         ALC269_TYPE_ALC271X,
14661 };
14662
14663 /*
14664  * BIOS auto configuration
14665  */
14666 static int alc269_parse_auto_config(struct hda_codec *codec)
14667 {
14668         struct alc_spec *spec = codec->spec;
14669         int err;
14670         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14671
14672         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14673                                            alc269_ignore);
14674         if (err < 0)
14675                 return err;
14676
14677         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14678         if (err < 0)
14679                 return err;
14680         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14681                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14682         else
14683                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14684                                                  0x22, 0);
14685         if (err < 0)
14686                 return err;
14687
14688         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14689
14690         alc_auto_parse_digital(codec);
14691
14692         if (spec->kctls.list)
14693                 add_mixer(spec, spec->kctls.list);
14694
14695         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14696                 add_verb(spec, alc269vb_init_verbs);
14697                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14698         } else {
14699                 add_verb(spec, alc269_init_verbs);
14700                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14701         }
14702
14703         spec->num_mux_defs = 1;
14704         spec->input_mux = &spec->private_imux[0];
14705
14706         if (!alc275_setup_dual_adc(codec))
14707                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14708                                      sizeof(alc269_adc_candidates));
14709
14710         /* set default input source */
14711         if (!spec->dual_adc_switch)
14712                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14713                                         spec->input_mux->items[0].index);
14714
14715         err = alc_auto_add_mic_boost(codec);
14716         if (err < 0)
14717                 return err;
14718
14719         if (!spec->cap_mixer && !spec->no_analog)
14720                 set_capture_mixer(codec);
14721
14722         return 1;
14723 }
14724
14725 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14726 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14727 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14728
14729
14730 /* init callback for auto-configuration model -- overriding the default init */
14731 static void alc269_auto_init(struct hda_codec *codec)
14732 {
14733         struct alc_spec *spec = codec->spec;
14734         alc269_auto_init_multi_out(codec);
14735         alc269_auto_init_hp_out(codec);
14736         alc269_auto_init_analog_input(codec);
14737         alc_auto_init_digital(codec);
14738         if (spec->unsol_event)
14739                 alc_inithook(codec);
14740 }
14741
14742 #ifdef SND_HDA_NEEDS_RESUME
14743 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14744 {
14745         int val = alc_read_coef_idx(codec, 0x04);
14746         if (power_up)
14747                 val |= 1 << 11;
14748         else
14749                 val &= ~(1 << 11);
14750         alc_write_coef_idx(codec, 0x04, val);
14751 }
14752
14753 #ifdef CONFIG_SND_HDA_POWER_SAVE
14754 static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14755 {
14756         struct alc_spec *spec = codec->spec;
14757
14758         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14759                 alc269_toggle_power_output(codec, 0);
14760         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14761                 alc269_toggle_power_output(codec, 0);
14762                 msleep(150);
14763         }
14764
14765         alc_shutup(codec);
14766         if (spec && spec->power_hook)
14767                 spec->power_hook(codec);
14768         return 0;
14769 }
14770 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14771
14772 static int alc269_resume(struct hda_codec *codec)
14773 {
14774         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14775                 alc269_toggle_power_output(codec, 0);
14776                 msleep(150);
14777         }
14778
14779         codec->patch_ops.init(codec);
14780
14781         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14782                 alc269_toggle_power_output(codec, 1);
14783                 msleep(200);
14784         }
14785
14786         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14787                 alc269_toggle_power_output(codec, 1);
14788
14789         snd_hda_codec_resume_amp(codec);
14790         snd_hda_codec_resume_cache(codec);
14791         hda_call_check_power_status(codec, 0x01);
14792         return 0;
14793 }
14794 #endif /* SND_HDA_NEEDS_RESUME */
14795
14796 enum {
14797         ALC269_FIXUP_SONY_VAIO,
14798         ALC269_FIXUP_DELL_M101Z,
14799         ALC269_FIXUP_SKU_IGNORE,
14800         ALC269_FIXUP_ASUS_G73JW,
14801 };
14802
14803 static const struct alc_fixup alc269_fixups[] = {
14804         [ALC269_FIXUP_SONY_VAIO] = {
14805                 .verbs = (const struct hda_verb[]) {
14806                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14807                         {}
14808                 }
14809         },
14810         [ALC269_FIXUP_DELL_M101Z] = {
14811                 .verbs = (const struct hda_verb[]) {
14812                         /* Enables internal speaker */
14813                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14814                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14815                         {}
14816                 }
14817         },
14818         [ALC269_FIXUP_SKU_IGNORE] = {
14819                 .sku = ALC_FIXUP_SKU_IGNORE,
14820         },
14821         [ALC269_FIXUP_ASUS_G73JW] = {
14822                 .pins = (const struct alc_pincfg[]) {
14823                         { 0x17, 0x99130111 }, /* subwoofer */
14824                         { }
14825                 }
14826         },
14827 };
14828
14829 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14830         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14831         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14832         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14833         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14834         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14835         {}
14836 };
14837
14838
14839 /*
14840  * configuration and preset
14841  */
14842 static const char *alc269_models[ALC269_MODEL_LAST] = {
14843         [ALC269_BASIC]                  = "basic",
14844         [ALC269_QUANTA_FL1]             = "quanta",
14845         [ALC269_AMIC]                   = "laptop-amic",
14846         [ALC269_DMIC]                   = "laptop-dmic",
14847         [ALC269_FUJITSU]                = "fujitsu",
14848         [ALC269_LIFEBOOK]               = "lifebook",
14849         [ALC269_AUTO]                   = "auto",
14850 };
14851
14852 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14853         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14854         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14855         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14856                       ALC269_AMIC),
14857         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14858         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14859         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14860         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14861         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14862         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14863         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14864         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14865         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14866         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14867         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14868         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14869         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14870         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14871         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14872         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14873         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14874         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14875         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14876         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14877         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14878         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14879         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14880         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14881         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14882         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14883         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14884         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14885         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14886         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14887         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14888         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14889         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14890         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14891         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14892         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14893         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14894                       ALC269_DMIC),
14895         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14896                       ALC269_DMIC),
14897         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14898         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14899         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14900         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14901         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14902         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14903         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14904         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14905         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14906         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14907         {}
14908 };
14909
14910 static struct alc_config_preset alc269_presets[] = {
14911         [ALC269_BASIC] = {
14912                 .mixers = { alc269_base_mixer },
14913                 .init_verbs = { alc269_init_verbs },
14914                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14915                 .dac_nids = alc269_dac_nids,
14916                 .hp_nid = 0x03,
14917                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14918                 .channel_mode = alc269_modes,
14919                 .input_mux = &alc269_capture_source,
14920         },
14921         [ALC269_QUANTA_FL1] = {
14922                 .mixers = { alc269_quanta_fl1_mixer },
14923                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14924                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14925                 .dac_nids = alc269_dac_nids,
14926                 .hp_nid = 0x03,
14927                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14928                 .channel_mode = alc269_modes,
14929                 .input_mux = &alc269_capture_source,
14930                 .unsol_event = alc269_quanta_fl1_unsol_event,
14931                 .setup = alc269_quanta_fl1_setup,
14932                 .init_hook = alc269_quanta_fl1_init_hook,
14933         },
14934         [ALC269_AMIC] = {
14935                 .mixers = { alc269_laptop_mixer },
14936                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14937                 .init_verbs = { alc269_init_verbs,
14938                                 alc269_laptop_amic_init_verbs },
14939                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14940                 .dac_nids = alc269_dac_nids,
14941                 .hp_nid = 0x03,
14942                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14943                 .channel_mode = alc269_modes,
14944                 .unsol_event = alc269_laptop_unsol_event,
14945                 .setup = alc269_laptop_amic_setup,
14946                 .init_hook = alc269_laptop_inithook,
14947         },
14948         [ALC269_DMIC] = {
14949                 .mixers = { alc269_laptop_mixer },
14950                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14951                 .init_verbs = { alc269_init_verbs,
14952                                 alc269_laptop_dmic_init_verbs },
14953                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14954                 .dac_nids = alc269_dac_nids,
14955                 .hp_nid = 0x03,
14956                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14957                 .channel_mode = alc269_modes,
14958                 .unsol_event = alc269_laptop_unsol_event,
14959                 .setup = alc269_laptop_dmic_setup,
14960                 .init_hook = alc269_laptop_inithook,
14961         },
14962         [ALC269VB_AMIC] = {
14963                 .mixers = { alc269vb_laptop_mixer },
14964                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14965                 .init_verbs = { alc269vb_init_verbs,
14966                                 alc269vb_laptop_amic_init_verbs },
14967                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14968                 .dac_nids = alc269_dac_nids,
14969                 .hp_nid = 0x03,
14970                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14971                 .channel_mode = alc269_modes,
14972                 .unsol_event = alc269_laptop_unsol_event,
14973                 .setup = alc269vb_laptop_amic_setup,
14974                 .init_hook = alc269_laptop_inithook,
14975         },
14976         [ALC269VB_DMIC] = {
14977                 .mixers = { alc269vb_laptop_mixer },
14978                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14979                 .init_verbs = { alc269vb_init_verbs,
14980                                 alc269vb_laptop_dmic_init_verbs },
14981                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14982                 .dac_nids = alc269_dac_nids,
14983                 .hp_nid = 0x03,
14984                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14985                 .channel_mode = alc269_modes,
14986                 .unsol_event = alc269_laptop_unsol_event,
14987                 .setup = alc269vb_laptop_dmic_setup,
14988                 .init_hook = alc269_laptop_inithook,
14989         },
14990         [ALC269_FUJITSU] = {
14991                 .mixers = { alc269_fujitsu_mixer },
14992                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14993                 .init_verbs = { alc269_init_verbs,
14994                                 alc269_laptop_dmic_init_verbs },
14995                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14996                 .dac_nids = alc269_dac_nids,
14997                 .hp_nid = 0x03,
14998                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14999                 .channel_mode = alc269_modes,
15000                 .unsol_event = alc269_laptop_unsol_event,
15001                 .setup = alc269_laptop_dmic_setup,
15002                 .init_hook = alc269_laptop_inithook,
15003         },
15004         [ALC269_LIFEBOOK] = {
15005                 .mixers = { alc269_lifebook_mixer },
15006                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15007                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15008                 .dac_nids = alc269_dac_nids,
15009                 .hp_nid = 0x03,
15010                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15011                 .channel_mode = alc269_modes,
15012                 .input_mux = &alc269_capture_source,
15013                 .unsol_event = alc269_lifebook_unsol_event,
15014                 .init_hook = alc269_lifebook_init_hook,
15015         },
15016         [ALC271_ACER] = {
15017                 .mixers = { alc269_asus_mixer },
15018                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15019                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15020                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15021                 .dac_nids = alc269_dac_nids,
15022                 .adc_nids = alc262_dmic_adc_nids,
15023                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15024                 .capsrc_nids = alc262_dmic_capsrc_nids,
15025                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15026                 .channel_mode = alc269_modes,
15027                 .input_mux = &alc269_capture_source,
15028                 .dig_out_nid = ALC880_DIGOUT_NID,
15029                 .unsol_event = alc_sku_unsol_event,
15030                 .setup = alc269vb_laptop_dmic_setup,
15031                 .init_hook = alc_inithook,
15032         },
15033 };
15034
15035 static int alc269_fill_coef(struct hda_codec *codec)
15036 {
15037         int val;
15038
15039         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15040                 alc_write_coef_idx(codec, 0xf, 0x960b);
15041                 alc_write_coef_idx(codec, 0xe, 0x8817);
15042         }
15043
15044         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15045                 alc_write_coef_idx(codec, 0xf, 0x960b);
15046                 alc_write_coef_idx(codec, 0xe, 0x8814);
15047         }
15048
15049         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15050                 val = alc_read_coef_idx(codec, 0x04);
15051                 /* Power up output pin */
15052                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15053         }
15054
15055         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15056                 val = alc_read_coef_idx(codec, 0xd);
15057                 if ((val & 0x0c00) >> 10 != 0x1) {
15058                         /* Capless ramp up clock control */
15059                         alc_write_coef_idx(codec, 0xd, val | 1<<10);
15060                 }
15061                 val = alc_read_coef_idx(codec, 0x17);
15062                 if ((val & 0x01c0) >> 6 != 0x4) {
15063                         /* Class D power on reset */
15064                         alc_write_coef_idx(codec, 0x17, val | 1<<7);
15065                 }
15066         }
15067         return 0;
15068 }
15069
15070 static int patch_alc269(struct hda_codec *codec)
15071 {
15072         struct alc_spec *spec;
15073         int board_config, coef;
15074         int err;
15075
15076         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15077         if (spec == NULL)
15078                 return -ENOMEM;
15079
15080         codec->spec = spec;
15081
15082         alc_auto_parse_customize_define(codec);
15083
15084         coef = alc_read_coef_idx(codec, 0);
15085         if ((coef & 0x00f0) == 0x0010) {
15086                 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15087                     spec->cdefine.platform_type == 1) {
15088                         alc_codec_rename(codec, "ALC271X");
15089                         spec->codec_variant = ALC269_TYPE_ALC271X;
15090                 } else if ((coef & 0xf000) == 0x1000) {
15091                         spec->codec_variant = ALC269_TYPE_ALC270;
15092                 } else if ((coef & 0xf000) == 0x2000) {
15093                         alc_codec_rename(codec, "ALC259");
15094                         spec->codec_variant = ALC269_TYPE_ALC259;
15095                 } else if ((coef & 0xf000) == 0x3000) {
15096                         alc_codec_rename(codec, "ALC258");
15097                         spec->codec_variant = ALC269_TYPE_ALC258;
15098                 } else {
15099                         alc_codec_rename(codec, "ALC269VB");
15100                         spec->codec_variant = ALC269_TYPE_ALC269VB;
15101                 }
15102         } else
15103                 alc_fix_pll_init(codec, 0x20, 0x04, 15);
15104
15105         alc269_fill_coef(codec);
15106
15107         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15108                                                   alc269_models,
15109                                                   alc269_cfg_tbl);
15110
15111         if (board_config < 0) {
15112                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15113                        codec->chip_name);
15114                 board_config = ALC269_AUTO;
15115         }
15116
15117         if (board_config == ALC269_AUTO)
15118                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
15119
15120         if (board_config == ALC269_AUTO) {
15121                 /* automatic parse from the BIOS config */
15122                 err = alc269_parse_auto_config(codec);
15123                 if (err < 0) {
15124                         alc_free(codec);
15125                         return err;
15126                 } else if (!err) {
15127                         printk(KERN_INFO
15128                                "hda_codec: Cannot set up configuration "
15129                                "from BIOS.  Using base mode...\n");
15130                         board_config = ALC269_BASIC;
15131                 }
15132         }
15133
15134         if (has_cdefine_beep(codec)) {
15135                 err = snd_hda_attach_beep_device(codec, 0x1);
15136                 if (err < 0) {
15137                         alc_free(codec);
15138                         return err;
15139                 }
15140         }
15141
15142         if (board_config != ALC269_AUTO)
15143                 setup_preset(codec, &alc269_presets[board_config]);
15144
15145         if (board_config == ALC269_QUANTA_FL1) {
15146                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15147                  * fix the sample rate of analog I/O to 44.1kHz
15148                  */
15149                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15150                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15151         } else if (spec->dual_adc_switch) {
15152                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15153                 /* switch ADC dynamically */
15154                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15155         } else {
15156                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15157                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15158         }
15159         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15160         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15161
15162         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15163                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15164                         spec->adc_nids = alc269_adc_nids;
15165                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15166                         spec->capsrc_nids = alc269_capsrc_nids;
15167                 } else {
15168                         spec->adc_nids = alc269vb_adc_nids;
15169                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15170                         spec->capsrc_nids = alc269vb_capsrc_nids;
15171                 }
15172         }
15173
15174         if (!spec->cap_mixer)
15175                 set_capture_mixer(codec);
15176         if (has_cdefine_beep(codec))
15177                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15178
15179         if (board_config == ALC269_AUTO)
15180                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
15181
15182         spec->vmaster_nid = 0x02;
15183
15184         codec->patch_ops = alc_patch_ops;
15185 #ifdef CONFIG_SND_HDA_POWER_SAVE
15186         codec->patch_ops.suspend = alc269_suspend;
15187 #endif
15188 #ifdef SND_HDA_NEEDS_RESUME
15189         codec->patch_ops.resume = alc269_resume;
15190 #endif
15191         if (board_config == ALC269_AUTO)
15192                 spec->init_hook = alc269_auto_init;
15193
15194         alc_init_jacks(codec);
15195 #ifdef CONFIG_SND_HDA_POWER_SAVE
15196         if (!spec->loopback.amplist)
15197                 spec->loopback.amplist = alc269_loopbacks;
15198         if (alc269_mic2_for_mute_led(codec))
15199                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15200 #endif
15201
15202         return 0;
15203 }
15204
15205 /*
15206  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15207  */
15208
15209 /*
15210  * set the path ways for 2 channel output
15211  * need to set the codec line out and mic 1 pin widgets to inputs
15212  */
15213 static struct hda_verb alc861_threestack_ch2_init[] = {
15214         /* set pin widget 1Ah (line in) for input */
15215         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15216         /* set pin widget 18h (mic1/2) for input, for mic also enable
15217          * the vref
15218          */
15219         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15220
15221         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15222 #if 0
15223         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15224         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15225 #endif
15226         { } /* end */
15227 };
15228 /*
15229  * 6ch mode
15230  * need to set the codec line out and mic 1 pin widgets to outputs
15231  */
15232 static struct hda_verb alc861_threestack_ch6_init[] = {
15233         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15234         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15235         /* set pin widget 18h (mic1) for output (CLFE)*/
15236         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15237
15238         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15239         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15240
15241         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15242 #if 0
15243         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15244         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15245 #endif
15246         { } /* end */
15247 };
15248
15249 static struct hda_channel_mode alc861_threestack_modes[2] = {
15250         { 2, alc861_threestack_ch2_init },
15251         { 6, alc861_threestack_ch6_init },
15252 };
15253 /* Set mic1 as input and unmute the mixer */
15254 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15255         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15256         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15257         { } /* end */
15258 };
15259 /* Set mic1 as output and mute mixer */
15260 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15261         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15262         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15263         { } /* end */
15264 };
15265
15266 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15267         { 2, alc861_uniwill_m31_ch2_init },
15268         { 4, alc861_uniwill_m31_ch4_init },
15269 };
15270
15271 /* Set mic1 and line-in as input and unmute the mixer */
15272 static struct hda_verb alc861_asus_ch2_init[] = {
15273         /* set pin widget 1Ah (line in) for input */
15274         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15275         /* set pin widget 18h (mic1/2) for input, for mic also enable
15276          * the vref
15277          */
15278         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15279
15280         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15281 #if 0
15282         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15283         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15284 #endif
15285         { } /* end */
15286 };
15287 /* Set mic1 nad line-in as output and mute mixer */
15288 static struct hda_verb alc861_asus_ch6_init[] = {
15289         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15290         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15291         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15292         /* set pin widget 18h (mic1) for output (CLFE)*/
15293         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15294         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15295         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15296         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15297
15298         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15299 #if 0
15300         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15301         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15302 #endif
15303         { } /* end */
15304 };
15305
15306 static struct hda_channel_mode alc861_asus_modes[2] = {
15307         { 2, alc861_asus_ch2_init },
15308         { 6, alc861_asus_ch6_init },
15309 };
15310
15311 /* patch-ALC861 */
15312
15313 static struct snd_kcontrol_new alc861_base_mixer[] = {
15314         /* output mixer control */
15315         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15316         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15317         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15318         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15319         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15320
15321         /*Input mixer control */
15322         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15323            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15324         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15325         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15326         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15327         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15328         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15329         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15330         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15331         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15332
15333         { } /* end */
15334 };
15335
15336 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15337         /* output mixer control */
15338         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15339         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15340         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15341         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15342         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15343
15344         /* Input mixer control */
15345         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15346            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15347         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15348         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15349         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15350         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15351         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15352         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15353         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15354         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15355
15356         {
15357                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15358                 .name = "Channel Mode",
15359                 .info = alc_ch_mode_info,
15360                 .get = alc_ch_mode_get,
15361                 .put = alc_ch_mode_put,
15362                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15363         },
15364         { } /* end */
15365 };
15366
15367 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15368         /* output mixer control */
15369         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15370         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15371         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15372
15373         { } /* end */
15374 };
15375
15376 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15377         /* output mixer control */
15378         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15379         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15380         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15381         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15382         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15383
15384         /* Input mixer control */
15385         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15386            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15387         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15388         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15389         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15390         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15391         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15392         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15393         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15394         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15395
15396         {
15397                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15398                 .name = "Channel Mode",
15399                 .info = alc_ch_mode_info,
15400                 .get = alc_ch_mode_get,
15401                 .put = alc_ch_mode_put,
15402                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15403         },
15404         { } /* end */
15405 };
15406
15407 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15408         /* output mixer control */
15409         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15410         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15411         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15412         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15413         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15414
15415         /* Input mixer control */
15416         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15417         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15418         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15419         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15420         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15421         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15422         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15423         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15424         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15425         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15426
15427         {
15428                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15429                 .name = "Channel Mode",
15430                 .info = alc_ch_mode_info,
15431                 .get = alc_ch_mode_get,
15432                 .put = alc_ch_mode_put,
15433                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15434         },
15435         { }
15436 };
15437
15438 /* additional mixer */
15439 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15440         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15441         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15442         { }
15443 };
15444
15445 /*
15446  * generic initialization of ADC, input mixers and output mixers
15447  */
15448 static struct hda_verb alc861_base_init_verbs[] = {
15449         /*
15450          * Unmute ADC0 and set the default input to mic-in
15451          */
15452         /* port-A for surround (rear panel) */
15453         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15454         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15455         /* port-B for mic-in (rear panel) with vref */
15456         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15457         /* port-C for line-in (rear panel) */
15458         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15459         /* port-D for Front */
15460         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15461         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15462         /* port-E for HP out (front panel) */
15463         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15464         /* route front PCM to HP */
15465         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15466         /* port-F for mic-in (front panel) with vref */
15467         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15468         /* port-G for CLFE (rear panel) */
15469         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15470         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15471         /* port-H for side (rear panel) */
15472         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15473         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15474         /* CD-in */
15475         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15476         /* route front mic to ADC1*/
15477         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15478         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15479
15480         /* Unmute DAC0~3 & spdif out*/
15481         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15482         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15483         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15484         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15485         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15486
15487         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15488         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15489         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15490         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15491         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15492
15493         /* Unmute Stereo Mixer 15 */
15494         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15495         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15496         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15497         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15498
15499         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15500         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15501         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15502         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15503         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15504         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15505         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15506         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15507         /* hp used DAC 3 (Front) */
15508         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15509         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15510
15511         { }
15512 };
15513
15514 static struct hda_verb alc861_threestack_init_verbs[] = {
15515         /*
15516          * Unmute ADC0 and set the default input to mic-in
15517          */
15518         /* port-A for surround (rear panel) */
15519         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15520         /* port-B for mic-in (rear panel) with vref */
15521         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15522         /* port-C for line-in (rear panel) */
15523         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15524         /* port-D for Front */
15525         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15526         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15527         /* port-E for HP out (front panel) */
15528         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15529         /* route front PCM to HP */
15530         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15531         /* port-F for mic-in (front panel) with vref */
15532         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15533         /* port-G for CLFE (rear panel) */
15534         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15535         /* port-H for side (rear panel) */
15536         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15537         /* CD-in */
15538         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15539         /* route front mic to ADC1*/
15540         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15541         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15542         /* Unmute DAC0~3 & spdif out*/
15543         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15544         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15545         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15546         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15548
15549         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15550         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15551         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15552         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15553         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15554
15555         /* Unmute Stereo Mixer 15 */
15556         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15557         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15558         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15559         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15560
15561         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15562         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15563         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15564         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15565         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15566         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15567         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15568         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15569         /* hp used DAC 3 (Front) */
15570         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15571         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15572         { }
15573 };
15574
15575 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15576         /*
15577          * Unmute ADC0 and set the default input to mic-in
15578          */
15579         /* port-A for surround (rear panel) */
15580         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15581         /* port-B for mic-in (rear panel) with vref */
15582         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15583         /* port-C for line-in (rear panel) */
15584         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15585         /* port-D for Front */
15586         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15587         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15588         /* port-E for HP out (front panel) */
15589         /* this has to be set to VREF80 */
15590         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15591         /* route front PCM to HP */
15592         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15593         /* port-F for mic-in (front panel) with vref */
15594         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15595         /* port-G for CLFE (rear panel) */
15596         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15597         /* port-H for side (rear panel) */
15598         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15599         /* CD-in */
15600         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15601         /* route front mic to ADC1*/
15602         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15603         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15604         /* Unmute DAC0~3 & spdif out*/
15605         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15606         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15607         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15608         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15609         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15610
15611         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15612         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15613         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15614         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15615         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15616
15617         /* Unmute Stereo Mixer 15 */
15618         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15619         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15620         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15621         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15622
15623         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15624         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15625         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15626         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15627         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15628         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15629         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15630         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15631         /* hp used DAC 3 (Front) */
15632         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15633         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15634         { }
15635 };
15636
15637 static struct hda_verb alc861_asus_init_verbs[] = {
15638         /*
15639          * Unmute ADC0 and set the default input to mic-in
15640          */
15641         /* port-A for surround (rear panel)
15642          * according to codec#0 this is the HP jack
15643          */
15644         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15645         /* route front PCM to HP */
15646         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15647         /* port-B for mic-in (rear panel) with vref */
15648         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15649         /* port-C for line-in (rear panel) */
15650         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15651         /* port-D for Front */
15652         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15653         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15654         /* port-E for HP out (front panel) */
15655         /* this has to be set to VREF80 */
15656         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15657         /* route front PCM to HP */
15658         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15659         /* port-F for mic-in (front panel) with vref */
15660         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15661         /* port-G for CLFE (rear panel) */
15662         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15663         /* port-H for side (rear panel) */
15664         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15665         /* CD-in */
15666         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15667         /* route front mic to ADC1*/
15668         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15669         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15670         /* Unmute DAC0~3 & spdif out*/
15671         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15672         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15673         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15674         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15675         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15676         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15677         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15678         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15679         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15680         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15681
15682         /* Unmute Stereo Mixer 15 */
15683         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15684         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15685         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15686         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15687
15688         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15689         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15690         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15691         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15692         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15693         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15694         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15695         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15696         /* hp used DAC 3 (Front) */
15697         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15698         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15699         { }
15700 };
15701
15702 /* additional init verbs for ASUS laptops */
15703 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15704         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15705         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15706         { }
15707 };
15708
15709 /*
15710  * generic initialization of ADC, input mixers and output mixers
15711  */
15712 static struct hda_verb alc861_auto_init_verbs[] = {
15713         /*
15714          * Unmute ADC0 and set the default input to mic-in
15715          */
15716         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15717         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15718
15719         /* Unmute DAC0~3 & spdif out*/
15720         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15721         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15722         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15723         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15724         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15725
15726         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15727         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15728         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15729         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15730         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15731
15732         /* Unmute Stereo Mixer 15 */
15733         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15734         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15735         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15736         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15737
15738         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15739         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15740         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15741         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15742         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15743         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15744         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15745         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15746
15747         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15748         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15749         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15750         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15751         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15752         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15753         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15754         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15755
15756         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15757
15758         { }
15759 };
15760
15761 static struct hda_verb alc861_toshiba_init_verbs[] = {
15762         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15763
15764         { }
15765 };
15766
15767 /* toggle speaker-output according to the hp-jack state */
15768 static void alc861_toshiba_automute(struct hda_codec *codec)
15769 {
15770         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15771
15772         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15773                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15774         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15775                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15776 }
15777
15778 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15779                                        unsigned int res)
15780 {
15781         if ((res >> 26) == ALC880_HP_EVENT)
15782                 alc861_toshiba_automute(codec);
15783 }
15784
15785 /* pcm configuration: identical with ALC880 */
15786 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15787 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15788 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15789 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15790
15791
15792 #define ALC861_DIGOUT_NID       0x07
15793
15794 static struct hda_channel_mode alc861_8ch_modes[1] = {
15795         { 8, NULL }
15796 };
15797
15798 static hda_nid_t alc861_dac_nids[4] = {
15799         /* front, surround, clfe, side */
15800         0x03, 0x06, 0x05, 0x04
15801 };
15802
15803 static hda_nid_t alc660_dac_nids[3] = {
15804         /* front, clfe, surround */
15805         0x03, 0x05, 0x06
15806 };
15807
15808 static hda_nid_t alc861_adc_nids[1] = {
15809         /* ADC0-2 */
15810         0x08,
15811 };
15812
15813 static struct hda_input_mux alc861_capture_source = {
15814         .num_items = 5,
15815         .items = {
15816                 { "Mic", 0x0 },
15817                 { "Front Mic", 0x3 },
15818                 { "Line", 0x1 },
15819                 { "CD", 0x4 },
15820                 { "Mixer", 0x5 },
15821         },
15822 };
15823
15824 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15825 {
15826         struct alc_spec *spec = codec->spec;
15827         hda_nid_t mix, srcs[5];
15828         int i, j, num;
15829
15830         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15831                 return 0;
15832         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15833         if (num < 0)
15834                 return 0;
15835         for (i = 0; i < num; i++) {
15836                 unsigned int type;
15837                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15838                 if (type != AC_WID_AUD_OUT)
15839                         continue;
15840                 for (j = 0; j < spec->multiout.num_dacs; j++)
15841                         if (spec->multiout.dac_nids[j] == srcs[i])
15842                                 break;
15843                 if (j >= spec->multiout.num_dacs)
15844                         return srcs[i];
15845         }
15846         return 0;
15847 }
15848
15849 /* fill in the dac_nids table from the parsed pin configuration */
15850 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15851                                      const struct auto_pin_cfg *cfg)
15852 {
15853         struct alc_spec *spec = codec->spec;
15854         int i;
15855         hda_nid_t nid, dac;
15856
15857         spec->multiout.dac_nids = spec->private_dac_nids;
15858         for (i = 0; i < cfg->line_outs; i++) {
15859                 nid = cfg->line_out_pins[i];
15860                 dac = alc861_look_for_dac(codec, nid);
15861                 if (!dac)
15862                         continue;
15863                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15864         }
15865         return 0;
15866 }
15867
15868 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15869                                 hda_nid_t nid, unsigned int chs)
15870 {
15871         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
15872                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15873 }
15874
15875 /* add playback controls from the parsed DAC table */
15876 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15877                                              const struct auto_pin_cfg *cfg)
15878 {
15879         struct alc_spec *spec = codec->spec;
15880         static const char *chname[4] = {
15881                 "Front", "Surround", NULL /*CLFE*/, "Side"
15882         };
15883         hda_nid_t nid;
15884         int i, err;
15885
15886         if (cfg->line_outs == 1) {
15887                 const char *pfx = NULL;
15888                 if (!cfg->hp_outs)
15889                         pfx = "Master";
15890                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15891                         pfx = "Speaker";
15892                 if (pfx) {
15893                         nid = spec->multiout.dac_nids[0];
15894                         return alc861_create_out_sw(codec, pfx, nid, 3);
15895                 }
15896         }
15897
15898         for (i = 0; i < cfg->line_outs; i++) {
15899                 nid = spec->multiout.dac_nids[i];
15900                 if (!nid)
15901                         continue;
15902                 if (i == 2) {
15903                         /* Center/LFE */
15904                         err = alc861_create_out_sw(codec, "Center", nid, 1);
15905                         if (err < 0)
15906                                 return err;
15907                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
15908                         if (err < 0)
15909                                 return err;
15910                 } else {
15911                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
15912                         if (err < 0)
15913                                 return err;
15914                 }
15915         }
15916         return 0;
15917 }
15918
15919 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15920 {
15921         struct alc_spec *spec = codec->spec;
15922         int err;
15923         hda_nid_t nid;
15924
15925         if (!pin)
15926                 return 0;
15927
15928         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15929                 nid = alc861_look_for_dac(codec, pin);
15930                 if (nid) {
15931                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15932                         if (err < 0)
15933                                 return err;
15934                         spec->multiout.hp_nid = nid;
15935                 }
15936         }
15937         return 0;
15938 }
15939
15940 /* create playback/capture controls for input pins */
15941 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15942                                                 const struct auto_pin_cfg *cfg)
15943 {
15944         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15945 }
15946
15947 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15948                                               hda_nid_t nid,
15949                                               int pin_type, hda_nid_t dac)
15950 {
15951         hda_nid_t mix, srcs[5];
15952         int i, num;
15953
15954         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15955                             pin_type);
15956         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15957                             AMP_OUT_UNMUTE);
15958         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15959                 return;
15960         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15961         if (num < 0)
15962                 return;
15963         for (i = 0; i < num; i++) {
15964                 unsigned int mute;
15965                 if (srcs[i] == dac || srcs[i] == 0x15)
15966                         mute = AMP_IN_UNMUTE(i);
15967                 else
15968                         mute = AMP_IN_MUTE(i);
15969                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15970                                     mute);
15971         }
15972 }
15973
15974 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15975 {
15976         struct alc_spec *spec = codec->spec;
15977         int i;
15978
15979         for (i = 0; i < spec->autocfg.line_outs; i++) {
15980                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15981                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15982                 if (nid)
15983                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15984                                                           spec->multiout.dac_nids[i]);
15985         }
15986 }
15987
15988 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15989 {
15990         struct alc_spec *spec = codec->spec;
15991
15992         if (spec->autocfg.hp_outs)
15993                 alc861_auto_set_output_and_unmute(codec,
15994                                                   spec->autocfg.hp_pins[0],
15995                                                   PIN_HP,
15996                                                   spec->multiout.hp_nid);
15997         if (spec->autocfg.speaker_outs)
15998                 alc861_auto_set_output_and_unmute(codec,
15999                                                   spec->autocfg.speaker_pins[0],
16000                                                   PIN_OUT,
16001                                                   spec->multiout.dac_nids[0]);
16002 }
16003
16004 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16005 {
16006         struct alc_spec *spec = codec->spec;
16007         struct auto_pin_cfg *cfg = &spec->autocfg;
16008         int i;
16009
16010         for (i = 0; i < cfg->num_inputs; i++) {
16011                 hda_nid_t nid = cfg->inputs[i].pin;
16012                 if (nid >= 0x0c && nid <= 0x11)
16013                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16014         }
16015 }
16016
16017 /* parse the BIOS configuration and set up the alc_spec */
16018 /* return 1 if successful, 0 if the proper config is not found,
16019  * or a negative error code
16020  */
16021 static int alc861_parse_auto_config(struct hda_codec *codec)
16022 {
16023         struct alc_spec *spec = codec->spec;
16024         int err;
16025         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16026
16027         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16028                                            alc861_ignore);
16029         if (err < 0)
16030                 return err;
16031         if (!spec->autocfg.line_outs)
16032                 return 0; /* can't find valid BIOS pin config */
16033
16034         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16035         if (err < 0)
16036                 return err;
16037         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16038         if (err < 0)
16039                 return err;
16040         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16041         if (err < 0)
16042                 return err;
16043         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16044         if (err < 0)
16045                 return err;
16046
16047         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16048
16049         alc_auto_parse_digital(codec);
16050
16051         if (spec->kctls.list)
16052                 add_mixer(spec, spec->kctls.list);
16053
16054         add_verb(spec, alc861_auto_init_verbs);
16055
16056         spec->num_mux_defs = 1;
16057         spec->input_mux = &spec->private_imux[0];
16058
16059         spec->adc_nids = alc861_adc_nids;
16060         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16061         set_capture_mixer(codec);
16062
16063         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16064
16065         return 1;
16066 }
16067
16068 /* additional initialization for auto-configuration model */
16069 static void alc861_auto_init(struct hda_codec *codec)
16070 {
16071         struct alc_spec *spec = codec->spec;
16072         alc861_auto_init_multi_out(codec);
16073         alc861_auto_init_hp_out(codec);
16074         alc861_auto_init_analog_input(codec);
16075         alc_auto_init_digital(codec);
16076         if (spec->unsol_event)
16077                 alc_inithook(codec);
16078 }
16079
16080 #ifdef CONFIG_SND_HDA_POWER_SAVE
16081 static struct hda_amp_list alc861_loopbacks[] = {
16082         { 0x15, HDA_INPUT, 0 },
16083         { 0x15, HDA_INPUT, 1 },
16084         { 0x15, HDA_INPUT, 2 },
16085         { 0x15, HDA_INPUT, 3 },
16086         { } /* end */
16087 };
16088 #endif
16089
16090
16091 /*
16092  * configuration and preset
16093  */
16094 static const char *alc861_models[ALC861_MODEL_LAST] = {
16095         [ALC861_3ST]            = "3stack",
16096         [ALC660_3ST]            = "3stack-660",
16097         [ALC861_3ST_DIG]        = "3stack-dig",
16098         [ALC861_6ST_DIG]        = "6stack-dig",
16099         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16100         [ALC861_TOSHIBA]        = "toshiba",
16101         [ALC861_ASUS]           = "asus",
16102         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16103         [ALC861_AUTO]           = "auto",
16104 };
16105
16106 static struct snd_pci_quirk alc861_cfg_tbl[] = {
16107         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16108         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16109         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16110         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16111         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16112         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16113         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16114         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16115          *        Any other models that need this preset?
16116          */
16117         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16118         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16119         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16120         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16121         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16122         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16123         /* FIXME: the below seems conflict */
16124         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16125         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16126         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16127         {}
16128 };
16129
16130 static struct alc_config_preset alc861_presets[] = {
16131         [ALC861_3ST] = {
16132                 .mixers = { alc861_3ST_mixer },
16133                 .init_verbs = { alc861_threestack_init_verbs },
16134                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16135                 .dac_nids = alc861_dac_nids,
16136                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16137                 .channel_mode = alc861_threestack_modes,
16138                 .need_dac_fix = 1,
16139                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16140                 .adc_nids = alc861_adc_nids,
16141                 .input_mux = &alc861_capture_source,
16142         },
16143         [ALC861_3ST_DIG] = {
16144                 .mixers = { alc861_base_mixer },
16145                 .init_verbs = { alc861_threestack_init_verbs },
16146                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16147                 .dac_nids = alc861_dac_nids,
16148                 .dig_out_nid = ALC861_DIGOUT_NID,
16149                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16150                 .channel_mode = alc861_threestack_modes,
16151                 .need_dac_fix = 1,
16152                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16153                 .adc_nids = alc861_adc_nids,
16154                 .input_mux = &alc861_capture_source,
16155         },
16156         [ALC861_6ST_DIG] = {
16157                 .mixers = { alc861_base_mixer },
16158                 .init_verbs = { alc861_base_init_verbs },
16159                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16160                 .dac_nids = alc861_dac_nids,
16161                 .dig_out_nid = ALC861_DIGOUT_NID,
16162                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16163                 .channel_mode = alc861_8ch_modes,
16164                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16165                 .adc_nids = alc861_adc_nids,
16166                 .input_mux = &alc861_capture_source,
16167         },
16168         [ALC660_3ST] = {
16169                 .mixers = { alc861_3ST_mixer },
16170                 .init_verbs = { alc861_threestack_init_verbs },
16171                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16172                 .dac_nids = alc660_dac_nids,
16173                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16174                 .channel_mode = alc861_threestack_modes,
16175                 .need_dac_fix = 1,
16176                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16177                 .adc_nids = alc861_adc_nids,
16178                 .input_mux = &alc861_capture_source,
16179         },
16180         [ALC861_UNIWILL_M31] = {
16181                 .mixers = { alc861_uniwill_m31_mixer },
16182                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16183                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16184                 .dac_nids = alc861_dac_nids,
16185                 .dig_out_nid = ALC861_DIGOUT_NID,
16186                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16187                 .channel_mode = alc861_uniwill_m31_modes,
16188                 .need_dac_fix = 1,
16189                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16190                 .adc_nids = alc861_adc_nids,
16191                 .input_mux = &alc861_capture_source,
16192         },
16193         [ALC861_TOSHIBA] = {
16194                 .mixers = { alc861_toshiba_mixer },
16195                 .init_verbs = { alc861_base_init_verbs,
16196                                 alc861_toshiba_init_verbs },
16197                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16198                 .dac_nids = alc861_dac_nids,
16199                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16200                 .channel_mode = alc883_3ST_2ch_modes,
16201                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16202                 .adc_nids = alc861_adc_nids,
16203                 .input_mux = &alc861_capture_source,
16204                 .unsol_event = alc861_toshiba_unsol_event,
16205                 .init_hook = alc861_toshiba_automute,
16206         },
16207         [ALC861_ASUS] = {
16208                 .mixers = { alc861_asus_mixer },
16209                 .init_verbs = { alc861_asus_init_verbs },
16210                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16211                 .dac_nids = alc861_dac_nids,
16212                 .dig_out_nid = ALC861_DIGOUT_NID,
16213                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16214                 .channel_mode = alc861_asus_modes,
16215                 .need_dac_fix = 1,
16216                 .hp_nid = 0x06,
16217                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16218                 .adc_nids = alc861_adc_nids,
16219                 .input_mux = &alc861_capture_source,
16220         },
16221         [ALC861_ASUS_LAPTOP] = {
16222                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16223                 .init_verbs = { alc861_asus_init_verbs,
16224                                 alc861_asus_laptop_init_verbs },
16225                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16226                 .dac_nids = alc861_dac_nids,
16227                 .dig_out_nid = ALC861_DIGOUT_NID,
16228                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16229                 .channel_mode = alc883_3ST_2ch_modes,
16230                 .need_dac_fix = 1,
16231                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16232                 .adc_nids = alc861_adc_nids,
16233                 .input_mux = &alc861_capture_source,
16234         },
16235 };
16236
16237 /* Pin config fixes */
16238 enum {
16239         PINFIX_FSC_AMILO_PI1505,
16240 };
16241
16242 static const struct alc_fixup alc861_fixups[] = {
16243         [PINFIX_FSC_AMILO_PI1505] = {
16244                 .pins = (const struct alc_pincfg[]) {
16245                         { 0x0b, 0x0221101f }, /* HP */
16246                         { 0x0f, 0x90170310 }, /* speaker */
16247                         { }
16248                 }
16249         },
16250 };
16251
16252 static struct snd_pci_quirk alc861_fixup_tbl[] = {
16253         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16254         {}
16255 };
16256
16257 static int patch_alc861(struct hda_codec *codec)
16258 {
16259         struct alc_spec *spec;
16260         int board_config;
16261         int err;
16262
16263         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16264         if (spec == NULL)
16265                 return -ENOMEM;
16266
16267         codec->spec = spec;
16268
16269         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16270                                                   alc861_models,
16271                                                   alc861_cfg_tbl);
16272
16273         if (board_config < 0) {
16274                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16275                        codec->chip_name);
16276                 board_config = ALC861_AUTO;
16277         }
16278
16279         if (board_config == ALC861_AUTO)
16280                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
16281
16282         if (board_config == ALC861_AUTO) {
16283                 /* automatic parse from the BIOS config */
16284                 err = alc861_parse_auto_config(codec);
16285                 if (err < 0) {
16286                         alc_free(codec);
16287                         return err;
16288                 } else if (!err) {
16289                         printk(KERN_INFO
16290                                "hda_codec: Cannot set up configuration "
16291                                "from BIOS.  Using base mode...\n");
16292                    board_config = ALC861_3ST_DIG;
16293                 }
16294         }
16295
16296         err = snd_hda_attach_beep_device(codec, 0x23);
16297         if (err < 0) {
16298                 alc_free(codec);
16299                 return err;
16300         }
16301
16302         if (board_config != ALC861_AUTO)
16303                 setup_preset(codec, &alc861_presets[board_config]);
16304
16305         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16306         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16307
16308         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16309         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16310
16311         if (!spec->cap_mixer)
16312                 set_capture_mixer(codec);
16313         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16314
16315         spec->vmaster_nid = 0x03;
16316
16317         if (board_config == ALC861_AUTO)
16318                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
16319
16320         codec->patch_ops = alc_patch_ops;
16321         if (board_config == ALC861_AUTO) {
16322                 spec->init_hook = alc861_auto_init;
16323 #ifdef CONFIG_SND_HDA_POWER_SAVE
16324                 spec->power_hook = alc_power_eapd;
16325 #endif
16326         }
16327 #ifdef CONFIG_SND_HDA_POWER_SAVE
16328         if (!spec->loopback.amplist)
16329                 spec->loopback.amplist = alc861_loopbacks;
16330 #endif
16331
16332         return 0;
16333 }
16334
16335 /*
16336  * ALC861-VD support
16337  *
16338  * Based on ALC882
16339  *
16340  * In addition, an independent DAC
16341  */
16342 #define ALC861VD_DIGOUT_NID     0x06
16343
16344 static hda_nid_t alc861vd_dac_nids[4] = {
16345         /* front, surr, clfe, side surr */
16346         0x02, 0x03, 0x04, 0x05
16347 };
16348
16349 /* dac_nids for ALC660vd are in a different order - according to
16350  * Realtek's driver.
16351  * This should probably result in a different mixer for 6stack models
16352  * of ALC660vd codecs, but for now there is only 3stack mixer
16353  * - and it is the same as in 861vd.
16354  * adc_nids in ALC660vd are (is) the same as in 861vd
16355  */
16356 static hda_nid_t alc660vd_dac_nids[3] = {
16357         /* front, rear, clfe, rear_surr */
16358         0x02, 0x04, 0x03
16359 };
16360
16361 static hda_nid_t alc861vd_adc_nids[1] = {
16362         /* ADC0 */
16363         0x09,
16364 };
16365
16366 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16367
16368 /* input MUX */
16369 /* FIXME: should be a matrix-type input source selection */
16370 static struct hda_input_mux alc861vd_capture_source = {
16371         .num_items = 4,
16372         .items = {
16373                 { "Mic", 0x0 },
16374                 { "Front Mic", 0x1 },
16375                 { "Line", 0x2 },
16376                 { "CD", 0x4 },
16377         },
16378 };
16379
16380 static struct hda_input_mux alc861vd_dallas_capture_source = {
16381         .num_items = 2,
16382         .items = {
16383                 { "Ext Mic", 0x0 },
16384                 { "Int Mic", 0x1 },
16385         },
16386 };
16387
16388 static struct hda_input_mux alc861vd_hp_capture_source = {
16389         .num_items = 2,
16390         .items = {
16391                 { "Front Mic", 0x0 },
16392                 { "ATAPI Mic", 0x1 },
16393         },
16394 };
16395
16396 /*
16397  * 2ch mode
16398  */
16399 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16400         { 2, NULL }
16401 };
16402
16403 /*
16404  * 6ch mode
16405  */
16406 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16407         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16408         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16409         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16410         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16411         { } /* end */
16412 };
16413
16414 /*
16415  * 8ch mode
16416  */
16417 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16418         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16419         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16420         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16421         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16422         { } /* end */
16423 };
16424
16425 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16426         { 6, alc861vd_6stack_ch6_init },
16427         { 8, alc861vd_6stack_ch8_init },
16428 };
16429
16430 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16431         {
16432                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16433                 .name = "Channel Mode",
16434                 .info = alc_ch_mode_info,
16435                 .get = alc_ch_mode_get,
16436                 .put = alc_ch_mode_put,
16437         },
16438         { } /* end */
16439 };
16440
16441 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16442  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16443  */
16444 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16445         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16446         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16447
16448         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16449         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16450
16451         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16452                                 HDA_OUTPUT),
16453         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16454                                 HDA_OUTPUT),
16455         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16456         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16457
16458         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16459         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16460
16461         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16462
16463         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16464         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16465         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16466
16467         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16468         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16469         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16470
16471         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16472         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16473
16474         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16475         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16476
16477         { } /* end */
16478 };
16479
16480 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16481         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16482         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16483
16484         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16485
16486         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16487         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16488         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16489
16490         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16491         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16492         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16493
16494         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16495         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16496
16497         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16498         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16499
16500         { } /* end */
16501 };
16502
16503 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16504         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16505         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16506         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16507
16508         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16509
16510         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16511         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16512         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16513
16514         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16515         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16516         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16517
16518         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16519         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16520
16521         { } /* end */
16522 };
16523
16524 /* Pin assignment: Speaker=0x14, HP = 0x15,
16525  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16526  */
16527 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16528         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16529         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16530         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16531         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16532         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16533         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16534         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16535         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16536         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16537         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16538         { } /* end */
16539 };
16540
16541 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16542  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16543  */
16544 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16545         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16546         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16547         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16548         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16549         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16550         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16551         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16552         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16553
16554         { } /* end */
16555 };
16556
16557 /*
16558  * generic initialization of ADC, input mixers and output mixers
16559  */
16560 static struct hda_verb alc861vd_volume_init_verbs[] = {
16561         /*
16562          * Unmute ADC0 and set the default input to mic-in
16563          */
16564         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16565         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16566
16567         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16568          * the analog-loopback mixer widget
16569          */
16570         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16572         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16573         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16574         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16575         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16576
16577         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16578         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16579         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16580         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16581         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16582
16583         /*
16584          * Set up output mixers (0x02 - 0x05)
16585          */
16586         /* set vol=0 to output mixers */
16587         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16588         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16589         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16590         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16591
16592         /* set up input amps for analog loopback */
16593         /* Amp Indices: DAC = 0, mixer = 1 */
16594         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16595         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16596         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16597         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16598         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16599         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16600         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16601         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16602
16603         { }
16604 };
16605
16606 /*
16607  * 3-stack pin configuration:
16608  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16609  */
16610 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16611         /*
16612          * Set pin mode and muting
16613          */
16614         /* set front pin widgets 0x14 for output */
16615         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16616         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16617         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16618
16619         /* Mic (rear) pin: input vref at 80% */
16620         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16621         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16622         /* Front Mic pin: input vref at 80% */
16623         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16624         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16625         /* Line In pin: input */
16626         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16627         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16628         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16629         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16630         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16631         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16632         /* CD pin widget for input */
16633         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16634
16635         { }
16636 };
16637
16638 /*
16639  * 6-stack pin configuration:
16640  */
16641 static struct hda_verb alc861vd_6stack_init_verbs[] = {
16642         /*
16643          * Set pin mode and muting
16644          */
16645         /* set front pin widgets 0x14 for output */
16646         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16647         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16648         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16649
16650         /* Rear Pin: output 1 (0x0d) */
16651         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16652         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16653         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16654         /* CLFE Pin: output 2 (0x0e) */
16655         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16656         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16657         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16658         /* Side Pin: output 3 (0x0f) */
16659         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16660         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16661         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16662
16663         /* Mic (rear) pin: input vref at 80% */
16664         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16665         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16666         /* Front Mic pin: input vref at 80% */
16667         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16668         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16669         /* Line In pin: input */
16670         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16671         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16672         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16673         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16674         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16675         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16676         /* CD pin widget for input */
16677         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16678
16679         { }
16680 };
16681
16682 static struct hda_verb alc861vd_eapd_verbs[] = {
16683         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16684         { }
16685 };
16686
16687 static struct hda_verb alc660vd_eapd_verbs[] = {
16688         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16689         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16690         { }
16691 };
16692
16693 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16694         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16695         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16696         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16697         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16698         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16699         {}
16700 };
16701
16702 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16703 {
16704         struct alc_spec *spec = codec->spec;
16705         spec->autocfg.hp_pins[0] = 0x1b;
16706         spec->autocfg.speaker_pins[0] = 0x14;
16707 }
16708
16709 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16710 {
16711         alc_automute_amp(codec);
16712         alc88x_simple_mic_automute(codec);
16713 }
16714
16715 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16716                                         unsigned int res)
16717 {
16718         switch (res >> 26) {
16719         case ALC880_MIC_EVENT:
16720                 alc88x_simple_mic_automute(codec);
16721                 break;
16722         default:
16723                 alc_automute_amp_unsol_event(codec, res);
16724                 break;
16725         }
16726 }
16727
16728 static struct hda_verb alc861vd_dallas_verbs[] = {
16729         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16730         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16731         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16732         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16733
16734         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16735         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16736         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16737         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16738         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16739         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16740         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16741         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16742
16743         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16744         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16745         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16746         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16747         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16748         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16749         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16750         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16751
16752         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16753         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16754         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16755         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16756         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16757         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16758         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16759         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16760
16761         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16762         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16763         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16764         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16765
16766         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16767         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16768         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16769
16770         { } /* end */
16771 };
16772
16773 /* toggle speaker-output according to the hp-jack state */
16774 static void alc861vd_dallas_setup(struct hda_codec *codec)
16775 {
16776         struct alc_spec *spec = codec->spec;
16777
16778         spec->autocfg.hp_pins[0] = 0x15;
16779         spec->autocfg.speaker_pins[0] = 0x14;
16780 }
16781
16782 #ifdef CONFIG_SND_HDA_POWER_SAVE
16783 #define alc861vd_loopbacks      alc880_loopbacks
16784 #endif
16785
16786 /* pcm configuration: identical with ALC880 */
16787 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16788 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16789 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16790 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16791
16792 /*
16793  * configuration and preset
16794  */
16795 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16796         [ALC660VD_3ST]          = "3stack-660",
16797         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16798         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16799         [ALC861VD_3ST]          = "3stack",
16800         [ALC861VD_3ST_DIG]      = "3stack-digout",
16801         [ALC861VD_6ST_DIG]      = "6stack-digout",
16802         [ALC861VD_LENOVO]       = "lenovo",
16803         [ALC861VD_DALLAS]       = "dallas",
16804         [ALC861VD_HP]           = "hp",
16805         [ALC861VD_AUTO]         = "auto",
16806 };
16807
16808 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16809         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16810         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16811         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16812         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16813         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16814         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16815         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16816         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16817         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16818         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16819         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16820         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16821         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16822         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16823         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16824         {}
16825 };
16826
16827 static struct alc_config_preset alc861vd_presets[] = {
16828         [ALC660VD_3ST] = {
16829                 .mixers = { alc861vd_3st_mixer },
16830                 .init_verbs = { alc861vd_volume_init_verbs,
16831                                  alc861vd_3stack_init_verbs },
16832                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16833                 .dac_nids = alc660vd_dac_nids,
16834                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16835                 .channel_mode = alc861vd_3stack_2ch_modes,
16836                 .input_mux = &alc861vd_capture_source,
16837         },
16838         [ALC660VD_3ST_DIG] = {
16839                 .mixers = { alc861vd_3st_mixer },
16840                 .init_verbs = { alc861vd_volume_init_verbs,
16841                                  alc861vd_3stack_init_verbs },
16842                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16843                 .dac_nids = alc660vd_dac_nids,
16844                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16845                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16846                 .channel_mode = alc861vd_3stack_2ch_modes,
16847                 .input_mux = &alc861vd_capture_source,
16848         },
16849         [ALC861VD_3ST] = {
16850                 .mixers = { alc861vd_3st_mixer },
16851                 .init_verbs = { alc861vd_volume_init_verbs,
16852                                  alc861vd_3stack_init_verbs },
16853                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16854                 .dac_nids = alc861vd_dac_nids,
16855                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16856                 .channel_mode = alc861vd_3stack_2ch_modes,
16857                 .input_mux = &alc861vd_capture_source,
16858         },
16859         [ALC861VD_3ST_DIG] = {
16860                 .mixers = { alc861vd_3st_mixer },
16861                 .init_verbs = { alc861vd_volume_init_verbs,
16862                                  alc861vd_3stack_init_verbs },
16863                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16864                 .dac_nids = alc861vd_dac_nids,
16865                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16866                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16867                 .channel_mode = alc861vd_3stack_2ch_modes,
16868                 .input_mux = &alc861vd_capture_source,
16869         },
16870         [ALC861VD_6ST_DIG] = {
16871                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16872                 .init_verbs = { alc861vd_volume_init_verbs,
16873                                 alc861vd_6stack_init_verbs },
16874                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16875                 .dac_nids = alc861vd_dac_nids,
16876                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16877                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16878                 .channel_mode = alc861vd_6stack_modes,
16879                 .input_mux = &alc861vd_capture_source,
16880         },
16881         [ALC861VD_LENOVO] = {
16882                 .mixers = { alc861vd_lenovo_mixer },
16883                 .init_verbs = { alc861vd_volume_init_verbs,
16884                                 alc861vd_3stack_init_verbs,
16885                                 alc861vd_eapd_verbs,
16886                                 alc861vd_lenovo_unsol_verbs },
16887                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16888                 .dac_nids = alc660vd_dac_nids,
16889                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16890                 .channel_mode = alc861vd_3stack_2ch_modes,
16891                 .input_mux = &alc861vd_capture_source,
16892                 .unsol_event = alc861vd_lenovo_unsol_event,
16893                 .setup = alc861vd_lenovo_setup,
16894                 .init_hook = alc861vd_lenovo_init_hook,
16895         },
16896         [ALC861VD_DALLAS] = {
16897                 .mixers = { alc861vd_dallas_mixer },
16898                 .init_verbs = { alc861vd_dallas_verbs },
16899                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16900                 .dac_nids = alc861vd_dac_nids,
16901                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16902                 .channel_mode = alc861vd_3stack_2ch_modes,
16903                 .input_mux = &alc861vd_dallas_capture_source,
16904                 .unsol_event = alc_automute_amp_unsol_event,
16905                 .setup = alc861vd_dallas_setup,
16906                 .init_hook = alc_automute_amp,
16907         },
16908         [ALC861VD_HP] = {
16909                 .mixers = { alc861vd_hp_mixer },
16910                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16911                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16912                 .dac_nids = alc861vd_dac_nids,
16913                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16914                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16915                 .channel_mode = alc861vd_3stack_2ch_modes,
16916                 .input_mux = &alc861vd_hp_capture_source,
16917                 .unsol_event = alc_automute_amp_unsol_event,
16918                 .setup = alc861vd_dallas_setup,
16919                 .init_hook = alc_automute_amp,
16920         },
16921         [ALC660VD_ASUS_V1S] = {
16922                 .mixers = { alc861vd_lenovo_mixer },
16923                 .init_verbs = { alc861vd_volume_init_verbs,
16924                                 alc861vd_3stack_init_verbs,
16925                                 alc861vd_eapd_verbs,
16926                                 alc861vd_lenovo_unsol_verbs },
16927                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16928                 .dac_nids = alc660vd_dac_nids,
16929                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16930                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16931                 .channel_mode = alc861vd_3stack_2ch_modes,
16932                 .input_mux = &alc861vd_capture_source,
16933                 .unsol_event = alc861vd_lenovo_unsol_event,
16934                 .setup = alc861vd_lenovo_setup,
16935                 .init_hook = alc861vd_lenovo_init_hook,
16936         },
16937 };
16938
16939 /*
16940  * BIOS auto configuration
16941  */
16942 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16943                                                 const struct auto_pin_cfg *cfg)
16944 {
16945         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
16946 }
16947
16948
16949 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16950                                 hda_nid_t nid, int pin_type, int dac_idx)
16951 {
16952         alc_set_pin_output(codec, nid, pin_type);
16953 }
16954
16955 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16956 {
16957         struct alc_spec *spec = codec->spec;
16958         int i;
16959
16960         for (i = 0; i <= HDA_SIDE; i++) {
16961                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16962                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16963                 if (nid)
16964                         alc861vd_auto_set_output_and_unmute(codec, nid,
16965                                                             pin_type, i);
16966         }
16967 }
16968
16969
16970 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16971 {
16972         struct alc_spec *spec = codec->spec;
16973         hda_nid_t pin;
16974
16975         pin = spec->autocfg.hp_pins[0];
16976         if (pin) /* connect to front and use dac 0 */
16977                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16978         pin = spec->autocfg.speaker_pins[0];
16979         if (pin)
16980                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16981 }
16982
16983 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16984
16985 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16986 {
16987         struct alc_spec *spec = codec->spec;
16988         struct auto_pin_cfg *cfg = &spec->autocfg;
16989         int i;
16990
16991         for (i = 0; i < cfg->num_inputs; i++) {
16992                 hda_nid_t nid = cfg->inputs[i].pin;
16993                 if (alc_is_input_pin(codec, nid)) {
16994                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16995                         if (nid != ALC861VD_PIN_CD_NID &&
16996                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16997                                 snd_hda_codec_write(codec, nid, 0,
16998                                                 AC_VERB_SET_AMP_GAIN_MUTE,
16999                                                 AMP_OUT_MUTE);
17000                 }
17001         }
17002 }
17003
17004 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17005
17006 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17007 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17008
17009 /* add playback controls from the parsed DAC table */
17010 /* Based on ALC880 version. But ALC861VD has separate,
17011  * different NIDs for mute/unmute switch and volume control */
17012 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17013                                              const struct auto_pin_cfg *cfg)
17014 {
17015         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
17016         hda_nid_t nid_v, nid_s;
17017         int i, err;
17018
17019         for (i = 0; i < cfg->line_outs; i++) {
17020                 if (!spec->multiout.dac_nids[i])
17021                         continue;
17022                 nid_v = alc861vd_idx_to_mixer_vol(
17023                                 alc880_dac_to_idx(
17024                                         spec->multiout.dac_nids[i]));
17025                 nid_s = alc861vd_idx_to_mixer_switch(
17026                                 alc880_dac_to_idx(
17027                                         spec->multiout.dac_nids[i]));
17028
17029                 if (i == 2) {
17030                         /* Center/LFE */
17031                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17032                                               "Center",
17033                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17034                                                               HDA_OUTPUT));
17035                         if (err < 0)
17036                                 return err;
17037                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17038                                               "LFE",
17039                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17040                                                               HDA_OUTPUT));
17041                         if (err < 0)
17042                                 return err;
17043                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17044                                              "Center",
17045                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17046                                                               HDA_INPUT));
17047                         if (err < 0)
17048                                 return err;
17049                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17050                                              "LFE",
17051                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17052                                                               HDA_INPUT));
17053                         if (err < 0)
17054                                 return err;
17055                 } else {
17056                         const char *pfx;
17057                         if (cfg->line_outs == 1 &&
17058                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17059                                 if (!cfg->hp_pins)
17060                                         pfx = "Speaker";
17061                                 else
17062                                         pfx = "PCM";
17063                         } else
17064                                 pfx = chname[i];
17065                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17066                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17067                                                               HDA_OUTPUT));
17068                         if (err < 0)
17069                                 return err;
17070                         if (cfg->line_outs == 1 &&
17071                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17072                                 pfx = "Speaker";
17073                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17074                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17075                                                               HDA_INPUT));
17076                         if (err < 0)
17077                                 return err;
17078                 }
17079         }
17080         return 0;
17081 }
17082
17083 /* add playback controls for speaker and HP outputs */
17084 /* Based on ALC880 version. But ALC861VD has separate,
17085  * different NIDs for mute/unmute switch and volume control */
17086 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17087                                         hda_nid_t pin, const char *pfx)
17088 {
17089         hda_nid_t nid_v, nid_s;
17090         int err;
17091
17092         if (!pin)
17093                 return 0;
17094
17095         if (alc880_is_fixed_pin(pin)) {
17096                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17097                 /* specify the DAC as the extra output */
17098                 if (!spec->multiout.hp_nid)
17099                         spec->multiout.hp_nid = nid_v;
17100                 else
17101                         spec->multiout.extra_out_nid[0] = nid_v;
17102                 /* control HP volume/switch on the output mixer amp */
17103                 nid_v = alc861vd_idx_to_mixer_vol(
17104                                 alc880_fixed_pin_idx(pin));
17105                 nid_s = alc861vd_idx_to_mixer_switch(
17106                                 alc880_fixed_pin_idx(pin));
17107
17108                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17109                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17110                 if (err < 0)
17111                         return err;
17112                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17113                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17114                 if (err < 0)
17115                         return err;
17116         } else if (alc880_is_multi_pin(pin)) {
17117                 /* set manual connection */
17118                 /* we have only a switch on HP-out PIN */
17119                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17120                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17121                 if (err < 0)
17122                         return err;
17123         }
17124         return 0;
17125 }
17126
17127 /* parse the BIOS configuration and set up the alc_spec
17128  * return 1 if successful, 0 if the proper config is not found,
17129  * or a negative error code
17130  * Based on ALC880 version - had to change it to override
17131  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17132 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17133 {
17134         struct alc_spec *spec = codec->spec;
17135         int err;
17136         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17137
17138         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17139                                            alc861vd_ignore);
17140         if (err < 0)
17141                 return err;
17142         if (!spec->autocfg.line_outs)
17143                 return 0; /* can't find valid BIOS pin config */
17144
17145         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17146         if (err < 0)
17147                 return err;
17148         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17149         if (err < 0)
17150                 return err;
17151         err = alc861vd_auto_create_extra_out(spec,
17152                                              spec->autocfg.speaker_pins[0],
17153                                              "Speaker");
17154         if (err < 0)
17155                 return err;
17156         err = alc861vd_auto_create_extra_out(spec,
17157                                              spec->autocfg.hp_pins[0],
17158                                              "Headphone");
17159         if (err < 0)
17160                 return err;
17161         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17162         if (err < 0)
17163                 return err;
17164
17165         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17166
17167         alc_auto_parse_digital(codec);
17168
17169         if (spec->kctls.list)
17170                 add_mixer(spec, spec->kctls.list);
17171
17172         add_verb(spec, alc861vd_volume_init_verbs);
17173
17174         spec->num_mux_defs = 1;
17175         spec->input_mux = &spec->private_imux[0];
17176
17177         err = alc_auto_add_mic_boost(codec);
17178         if (err < 0)
17179                 return err;
17180
17181         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17182
17183         return 1;
17184 }
17185
17186 /* additional initialization for auto-configuration model */
17187 static void alc861vd_auto_init(struct hda_codec *codec)
17188 {
17189         struct alc_spec *spec = codec->spec;
17190         alc861vd_auto_init_multi_out(codec);
17191         alc861vd_auto_init_hp_out(codec);
17192         alc861vd_auto_init_analog_input(codec);
17193         alc861vd_auto_init_input_src(codec);
17194         alc_auto_init_digital(codec);
17195         if (spec->unsol_event)
17196                 alc_inithook(codec);
17197 }
17198
17199 enum {
17200         ALC660VD_FIX_ASUS_GPIO1
17201 };
17202
17203 /* reset GPIO1 */
17204 static const struct alc_fixup alc861vd_fixups[] = {
17205         [ALC660VD_FIX_ASUS_GPIO1] = {
17206                 .verbs = (const struct hda_verb[]) {
17207                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17208                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17209                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17210                         { }
17211                 }
17212         },
17213 };
17214
17215 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17216         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17217         {}
17218 };
17219
17220 static int patch_alc861vd(struct hda_codec *codec)
17221 {
17222         struct alc_spec *spec;
17223         int err, board_config;
17224
17225         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17226         if (spec == NULL)
17227                 return -ENOMEM;
17228
17229         codec->spec = spec;
17230
17231         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17232                                                   alc861vd_models,
17233                                                   alc861vd_cfg_tbl);
17234
17235         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17236                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17237                        codec->chip_name);
17238                 board_config = ALC861VD_AUTO;
17239         }
17240
17241         if (board_config == ALC861VD_AUTO)
17242                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
17243
17244         if (board_config == ALC861VD_AUTO) {
17245                 /* automatic parse from the BIOS config */
17246                 err = alc861vd_parse_auto_config(codec);
17247                 if (err < 0) {
17248                         alc_free(codec);
17249                         return err;
17250                 } else if (!err) {
17251                         printk(KERN_INFO
17252                                "hda_codec: Cannot set up configuration "
17253                                "from BIOS.  Using base mode...\n");
17254                         board_config = ALC861VD_3ST;
17255                 }
17256         }
17257
17258         err = snd_hda_attach_beep_device(codec, 0x23);
17259         if (err < 0) {
17260                 alc_free(codec);
17261                 return err;
17262         }
17263
17264         if (board_config != ALC861VD_AUTO)
17265                 setup_preset(codec, &alc861vd_presets[board_config]);
17266
17267         if (codec->vendor_id == 0x10ec0660) {
17268                 /* always turn on EAPD */
17269                 add_verb(spec, alc660vd_eapd_verbs);
17270         }
17271
17272         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17273         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17274
17275         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17276         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17277
17278         if (!spec->adc_nids) {
17279                 spec->adc_nids = alc861vd_adc_nids;
17280                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17281         }
17282         if (!spec->capsrc_nids)
17283                 spec->capsrc_nids = alc861vd_capsrc_nids;
17284
17285         set_capture_mixer(codec);
17286         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17287
17288         spec->vmaster_nid = 0x02;
17289
17290         if (board_config == ALC861VD_AUTO)
17291                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
17292
17293         codec->patch_ops = alc_patch_ops;
17294
17295         if (board_config == ALC861VD_AUTO)
17296                 spec->init_hook = alc861vd_auto_init;
17297 #ifdef CONFIG_SND_HDA_POWER_SAVE
17298         if (!spec->loopback.amplist)
17299                 spec->loopback.amplist = alc861vd_loopbacks;
17300 #endif
17301
17302         return 0;
17303 }
17304
17305 /*
17306  * ALC662 support
17307  *
17308  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17309  * configuration.  Each pin widget can choose any input DACs and a mixer.
17310  * Each ADC is connected from a mixer of all inputs.  This makes possible
17311  * 6-channel independent captures.
17312  *
17313  * In addition, an independent DAC for the multi-playback (not used in this
17314  * driver yet).
17315  */
17316 #define ALC662_DIGOUT_NID       0x06
17317 #define ALC662_DIGIN_NID        0x0a
17318
17319 static hda_nid_t alc662_dac_nids[4] = {
17320         /* front, rear, clfe, rear_surr */
17321         0x02, 0x03, 0x04
17322 };
17323
17324 static hda_nid_t alc272_dac_nids[2] = {
17325         0x02, 0x03
17326 };
17327
17328 static hda_nid_t alc662_adc_nids[2] = {
17329         /* ADC1-2 */
17330         0x09, 0x08
17331 };
17332
17333 static hda_nid_t alc272_adc_nids[1] = {
17334         /* ADC1-2 */
17335         0x08,
17336 };
17337
17338 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17339 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17340
17341
17342 /* input MUX */
17343 /* FIXME: should be a matrix-type input source selection */
17344 static struct hda_input_mux alc662_capture_source = {
17345         .num_items = 4,
17346         .items = {
17347                 { "Mic", 0x0 },
17348                 { "Front Mic", 0x1 },
17349                 { "Line", 0x2 },
17350                 { "CD", 0x4 },
17351         },
17352 };
17353
17354 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17355         .num_items = 2,
17356         .items = {
17357                 { "Mic", 0x1 },
17358                 { "Line", 0x2 },
17359         },
17360 };
17361
17362 static struct hda_input_mux alc663_capture_source = {
17363         .num_items = 3,
17364         .items = {
17365                 { "Mic", 0x0 },
17366                 { "Front Mic", 0x1 },
17367                 { "Line", 0x2 },
17368         },
17369 };
17370
17371 #if 0 /* set to 1 for testing other input sources below */
17372 static struct hda_input_mux alc272_nc10_capture_source = {
17373         .num_items = 16,
17374         .items = {
17375                 { "Autoselect Mic", 0x0 },
17376                 { "Internal Mic", 0x1 },
17377                 { "In-0x02", 0x2 },
17378                 { "In-0x03", 0x3 },
17379                 { "In-0x04", 0x4 },
17380                 { "In-0x05", 0x5 },
17381                 { "In-0x06", 0x6 },
17382                 { "In-0x07", 0x7 },
17383                 { "In-0x08", 0x8 },
17384                 { "In-0x09", 0x9 },
17385                 { "In-0x0a", 0x0a },
17386                 { "In-0x0b", 0x0b },
17387                 { "In-0x0c", 0x0c },
17388                 { "In-0x0d", 0x0d },
17389                 { "In-0x0e", 0x0e },
17390                 { "In-0x0f", 0x0f },
17391         },
17392 };
17393 #endif
17394
17395 /*
17396  * 2ch mode
17397  */
17398 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17399         { 2, NULL }
17400 };
17401
17402 /*
17403  * 2ch mode
17404  */
17405 static struct hda_verb alc662_3ST_ch2_init[] = {
17406         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17407         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17408         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17409         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17410         { } /* end */
17411 };
17412
17413 /*
17414  * 6ch mode
17415  */
17416 static struct hda_verb alc662_3ST_ch6_init[] = {
17417         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17418         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17419         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17420         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17421         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17422         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17423         { } /* end */
17424 };
17425
17426 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17427         { 2, alc662_3ST_ch2_init },
17428         { 6, alc662_3ST_ch6_init },
17429 };
17430
17431 /*
17432  * 2ch mode
17433  */
17434 static struct hda_verb alc662_sixstack_ch6_init[] = {
17435         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17436         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17437         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17438         { } /* end */
17439 };
17440
17441 /*
17442  * 6ch mode
17443  */
17444 static struct hda_verb alc662_sixstack_ch8_init[] = {
17445         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17446         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17447         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17448         { } /* end */
17449 };
17450
17451 static struct hda_channel_mode alc662_5stack_modes[2] = {
17452         { 2, alc662_sixstack_ch6_init },
17453         { 6, alc662_sixstack_ch8_init },
17454 };
17455
17456 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17457  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17458  */
17459
17460 static struct snd_kcontrol_new alc662_base_mixer[] = {
17461         /* output mixer control */
17462         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17463         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17464         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17465         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17466         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17467         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17468         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17469         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17470         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17471
17472         /*Input mixer control */
17473         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17474         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17475         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17476         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17477         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17478         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17479         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17480         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17481         { } /* end */
17482 };
17483
17484 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17485         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17486         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17487         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17488         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17489         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17490         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17491         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17492         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17493         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17494         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17495         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17496         { } /* end */
17497 };
17498
17499 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17500         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17501         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17502         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17503         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17504         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17505         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17506         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17507         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17508         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17509         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17510         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17511         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17512         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17513         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17514         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17515         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17516         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17517         { } /* end */
17518 };
17519
17520 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17521         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17522         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17523         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17524         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17525         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17526         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17527         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17528         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17529         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17530         { } /* end */
17531 };
17532
17533 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17534         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17535         ALC262_HIPPO_MASTER_SWITCH,
17536
17537         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
17538         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17539         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17540
17541         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17542         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17543         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17544         { } /* end */
17545 };
17546
17547 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17548         ALC262_HIPPO_MASTER_SWITCH,
17549         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17550         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17551         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17552         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17553         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17554         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17555         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17556         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17557         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17558         { } /* end */
17559 };
17560
17561 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17562         .ops = &snd_hda_bind_vol,
17563         .values = {
17564                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17565                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17566                 0
17567         },
17568 };
17569
17570 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17571         .ops = &snd_hda_bind_sw,
17572         .values = {
17573                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17574                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17575                 0
17576         },
17577 };
17578
17579 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17580         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17581         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17582         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17583         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17584         { } /* end */
17585 };
17586
17587 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17588         .ops = &snd_hda_bind_sw,
17589         .values = {
17590                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17591                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17592                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17593                 0
17594         },
17595 };
17596
17597 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17598         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17599         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17600         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17601         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17602         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17603         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17604
17605         { } /* end */
17606 };
17607
17608 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17609         .ops = &snd_hda_bind_sw,
17610         .values = {
17611                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17612                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17613                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17614                 0
17615         },
17616 };
17617
17618 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17619         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17620         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17621         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17622         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17623         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17624         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17625         { } /* end */
17626 };
17627
17628 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17629         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17630         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17631         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17632         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17633         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17634         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17635         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17636         { } /* end */
17637 };
17638
17639 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17640         .ops = &snd_hda_bind_vol,
17641         .values = {
17642                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17643                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17644                 0
17645         },
17646 };
17647
17648 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17649         .ops = &snd_hda_bind_sw,
17650         .values = {
17651                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17652                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17653                 0
17654         },
17655 };
17656
17657 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17658         HDA_BIND_VOL("Master Playback Volume",
17659                                 &alc663_asus_two_bind_master_vol),
17660         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17661         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17662         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17663         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17664         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17665         { } /* end */
17666 };
17667
17668 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17669         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17670         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17671         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17672         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17673         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17674         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17675         { } /* end */
17676 };
17677
17678 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17679         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17680         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17681         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17682         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17683         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17684
17685         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17686         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17687         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17688         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17689         { } /* end */
17690 };
17691
17692 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17693         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17694         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17695         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17696
17697         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17698         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17699         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17700         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17701         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17702         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17703         { } /* end */
17704 };
17705
17706 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17707         .ops = &snd_hda_bind_sw,
17708         .values = {
17709                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17710                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17711                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17712                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17713                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17714                 0
17715         },
17716 };
17717
17718 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17719         .ops = &snd_hda_bind_sw,
17720         .values = {
17721                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17722                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17723                 0
17724         },
17725 };
17726
17727 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17728         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17729         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17730         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17731         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17732         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17733         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17734         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17735         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17736         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17737         { } /* end */
17738 };
17739
17740 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17741         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17742         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17743         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17744         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17745         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17748         { } /* end */
17749 };
17750
17751
17752 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17753         {
17754                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17755                 .name = "Channel Mode",
17756                 .info = alc_ch_mode_info,
17757                 .get = alc_ch_mode_get,
17758                 .put = alc_ch_mode_put,
17759         },
17760         { } /* end */
17761 };
17762
17763 static struct hda_verb alc662_init_verbs[] = {
17764         /* ADC: mute amp left and right */
17765         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17766         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17767
17768         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17769         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17770         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17771         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17772         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17773         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17774
17775         /* Front Pin: output 0 (0x0c) */
17776         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17777         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17778
17779         /* Rear Pin: output 1 (0x0d) */
17780         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17781         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17782
17783         /* CLFE Pin: output 2 (0x0e) */
17784         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17785         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17786
17787         /* Mic (rear) pin: input vref at 80% */
17788         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17789         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17790         /* Front Mic pin: input vref at 80% */
17791         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17792         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17793         /* Line In pin: input */
17794         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17795         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17796         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17797         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17798         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17799         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17800         /* CD pin widget for input */
17801         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17802
17803         /* FIXME: use matrix-type input source selection */
17804         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17805         /* Input mixer */
17806         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17807         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17808
17809         /* always trun on EAPD */
17810         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17811         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17812
17813         { }
17814 };
17815
17816 static struct hda_verb alc663_init_verbs[] = {
17817         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17818         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17819         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17820         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17821         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17822         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17823         { }
17824 };
17825
17826 static struct hda_verb alc272_init_verbs[] = {
17827         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17828         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17829         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17830         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17831         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17832         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17833         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17834         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17835         { }
17836 };
17837
17838 static struct hda_verb alc662_sue_init_verbs[] = {
17839         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17840         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17841         {}
17842 };
17843
17844 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17845         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17846         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17847         {}
17848 };
17849
17850 /* Set Unsolicited Event*/
17851 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17852         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17853         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17854         {}
17855 };
17856
17857 static struct hda_verb alc663_m51va_init_verbs[] = {
17858         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17859         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17860         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17861         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17862         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17863         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17864         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17865         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17866         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17867         {}
17868 };
17869
17870 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17871         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17872         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17873         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17874         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17875         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17876         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17877         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17878         {}
17879 };
17880
17881 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17882         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17883         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17884         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17885         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17886         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17887         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17888         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17889         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17890         {}
17891 };
17892
17893 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17894         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17895         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17896         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17897         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17898         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17899         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17900         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17901         {}
17902 };
17903
17904 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17905         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
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, 0x0},   /* Headphone */
17909         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17910         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17911         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17912         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17913         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17914         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17915         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17916         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17917         {}
17918 };
17919
17920 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17921         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17922         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17923         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17924         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17925         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17926         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17927         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17928         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17929         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17930         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17931         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17932         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17933         {}
17934 };
17935
17936 static struct hda_verb alc663_g71v_init_verbs[] = {
17937         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17938         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17939         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17940
17941         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17942         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17943         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17944
17945         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17946         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17947         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17948         {}
17949 };
17950
17951 static struct hda_verb alc663_g50v_init_verbs[] = {
17952         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17953         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17954         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17955
17956         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17957         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17958         {}
17959 };
17960
17961 static struct hda_verb alc662_ecs_init_verbs[] = {
17962         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17963         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17964         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17965         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17966         {}
17967 };
17968
17969 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17970         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17971         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17972         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17973         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17974         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17975         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17976         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17977         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17978         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17979         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17980         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17981         {}
17982 };
17983
17984 static struct hda_verb alc272_dell_init_verbs[] = {
17985         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17986         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17987         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17988         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17989         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17990         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17991         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17992         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17993         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17994         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17995         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17996         {}
17997 };
17998
17999 static struct hda_verb alc663_mode7_init_verbs[] = {
18000         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18001         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18002         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18003         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18004         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18005         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18006         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18007         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18008         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18009         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18010         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18011         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18012         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18013         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18014         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18015         {}
18016 };
18017
18018 static struct hda_verb alc663_mode8_init_verbs[] = {
18019         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18020         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18021         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18022         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18023         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18024         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18025         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18026         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18027         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18028         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18029         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18030         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18031         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18032         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18033         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18034         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18035         {}
18036 };
18037
18038 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18039         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18040         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18041         { } /* end */
18042 };
18043
18044 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18045         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18046         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18047         { } /* end */
18048 };
18049
18050 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18051 {
18052         unsigned int present;
18053         unsigned char bits;
18054
18055         present = snd_hda_jack_detect(codec, 0x14);
18056         bits = present ? HDA_AMP_MUTE : 0;
18057
18058         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18059                                  HDA_AMP_MUTE, bits);
18060 }
18061
18062 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18063 {
18064         unsigned int present;
18065         unsigned char bits;
18066
18067         present = snd_hda_jack_detect(codec, 0x1b);
18068         bits = present ? HDA_AMP_MUTE : 0;
18069
18070         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18071                                  HDA_AMP_MUTE, bits);
18072         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18073                                  HDA_AMP_MUTE, bits);
18074 }
18075
18076 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18077                                            unsigned int res)
18078 {
18079         if ((res >> 26) == ALC880_HP_EVENT)
18080                 alc662_lenovo_101e_all_automute(codec);
18081         if ((res >> 26) == ALC880_FRONT_EVENT)
18082                 alc662_lenovo_101e_ispeaker_automute(codec);
18083 }
18084
18085 /* unsolicited event for HP jack sensing */
18086 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18087                                      unsigned int res)
18088 {
18089         if ((res >> 26) == ALC880_MIC_EVENT)
18090                 alc_mic_automute(codec);
18091         else
18092                 alc262_hippo_unsol_event(codec, res);
18093 }
18094
18095 static void alc662_eeepc_setup(struct hda_codec *codec)
18096 {
18097         struct alc_spec *spec = codec->spec;
18098
18099         alc262_hippo1_setup(codec);
18100         spec->ext_mic.pin = 0x18;
18101         spec->ext_mic.mux_idx = 0;
18102         spec->int_mic.pin = 0x19;
18103         spec->int_mic.mux_idx = 1;
18104         spec->auto_mic = 1;
18105 }
18106
18107 static void alc662_eeepc_inithook(struct hda_codec *codec)
18108 {
18109         alc262_hippo_automute(codec);
18110         alc_mic_automute(codec);
18111 }
18112
18113 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18114 {
18115         struct alc_spec *spec = codec->spec;
18116
18117         spec->autocfg.hp_pins[0] = 0x14;
18118         spec->autocfg.speaker_pins[0] = 0x1b;
18119 }
18120
18121 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
18122
18123 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18124 {
18125         unsigned int present;
18126         unsigned char bits;
18127
18128         present = snd_hda_jack_detect(codec, 0x21);
18129         bits = present ? HDA_AMP_MUTE : 0;
18130         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18131                                  HDA_AMP_MUTE, bits);
18132         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18133                                  HDA_AMP_MUTE, bits);
18134 }
18135
18136 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18137 {
18138         unsigned int present;
18139         unsigned char bits;
18140
18141         present = snd_hda_jack_detect(codec, 0x21);
18142         bits = present ? HDA_AMP_MUTE : 0;
18143         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18144                                  HDA_AMP_MUTE, bits);
18145         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18146                                  HDA_AMP_MUTE, bits);
18147         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18148                                  HDA_AMP_MUTE, bits);
18149         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18150                                  HDA_AMP_MUTE, bits);
18151 }
18152
18153 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18154 {
18155         unsigned int present;
18156         unsigned char bits;
18157
18158         present = snd_hda_jack_detect(codec, 0x15);
18159         bits = present ? HDA_AMP_MUTE : 0;
18160         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18161                                  HDA_AMP_MUTE, bits);
18162         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18163                                  HDA_AMP_MUTE, bits);
18164         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18165                                  HDA_AMP_MUTE, bits);
18166         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18167                                  HDA_AMP_MUTE, bits);
18168 }
18169
18170 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18171 {
18172         unsigned int present;
18173         unsigned char bits;
18174
18175         present = snd_hda_jack_detect(codec, 0x1b);
18176         bits = present ? 0 : PIN_OUT;
18177         snd_hda_codec_write(codec, 0x14, 0,
18178                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18179 }
18180
18181 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18182 {
18183         unsigned int present1, present2;
18184
18185         present1 = snd_hda_jack_detect(codec, 0x21);
18186         present2 = snd_hda_jack_detect(codec, 0x15);
18187
18188         if (present1 || present2) {
18189                 snd_hda_codec_write_cache(codec, 0x14, 0,
18190                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18191         } else {
18192                 snd_hda_codec_write_cache(codec, 0x14, 0,
18193                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18194         }
18195 }
18196
18197 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18198 {
18199         unsigned int present1, present2;
18200
18201         present1 = snd_hda_jack_detect(codec, 0x1b);
18202         present2 = snd_hda_jack_detect(codec, 0x15);
18203
18204         if (present1 || present2) {
18205                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18206                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18207                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18208                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18209         } else {
18210                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18211                                          HDA_AMP_MUTE, 0);
18212                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18213                                          HDA_AMP_MUTE, 0);
18214         }
18215 }
18216
18217 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18218 {
18219         unsigned int present1, present2;
18220
18221         present1 = snd_hda_codec_read(codec, 0x1b, 0,
18222                         AC_VERB_GET_PIN_SENSE, 0)
18223                         & AC_PINSENSE_PRESENCE;
18224         present2 = snd_hda_codec_read(codec, 0x21, 0,
18225                         AC_VERB_GET_PIN_SENSE, 0)
18226                         & AC_PINSENSE_PRESENCE;
18227
18228         if (present1 || present2) {
18229                 snd_hda_codec_write_cache(codec, 0x14, 0,
18230                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18231                 snd_hda_codec_write_cache(codec, 0x17, 0,
18232                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18233         } else {
18234                 snd_hda_codec_write_cache(codec, 0x14, 0,
18235                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18236                 snd_hda_codec_write_cache(codec, 0x17, 0,
18237                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18238         }
18239 }
18240
18241 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18242 {
18243         unsigned int present1, present2;
18244
18245         present1 = snd_hda_codec_read(codec, 0x21, 0,
18246                         AC_VERB_GET_PIN_SENSE, 0)
18247                         & AC_PINSENSE_PRESENCE;
18248         present2 = snd_hda_codec_read(codec, 0x15, 0,
18249                         AC_VERB_GET_PIN_SENSE, 0)
18250                         & AC_PINSENSE_PRESENCE;
18251
18252         if (present1 || present2) {
18253                 snd_hda_codec_write_cache(codec, 0x14, 0,
18254                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18255                 snd_hda_codec_write_cache(codec, 0x17, 0,
18256                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18257         } else {
18258                 snd_hda_codec_write_cache(codec, 0x14, 0,
18259                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18260                 snd_hda_codec_write_cache(codec, 0x17, 0,
18261                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18262         }
18263 }
18264
18265 static void alc663_m51va_unsol_event(struct hda_codec *codec,
18266                                            unsigned int res)
18267 {
18268         switch (res >> 26) {
18269         case ALC880_HP_EVENT:
18270                 alc663_m51va_speaker_automute(codec);
18271                 break;
18272         case ALC880_MIC_EVENT:
18273                 alc_mic_automute(codec);
18274                 break;
18275         }
18276 }
18277
18278 static void alc663_m51va_setup(struct hda_codec *codec)
18279 {
18280         struct alc_spec *spec = codec->spec;
18281         spec->ext_mic.pin = 0x18;
18282         spec->ext_mic.mux_idx = 0;
18283         spec->int_mic.pin = 0x12;
18284         spec->int_mic.mux_idx = 9;
18285         spec->auto_mic = 1;
18286 }
18287
18288 static void alc663_m51va_inithook(struct hda_codec *codec)
18289 {
18290         alc663_m51va_speaker_automute(codec);
18291         alc_mic_automute(codec);
18292 }
18293
18294 /* ***************** Mode1 ******************************/
18295 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
18296
18297 static void alc663_mode1_setup(struct hda_codec *codec)
18298 {
18299         struct alc_spec *spec = codec->spec;
18300         spec->ext_mic.pin = 0x18;
18301         spec->ext_mic.mux_idx = 0;
18302         spec->int_mic.pin = 0x19;
18303         spec->int_mic.mux_idx = 1;
18304         spec->auto_mic = 1;
18305 }
18306
18307 #define alc663_mode1_inithook           alc663_m51va_inithook
18308
18309 /* ***************** Mode2 ******************************/
18310 static void alc662_mode2_unsol_event(struct hda_codec *codec,
18311                                            unsigned int res)
18312 {
18313         switch (res >> 26) {
18314         case ALC880_HP_EVENT:
18315                 alc662_f5z_speaker_automute(codec);
18316                 break;
18317         case ALC880_MIC_EVENT:
18318                 alc_mic_automute(codec);
18319                 break;
18320         }
18321 }
18322
18323 #define alc662_mode2_setup      alc663_mode1_setup
18324
18325 static void alc662_mode2_inithook(struct hda_codec *codec)
18326 {
18327         alc662_f5z_speaker_automute(codec);
18328         alc_mic_automute(codec);
18329 }
18330 /* ***************** Mode3 ******************************/
18331 static void alc663_mode3_unsol_event(struct hda_codec *codec,
18332                                            unsigned int res)
18333 {
18334         switch (res >> 26) {
18335         case ALC880_HP_EVENT:
18336                 alc663_two_hp_m1_speaker_automute(codec);
18337                 break;
18338         case ALC880_MIC_EVENT:
18339                 alc_mic_automute(codec);
18340                 break;
18341         }
18342 }
18343
18344 #define alc663_mode3_setup      alc663_mode1_setup
18345
18346 static void alc663_mode3_inithook(struct hda_codec *codec)
18347 {
18348         alc663_two_hp_m1_speaker_automute(codec);
18349         alc_mic_automute(codec);
18350 }
18351 /* ***************** Mode4 ******************************/
18352 static void alc663_mode4_unsol_event(struct hda_codec *codec,
18353                                            unsigned int res)
18354 {
18355         switch (res >> 26) {
18356         case ALC880_HP_EVENT:
18357                 alc663_21jd_two_speaker_automute(codec);
18358                 break;
18359         case ALC880_MIC_EVENT:
18360                 alc_mic_automute(codec);
18361                 break;
18362         }
18363 }
18364
18365 #define alc663_mode4_setup      alc663_mode1_setup
18366
18367 static void alc663_mode4_inithook(struct hda_codec *codec)
18368 {
18369         alc663_21jd_two_speaker_automute(codec);
18370         alc_mic_automute(codec);
18371 }
18372 /* ***************** Mode5 ******************************/
18373 static void alc663_mode5_unsol_event(struct hda_codec *codec,
18374                                            unsigned int res)
18375 {
18376         switch (res >> 26) {
18377         case ALC880_HP_EVENT:
18378                 alc663_15jd_two_speaker_automute(codec);
18379                 break;
18380         case ALC880_MIC_EVENT:
18381                 alc_mic_automute(codec);
18382                 break;
18383         }
18384 }
18385
18386 #define alc663_mode5_setup      alc663_mode1_setup
18387
18388 static void alc663_mode5_inithook(struct hda_codec *codec)
18389 {
18390         alc663_15jd_two_speaker_automute(codec);
18391         alc_mic_automute(codec);
18392 }
18393 /* ***************** Mode6 ******************************/
18394 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18395                                            unsigned int res)
18396 {
18397         switch (res >> 26) {
18398         case ALC880_HP_EVENT:
18399                 alc663_two_hp_m2_speaker_automute(codec);
18400                 break;
18401         case ALC880_MIC_EVENT:
18402                 alc_mic_automute(codec);
18403                 break;
18404         }
18405 }
18406
18407 #define alc663_mode6_setup      alc663_mode1_setup
18408
18409 static void alc663_mode6_inithook(struct hda_codec *codec)
18410 {
18411         alc663_two_hp_m2_speaker_automute(codec);
18412         alc_mic_automute(codec);
18413 }
18414
18415 /* ***************** Mode7 ******************************/
18416 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18417                                            unsigned int res)
18418 {
18419         switch (res >> 26) {
18420         case ALC880_HP_EVENT:
18421                 alc663_two_hp_m7_speaker_automute(codec);
18422                 break;
18423         case ALC880_MIC_EVENT:
18424                 alc_mic_automute(codec);
18425                 break;
18426         }
18427 }
18428
18429 #define alc663_mode7_setup      alc663_mode1_setup
18430
18431 static void alc663_mode7_inithook(struct hda_codec *codec)
18432 {
18433         alc663_two_hp_m7_speaker_automute(codec);
18434         alc_mic_automute(codec);
18435 }
18436
18437 /* ***************** Mode8 ******************************/
18438 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18439                                            unsigned int res)
18440 {
18441         switch (res >> 26) {
18442         case ALC880_HP_EVENT:
18443                 alc663_two_hp_m8_speaker_automute(codec);
18444                 break;
18445         case ALC880_MIC_EVENT:
18446                 alc_mic_automute(codec);
18447                 break;
18448         }
18449 }
18450
18451 #define alc663_mode8_setup      alc663_m51va_setup
18452
18453 static void alc663_mode8_inithook(struct hda_codec *codec)
18454 {
18455         alc663_two_hp_m8_speaker_automute(codec);
18456         alc_mic_automute(codec);
18457 }
18458
18459 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18460 {
18461         unsigned int present;
18462         unsigned char bits;
18463
18464         present = snd_hda_jack_detect(codec, 0x21);
18465         bits = present ? HDA_AMP_MUTE : 0;
18466         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18467                                  HDA_AMP_MUTE, bits);
18468         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18469                                  HDA_AMP_MUTE, bits);
18470 }
18471
18472 static void alc663_g71v_front_automute(struct hda_codec *codec)
18473 {
18474         unsigned int present;
18475         unsigned char bits;
18476
18477         present = snd_hda_jack_detect(codec, 0x15);
18478         bits = present ? HDA_AMP_MUTE : 0;
18479         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18480                                  HDA_AMP_MUTE, bits);
18481 }
18482
18483 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18484                                            unsigned int res)
18485 {
18486         switch (res >> 26) {
18487         case ALC880_HP_EVENT:
18488                 alc663_g71v_hp_automute(codec);
18489                 break;
18490         case ALC880_FRONT_EVENT:
18491                 alc663_g71v_front_automute(codec);
18492                 break;
18493         case ALC880_MIC_EVENT:
18494                 alc_mic_automute(codec);
18495                 break;
18496         }
18497 }
18498
18499 #define alc663_g71v_setup       alc663_m51va_setup
18500
18501 static void alc663_g71v_inithook(struct hda_codec *codec)
18502 {
18503         alc663_g71v_front_automute(codec);
18504         alc663_g71v_hp_automute(codec);
18505         alc_mic_automute(codec);
18506 }
18507
18508 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18509                                            unsigned int res)
18510 {
18511         switch (res >> 26) {
18512         case ALC880_HP_EVENT:
18513                 alc663_m51va_speaker_automute(codec);
18514                 break;
18515         case ALC880_MIC_EVENT:
18516                 alc_mic_automute(codec);
18517                 break;
18518         }
18519 }
18520
18521 #define alc663_g50v_setup       alc663_m51va_setup
18522
18523 static void alc663_g50v_inithook(struct hda_codec *codec)
18524 {
18525         alc663_m51va_speaker_automute(codec);
18526         alc_mic_automute(codec);
18527 }
18528
18529 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18530         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18531         ALC262_HIPPO_MASTER_SWITCH,
18532
18533         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
18534         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18535         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18536
18537         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
18538         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18539         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18540         { } /* end */
18541 };
18542
18543 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18544         /* Master Playback automatically created from Speaker and Headphone */
18545         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18546         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18547         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18548         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18549
18550         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18551         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18552         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
18553
18554         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18555         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18556         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
18557         { } /* end */
18558 };
18559
18560 #ifdef CONFIG_SND_HDA_POWER_SAVE
18561 #define alc662_loopbacks        alc880_loopbacks
18562 #endif
18563
18564
18565 /* pcm configuration: identical with ALC880 */
18566 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18567 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18568 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18569 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18570
18571 /*
18572  * configuration and preset
18573  */
18574 static const char *alc662_models[ALC662_MODEL_LAST] = {
18575         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18576         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18577         [ALC662_3ST_6ch]        = "3stack-6ch",
18578         [ALC662_5ST_DIG]        = "6stack-dig",
18579         [ALC662_LENOVO_101E]    = "lenovo-101e",
18580         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18581         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18582         [ALC662_ECS] = "ecs",
18583         [ALC663_ASUS_M51VA] = "m51va",
18584         [ALC663_ASUS_G71V] = "g71v",
18585         [ALC663_ASUS_H13] = "h13",
18586         [ALC663_ASUS_G50V] = "g50v",
18587         [ALC663_ASUS_MODE1] = "asus-mode1",
18588         [ALC662_ASUS_MODE2] = "asus-mode2",
18589         [ALC663_ASUS_MODE3] = "asus-mode3",
18590         [ALC663_ASUS_MODE4] = "asus-mode4",
18591         [ALC663_ASUS_MODE5] = "asus-mode5",
18592         [ALC663_ASUS_MODE6] = "asus-mode6",
18593         [ALC663_ASUS_MODE7] = "asus-mode7",
18594         [ALC663_ASUS_MODE8] = "asus-mode8",
18595         [ALC272_DELL]           = "dell",
18596         [ALC272_DELL_ZM1]       = "dell-zm1",
18597         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18598         [ALC662_AUTO]           = "auto",
18599 };
18600
18601 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18602         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18603         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18604         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18605         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18606         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18607         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18608         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18609         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18610         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18611         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18612         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18613         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18614         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18615         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18616         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18617         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18618         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18619         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18620         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18621         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18622         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18623         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18624         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18625         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18626         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18627         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18628         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18629         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18630         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18631         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18632         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18633         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18634         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18635         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18636         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18637         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18638         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18639         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18640         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18641         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18642         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18643         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18644         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18645         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18646         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18647         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18648         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18649         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18650         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18651         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18652         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18653         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18654         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18655         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18656         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18657         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18658         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18659         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18660         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18661         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18662         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18663         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18664         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18665         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18666                       ALC662_3ST_6ch_DIG),
18667         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18668         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18669         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18670                       ALC662_3ST_6ch_DIG),
18671         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18672         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18673         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18674         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18675         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18676                                         ALC662_3ST_6ch_DIG),
18677         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18678                            ALC663_ASUS_H13),
18679         {}
18680 };
18681
18682 static struct alc_config_preset alc662_presets[] = {
18683         [ALC662_3ST_2ch_DIG] = {
18684                 .mixers = { alc662_3ST_2ch_mixer },
18685                 .init_verbs = { alc662_init_verbs },
18686                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18687                 .dac_nids = alc662_dac_nids,
18688                 .dig_out_nid = ALC662_DIGOUT_NID,
18689                 .dig_in_nid = ALC662_DIGIN_NID,
18690                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18691                 .channel_mode = alc662_3ST_2ch_modes,
18692                 .input_mux = &alc662_capture_source,
18693         },
18694         [ALC662_3ST_6ch_DIG] = {
18695                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18696                 .init_verbs = { alc662_init_verbs },
18697                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18698                 .dac_nids = alc662_dac_nids,
18699                 .dig_out_nid = ALC662_DIGOUT_NID,
18700                 .dig_in_nid = ALC662_DIGIN_NID,
18701                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18702                 .channel_mode = alc662_3ST_6ch_modes,
18703                 .need_dac_fix = 1,
18704                 .input_mux = &alc662_capture_source,
18705         },
18706         [ALC662_3ST_6ch] = {
18707                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18708                 .init_verbs = { alc662_init_verbs },
18709                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18710                 .dac_nids = alc662_dac_nids,
18711                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18712                 .channel_mode = alc662_3ST_6ch_modes,
18713                 .need_dac_fix = 1,
18714                 .input_mux = &alc662_capture_source,
18715         },
18716         [ALC662_5ST_DIG] = {
18717                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18718                 .init_verbs = { alc662_init_verbs },
18719                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18720                 .dac_nids = alc662_dac_nids,
18721                 .dig_out_nid = ALC662_DIGOUT_NID,
18722                 .dig_in_nid = ALC662_DIGIN_NID,
18723                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18724                 .channel_mode = alc662_5stack_modes,
18725                 .input_mux = &alc662_capture_source,
18726         },
18727         [ALC662_LENOVO_101E] = {
18728                 .mixers = { alc662_lenovo_101e_mixer },
18729                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18730                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18731                 .dac_nids = alc662_dac_nids,
18732                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18733                 .channel_mode = alc662_3ST_2ch_modes,
18734                 .input_mux = &alc662_lenovo_101e_capture_source,
18735                 .unsol_event = alc662_lenovo_101e_unsol_event,
18736                 .init_hook = alc662_lenovo_101e_all_automute,
18737         },
18738         [ALC662_ASUS_EEEPC_P701] = {
18739                 .mixers = { alc662_eeepc_p701_mixer },
18740                 .init_verbs = { alc662_init_verbs,
18741                                 alc662_eeepc_sue_init_verbs },
18742                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18743                 .dac_nids = alc662_dac_nids,
18744                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18745                 .channel_mode = alc662_3ST_2ch_modes,
18746                 .unsol_event = alc662_eeepc_unsol_event,
18747                 .setup = alc662_eeepc_setup,
18748                 .init_hook = alc662_eeepc_inithook,
18749         },
18750         [ALC662_ASUS_EEEPC_EP20] = {
18751                 .mixers = { alc662_eeepc_ep20_mixer,
18752                             alc662_chmode_mixer },
18753                 .init_verbs = { alc662_init_verbs,
18754                                 alc662_eeepc_ep20_sue_init_verbs },
18755                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18756                 .dac_nids = alc662_dac_nids,
18757                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18758                 .channel_mode = alc662_3ST_6ch_modes,
18759                 .input_mux = &alc662_lenovo_101e_capture_source,
18760                 .unsol_event = alc662_eeepc_unsol_event,
18761                 .setup = alc662_eeepc_ep20_setup,
18762                 .init_hook = alc662_eeepc_ep20_inithook,
18763         },
18764         [ALC662_ECS] = {
18765                 .mixers = { alc662_ecs_mixer },
18766                 .init_verbs = { alc662_init_verbs,
18767                                 alc662_ecs_init_verbs },
18768                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18769                 .dac_nids = alc662_dac_nids,
18770                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18771                 .channel_mode = alc662_3ST_2ch_modes,
18772                 .unsol_event = alc662_eeepc_unsol_event,
18773                 .setup = alc662_eeepc_setup,
18774                 .init_hook = alc662_eeepc_inithook,
18775         },
18776         [ALC663_ASUS_M51VA] = {
18777                 .mixers = { alc663_m51va_mixer },
18778                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18779                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18780                 .dac_nids = alc662_dac_nids,
18781                 .dig_out_nid = ALC662_DIGOUT_NID,
18782                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18783                 .channel_mode = alc662_3ST_2ch_modes,
18784                 .unsol_event = alc663_m51va_unsol_event,
18785                 .setup = alc663_m51va_setup,
18786                 .init_hook = alc663_m51va_inithook,
18787         },
18788         [ALC663_ASUS_G71V] = {
18789                 .mixers = { alc663_g71v_mixer },
18790                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18791                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18792                 .dac_nids = alc662_dac_nids,
18793                 .dig_out_nid = ALC662_DIGOUT_NID,
18794                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18795                 .channel_mode = alc662_3ST_2ch_modes,
18796                 .unsol_event = alc663_g71v_unsol_event,
18797                 .setup = alc663_g71v_setup,
18798                 .init_hook = alc663_g71v_inithook,
18799         },
18800         [ALC663_ASUS_H13] = {
18801                 .mixers = { alc663_m51va_mixer },
18802                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18803                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18804                 .dac_nids = alc662_dac_nids,
18805                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18806                 .channel_mode = alc662_3ST_2ch_modes,
18807                 .unsol_event = alc663_m51va_unsol_event,
18808                 .init_hook = alc663_m51va_inithook,
18809         },
18810         [ALC663_ASUS_G50V] = {
18811                 .mixers = { alc663_g50v_mixer },
18812                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18813                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18814                 .dac_nids = alc662_dac_nids,
18815                 .dig_out_nid = ALC662_DIGOUT_NID,
18816                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18817                 .channel_mode = alc662_3ST_6ch_modes,
18818                 .input_mux = &alc663_capture_source,
18819                 .unsol_event = alc663_g50v_unsol_event,
18820                 .setup = alc663_g50v_setup,
18821                 .init_hook = alc663_g50v_inithook,
18822         },
18823         [ALC663_ASUS_MODE1] = {
18824                 .mixers = { alc663_m51va_mixer },
18825                 .cap_mixer = alc662_auto_capture_mixer,
18826                 .init_verbs = { alc662_init_verbs,
18827                                 alc663_21jd_amic_init_verbs },
18828                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18829                 .hp_nid = 0x03,
18830                 .dac_nids = alc662_dac_nids,
18831                 .dig_out_nid = ALC662_DIGOUT_NID,
18832                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18833                 .channel_mode = alc662_3ST_2ch_modes,
18834                 .unsol_event = alc663_mode1_unsol_event,
18835                 .setup = alc663_mode1_setup,
18836                 .init_hook = alc663_mode1_inithook,
18837         },
18838         [ALC662_ASUS_MODE2] = {
18839                 .mixers = { alc662_1bjd_mixer },
18840                 .cap_mixer = alc662_auto_capture_mixer,
18841                 .init_verbs = { alc662_init_verbs,
18842                                 alc662_1bjd_amic_init_verbs },
18843                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18844                 .dac_nids = alc662_dac_nids,
18845                 .dig_out_nid = ALC662_DIGOUT_NID,
18846                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18847                 .channel_mode = alc662_3ST_2ch_modes,
18848                 .unsol_event = alc662_mode2_unsol_event,
18849                 .setup = alc662_mode2_setup,
18850                 .init_hook = alc662_mode2_inithook,
18851         },
18852         [ALC663_ASUS_MODE3] = {
18853                 .mixers = { alc663_two_hp_m1_mixer },
18854                 .cap_mixer = alc662_auto_capture_mixer,
18855                 .init_verbs = { alc662_init_verbs,
18856                                 alc663_two_hp_amic_m1_init_verbs },
18857                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18858                 .hp_nid = 0x03,
18859                 .dac_nids = alc662_dac_nids,
18860                 .dig_out_nid = ALC662_DIGOUT_NID,
18861                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18862                 .channel_mode = alc662_3ST_2ch_modes,
18863                 .unsol_event = alc663_mode3_unsol_event,
18864                 .setup = alc663_mode3_setup,
18865                 .init_hook = alc663_mode3_inithook,
18866         },
18867         [ALC663_ASUS_MODE4] = {
18868                 .mixers = { alc663_asus_21jd_clfe_mixer },
18869                 .cap_mixer = alc662_auto_capture_mixer,
18870                 .init_verbs = { alc662_init_verbs,
18871                                 alc663_21jd_amic_init_verbs},
18872                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18873                 .hp_nid = 0x03,
18874                 .dac_nids = alc662_dac_nids,
18875                 .dig_out_nid = ALC662_DIGOUT_NID,
18876                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18877                 .channel_mode = alc662_3ST_2ch_modes,
18878                 .unsol_event = alc663_mode4_unsol_event,
18879                 .setup = alc663_mode4_setup,
18880                 .init_hook = alc663_mode4_inithook,
18881         },
18882         [ALC663_ASUS_MODE5] = {
18883                 .mixers = { alc663_asus_15jd_clfe_mixer },
18884                 .cap_mixer = alc662_auto_capture_mixer,
18885                 .init_verbs = { alc662_init_verbs,
18886                                 alc663_15jd_amic_init_verbs },
18887                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18888                 .hp_nid = 0x03,
18889                 .dac_nids = alc662_dac_nids,
18890                 .dig_out_nid = ALC662_DIGOUT_NID,
18891                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18892                 .channel_mode = alc662_3ST_2ch_modes,
18893                 .unsol_event = alc663_mode5_unsol_event,
18894                 .setup = alc663_mode5_setup,
18895                 .init_hook = alc663_mode5_inithook,
18896         },
18897         [ALC663_ASUS_MODE6] = {
18898                 .mixers = { alc663_two_hp_m2_mixer },
18899                 .cap_mixer = alc662_auto_capture_mixer,
18900                 .init_verbs = { alc662_init_verbs,
18901                                 alc663_two_hp_amic_m2_init_verbs },
18902                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18903                 .hp_nid = 0x03,
18904                 .dac_nids = alc662_dac_nids,
18905                 .dig_out_nid = ALC662_DIGOUT_NID,
18906                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18907                 .channel_mode = alc662_3ST_2ch_modes,
18908                 .unsol_event = alc663_mode6_unsol_event,
18909                 .setup = alc663_mode6_setup,
18910                 .init_hook = alc663_mode6_inithook,
18911         },
18912         [ALC663_ASUS_MODE7] = {
18913                 .mixers = { alc663_mode7_mixer },
18914                 .cap_mixer = alc662_auto_capture_mixer,
18915                 .init_verbs = { alc662_init_verbs,
18916                                 alc663_mode7_init_verbs },
18917                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18918                 .hp_nid = 0x03,
18919                 .dac_nids = alc662_dac_nids,
18920                 .dig_out_nid = ALC662_DIGOUT_NID,
18921                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18922                 .channel_mode = alc662_3ST_2ch_modes,
18923                 .unsol_event = alc663_mode7_unsol_event,
18924                 .setup = alc663_mode7_setup,
18925                 .init_hook = alc663_mode7_inithook,
18926         },
18927         [ALC663_ASUS_MODE8] = {
18928                 .mixers = { alc663_mode8_mixer },
18929                 .cap_mixer = alc662_auto_capture_mixer,
18930                 .init_verbs = { alc662_init_verbs,
18931                                 alc663_mode8_init_verbs },
18932                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18933                 .hp_nid = 0x03,
18934                 .dac_nids = alc662_dac_nids,
18935                 .dig_out_nid = ALC662_DIGOUT_NID,
18936                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18937                 .channel_mode = alc662_3ST_2ch_modes,
18938                 .unsol_event = alc663_mode8_unsol_event,
18939                 .setup = alc663_mode8_setup,
18940                 .init_hook = alc663_mode8_inithook,
18941         },
18942         [ALC272_DELL] = {
18943                 .mixers = { alc663_m51va_mixer },
18944                 .cap_mixer = alc272_auto_capture_mixer,
18945                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18946                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18947                 .dac_nids = alc662_dac_nids,
18948                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18949                 .adc_nids = alc272_adc_nids,
18950                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18951                 .capsrc_nids = alc272_capsrc_nids,
18952                 .channel_mode = alc662_3ST_2ch_modes,
18953                 .unsol_event = alc663_m51va_unsol_event,
18954                 .setup = alc663_m51va_setup,
18955                 .init_hook = alc663_m51va_inithook,
18956         },
18957         [ALC272_DELL_ZM1] = {
18958                 .mixers = { alc663_m51va_mixer },
18959                 .cap_mixer = alc662_auto_capture_mixer,
18960                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18961                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18962                 .dac_nids = alc662_dac_nids,
18963                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18964                 .adc_nids = alc662_adc_nids,
18965                 .num_adc_nids = 1,
18966                 .capsrc_nids = alc662_capsrc_nids,
18967                 .channel_mode = alc662_3ST_2ch_modes,
18968                 .unsol_event = alc663_m51va_unsol_event,
18969                 .setup = alc663_m51va_setup,
18970                 .init_hook = alc663_m51va_inithook,
18971         },
18972         [ALC272_SAMSUNG_NC10] = {
18973                 .mixers = { alc272_nc10_mixer },
18974                 .init_verbs = { alc662_init_verbs,
18975                                 alc663_21jd_amic_init_verbs },
18976                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18977                 .dac_nids = alc272_dac_nids,
18978                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18979                 .channel_mode = alc662_3ST_2ch_modes,
18980                 /*.input_mux = &alc272_nc10_capture_source,*/
18981                 .unsol_event = alc663_mode4_unsol_event,
18982                 .setup = alc663_mode4_setup,
18983                 .init_hook = alc663_mode4_inithook,
18984         },
18985 };
18986
18987
18988 /*
18989  * BIOS auto configuration
18990  */
18991
18992 /* convert from MIX nid to DAC */
18993 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18994 {
18995         if (nid == 0x0f)
18996                 return 0x02;
18997         else if (nid >= 0x0c && nid <= 0x0e)
18998                 return nid - 0x0c + 0x02;
18999         else if (nid == 0x26) /* ALC887-VD has this DAC too */
19000                 return 0x25;
19001         else
19002                 return 0;
19003 }
19004
19005 /* get MIX nid connected to the given pin targeted to DAC */
19006 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19007                                    hda_nid_t dac)
19008 {
19009         hda_nid_t mix[5];
19010         int i, num;
19011
19012         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19013         for (i = 0; i < num; i++) {
19014                 if (alc662_mix_to_dac(mix[i]) == dac)
19015                         return mix[i];
19016         }
19017         return 0;
19018 }
19019
19020 /* look for an empty DAC slot */
19021 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19022 {
19023         struct alc_spec *spec = codec->spec;
19024         hda_nid_t srcs[5];
19025         int i, j, num;
19026
19027         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19028         if (num < 0)
19029                 return 0;
19030         for (i = 0; i < num; i++) {
19031                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19032                 if (!nid)
19033                         continue;
19034                 for (j = 0; j < spec->multiout.num_dacs; j++)
19035                         if (spec->multiout.dac_nids[j] == nid)
19036                                 break;
19037                 if (j >= spec->multiout.num_dacs)
19038                         return nid;
19039         }
19040         return 0;
19041 }
19042
19043 /* fill in the dac_nids table from the parsed pin configuration */
19044 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19045                                      const struct auto_pin_cfg *cfg)
19046 {
19047         struct alc_spec *spec = codec->spec;
19048         int i;
19049         hda_nid_t dac;
19050
19051         spec->multiout.dac_nids = spec->private_dac_nids;
19052         for (i = 0; i < cfg->line_outs; i++) {
19053                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19054                 if (!dac)
19055                         continue;
19056                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19057         }
19058         return 0;
19059 }
19060
19061 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19062                               hda_nid_t nid, unsigned int chs)
19063 {
19064         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
19065                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19066 }
19067
19068 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19069                              hda_nid_t nid, unsigned int chs)
19070 {
19071         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19072                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19073 }
19074
19075 #define alc662_add_stereo_vol(spec, pfx, nid) \
19076         alc662_add_vol_ctl(spec, pfx, nid, 3)
19077 #define alc662_add_stereo_sw(spec, pfx, nid) \
19078         alc662_add_sw_ctl(spec, pfx, nid, 3)
19079
19080 /* add playback controls from the parsed DAC table */
19081 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19082                                              const struct auto_pin_cfg *cfg)
19083 {
19084         struct alc_spec *spec = codec->spec;
19085         static const char *chname[4] = {
19086                 "Front", "Surround", NULL /*CLFE*/, "Side"
19087         };
19088         hda_nid_t nid, mix;
19089         int i, err;
19090
19091         for (i = 0; i < cfg->line_outs; i++) {
19092                 nid = spec->multiout.dac_nids[i];
19093                 if (!nid)
19094                         continue;
19095                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19096                 if (!mix)
19097                         continue;
19098                 if (i == 2) {
19099                         /* Center/LFE */
19100                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19101                         if (err < 0)
19102                                 return err;
19103                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19104                         if (err < 0)
19105                                 return err;
19106                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19107                         if (err < 0)
19108                                 return err;
19109                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19110                         if (err < 0)
19111                                 return err;
19112                 } else {
19113                         const char *pfx;
19114                         if (cfg->line_outs == 1 &&
19115                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
19116                                 if (cfg->hp_outs)
19117                                         pfx = "Speaker";
19118                                 else
19119                                         pfx = "PCM";
19120                         } else
19121                                 pfx = chname[i];
19122                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19123                         if (err < 0)
19124                                 return err;
19125                         if (cfg->line_outs == 1 &&
19126                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19127                                 pfx = "Speaker";
19128                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19129                         if (err < 0)
19130                                 return err;
19131                 }
19132         }
19133         return 0;
19134 }
19135
19136 /* add playback controls for speaker and HP outputs */
19137 /* return DAC nid if any new DAC is assigned */
19138 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19139                                         const char *pfx)
19140 {
19141         struct alc_spec *spec = codec->spec;
19142         hda_nid_t nid, mix;
19143         int err;
19144
19145         if (!pin)
19146                 return 0;
19147         nid = alc662_look_for_dac(codec, pin);
19148         if (!nid) {
19149                 /* the corresponding DAC is already occupied */
19150                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19151                         return 0; /* no way */
19152                 /* create a switch only */
19153                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19154                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19155         }
19156
19157         mix = alc662_dac_to_mix(codec, pin, nid);
19158         if (!mix)
19159                 return 0;
19160         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19161         if (err < 0)
19162                 return err;
19163         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19164         if (err < 0)
19165                 return err;
19166         return nid;
19167 }
19168
19169 /* create playback/capture controls for input pins */
19170 #define alc662_auto_create_input_ctls \
19171         alc882_auto_create_input_ctls
19172
19173 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19174                                               hda_nid_t nid, int pin_type,
19175                                               hda_nid_t dac)
19176 {
19177         int i, num;
19178         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19179
19180         alc_set_pin_output(codec, nid, pin_type);
19181         /* need the manual connection? */
19182         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19183         if (num <= 1)
19184                 return;
19185         for (i = 0; i < num; i++) {
19186                 if (alc662_mix_to_dac(srcs[i]) != dac)
19187                         continue;
19188                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19189                 return;
19190         }
19191 }
19192
19193 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19194 {
19195         struct alc_spec *spec = codec->spec;
19196         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19197         int i;
19198
19199         for (i = 0; i <= HDA_SIDE; i++) {
19200                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19201                 if (nid)
19202                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19203                                         spec->multiout.dac_nids[i]);
19204         }
19205 }
19206
19207 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19208 {
19209         struct alc_spec *spec = codec->spec;
19210         hda_nid_t pin;
19211
19212         pin = spec->autocfg.hp_pins[0];
19213         if (pin)
19214                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19215                                                   spec->multiout.hp_nid);
19216         pin = spec->autocfg.speaker_pins[0];
19217         if (pin)
19218                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19219                                         spec->multiout.extra_out_nid[0]);
19220 }
19221
19222 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19223
19224 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19225 {
19226         struct alc_spec *spec = codec->spec;
19227         struct auto_pin_cfg *cfg = &spec->autocfg;
19228         int i;
19229
19230         for (i = 0; i < cfg->num_inputs; i++) {
19231                 hda_nid_t nid = cfg->inputs[i].pin;
19232                 if (alc_is_input_pin(codec, nid)) {
19233                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19234                         if (nid != ALC662_PIN_CD_NID &&
19235                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19236                                 snd_hda_codec_write(codec, nid, 0,
19237                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19238                                                     AMP_OUT_MUTE);
19239                 }
19240         }
19241 }
19242
19243 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19244
19245 static int alc662_parse_auto_config(struct hda_codec *codec)
19246 {
19247         struct alc_spec *spec = codec->spec;
19248         int err;
19249         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19250
19251         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19252                                            alc662_ignore);
19253         if (err < 0)
19254                 return err;
19255         if (!spec->autocfg.line_outs)
19256                 return 0; /* can't find valid BIOS pin config */
19257
19258         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19259         if (err < 0)
19260                 return err;
19261         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19262         if (err < 0)
19263                 return err;
19264         err = alc662_auto_create_extra_out(codec,
19265                                            spec->autocfg.speaker_pins[0],
19266                                            "Speaker");
19267         if (err < 0)
19268                 return err;
19269         if (err)
19270                 spec->multiout.extra_out_nid[0] = err;
19271         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19272                                            "Headphone");
19273         if (err < 0)
19274                 return err;
19275         if (err)
19276                 spec->multiout.hp_nid = err;
19277         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19278         if (err < 0)
19279                 return err;
19280
19281         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19282
19283         alc_auto_parse_digital(codec);
19284
19285         if (spec->kctls.list)
19286                 add_mixer(spec, spec->kctls.list);
19287
19288         spec->num_mux_defs = 1;
19289         spec->input_mux = &spec->private_imux[0];
19290
19291         add_verb(spec, alc662_init_verbs);
19292         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19293             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19294                 add_verb(spec, alc663_init_verbs);
19295
19296         if (codec->vendor_id == 0x10ec0272)
19297                 add_verb(spec, alc272_init_verbs);
19298
19299         err = alc_auto_add_mic_boost(codec);
19300         if (err < 0)
19301                 return err;
19302
19303         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19304             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19305             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19306         else
19307             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19308
19309         return 1;
19310 }
19311
19312 /* additional initialization for auto-configuration model */
19313 static void alc662_auto_init(struct hda_codec *codec)
19314 {
19315         struct alc_spec *spec = codec->spec;
19316         alc662_auto_init_multi_out(codec);
19317         alc662_auto_init_hp_out(codec);
19318         alc662_auto_init_analog_input(codec);
19319         alc662_auto_init_input_src(codec);
19320         alc_auto_init_digital(codec);
19321         if (spec->unsol_event)
19322                 alc_inithook(codec);
19323 }
19324
19325 static void alc272_fixup_mario(struct hda_codec *codec,
19326                                const struct alc_fixup *fix, int pre_init) {
19327         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19328                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19329                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19330                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19331                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19332                 printk(KERN_WARNING
19333                        "hda_codec: failed to override amp caps for NID 0x2\n");
19334 }
19335
19336 enum {
19337         ALC662_FIXUP_ASPIRE,
19338         ALC662_FIXUP_IDEAPAD,
19339         ALC272_FIXUP_MARIO,
19340 };
19341
19342 static const struct alc_fixup alc662_fixups[] = {
19343         [ALC662_FIXUP_ASPIRE] = {
19344                 .pins = (const struct alc_pincfg[]) {
19345                         { 0x15, 0x99130112 }, /* subwoofer */
19346                         { }
19347                 }
19348         },
19349         [ALC662_FIXUP_IDEAPAD] = {
19350                 .pins = (const struct alc_pincfg[]) {
19351                         { 0x17, 0x99130112 }, /* subwoofer */
19352                         { }
19353                 }
19354         },
19355         [ALC272_FIXUP_MARIO] = {
19356                 .func = alc272_fixup_mario,
19357         }
19358 };
19359
19360 static struct snd_pci_quirk alc662_fixup_tbl[] = {
19361         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19362         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19363         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19364         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19365         {}
19366 };
19367
19368 static const struct alc_model_fixup alc662_fixup_models[] = {
19369         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19370         {}
19371 };
19372
19373
19374 static int patch_alc662(struct hda_codec *codec)
19375 {
19376         struct alc_spec *spec;
19377         int err, board_config;
19378         int coef;
19379
19380         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19381         if (!spec)
19382                 return -ENOMEM;
19383
19384         codec->spec = spec;
19385
19386         alc_auto_parse_customize_define(codec);
19387
19388         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19389
19390         coef = alc_read_coef_idx(codec, 0);
19391         if (coef == 0x8020 || coef == 0x8011)
19392                 alc_codec_rename(codec, "ALC661");
19393         else if (coef & (1 << 14) &&
19394                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19395                 spec->cdefine.platform_type == 1)
19396                 alc_codec_rename(codec, "ALC272X");
19397         else if (coef == 0x4011)
19398                 alc_codec_rename(codec, "ALC656");
19399
19400         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19401                                                   alc662_models,
19402                                                   alc662_cfg_tbl);
19403         if (board_config < 0) {
19404                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19405                        codec->chip_name);
19406                 board_config = ALC662_AUTO;
19407         }
19408
19409         if (board_config == ALC662_AUTO) {
19410                 alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1);
19411                 /* automatic parse from the BIOS config */
19412                 err = alc662_parse_auto_config(codec);
19413                 if (err < 0) {
19414                         alc_free(codec);
19415                         return err;
19416                 } else if (!err) {
19417                         printk(KERN_INFO
19418                                "hda_codec: Cannot set up configuration "
19419                                "from BIOS.  Using base mode...\n");
19420                         board_config = ALC662_3ST_2ch_DIG;
19421                 }
19422         }
19423
19424         if (has_cdefine_beep(codec)) {
19425                 err = snd_hda_attach_beep_device(codec, 0x1);
19426                 if (err < 0) {
19427                         alc_free(codec);
19428                         return err;
19429                 }
19430         }
19431
19432         if (board_config != ALC662_AUTO)
19433                 setup_preset(codec, &alc662_presets[board_config]);
19434
19435         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19436         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19437
19438         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19439         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19440
19441         if (!spec->adc_nids) {
19442                 spec->adc_nids = alc662_adc_nids;
19443                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19444         }
19445         if (!spec->capsrc_nids)
19446                 spec->capsrc_nids = alc662_capsrc_nids;
19447
19448         if (!spec->cap_mixer)
19449                 set_capture_mixer(codec);
19450
19451         if (has_cdefine_beep(codec)) {
19452                 switch (codec->vendor_id) {
19453                 case 0x10ec0662:
19454                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19455                         break;
19456                 case 0x10ec0272:
19457                 case 0x10ec0663:
19458                 case 0x10ec0665:
19459                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19460                         break;
19461                 case 0x10ec0273:
19462                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19463                         break;
19464                 }
19465         }
19466         spec->vmaster_nid = 0x02;
19467
19468         codec->patch_ops = alc_patch_ops;
19469         if (board_config == ALC662_AUTO) {
19470                 spec->init_hook = alc662_auto_init;
19471                 alc_pick_fixup_model(codec, alc662_fixup_models,
19472                                      alc662_fixup_tbl, alc662_fixups, 0);
19473         }
19474
19475         alc_init_jacks(codec);
19476
19477 #ifdef CONFIG_SND_HDA_POWER_SAVE
19478         if (!spec->loopback.amplist)
19479                 spec->loopback.amplist = alc662_loopbacks;
19480 #endif
19481
19482         return 0;
19483 }
19484
19485 static int patch_alc888(struct hda_codec *codec)
19486 {
19487         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19488                 kfree(codec->chip_name);
19489                 if (codec->vendor_id == 0x10ec0887)
19490                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19491                 else
19492                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19493                 if (!codec->chip_name) {
19494                         alc_free(codec);
19495                         return -ENOMEM;
19496                 }
19497                 return patch_alc662(codec);
19498         }
19499         return patch_alc882(codec);
19500 }
19501
19502 /*
19503  * ALC680 support
19504  */
19505 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19506 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19507 #define alc680_modes            alc260_modes
19508
19509 static hda_nid_t alc680_dac_nids[3] = {
19510         /* Lout1, Lout2, hp */
19511         0x02, 0x03, 0x04
19512 };
19513
19514 static hda_nid_t alc680_adc_nids[3] = {
19515         /* ADC0-2 */
19516         /* DMIC, MIC, Line-in*/
19517         0x07, 0x08, 0x09
19518 };
19519
19520 /*
19521  * Analog capture ADC cgange
19522  */
19523 static void alc680_rec_autoswitch(struct hda_codec *codec)
19524 {
19525         struct alc_spec *spec = codec->spec;
19526         struct auto_pin_cfg *cfg = &spec->autocfg;
19527         int pin_found = 0;
19528         int type_found = AUTO_PIN_LAST;
19529         hda_nid_t nid;
19530         int i;
19531
19532         for (i = 0; i < cfg->num_inputs; i++) {
19533                 nid = cfg->inputs[i].pin;
19534                 if (!(snd_hda_query_pin_caps(codec, nid) &
19535                       AC_PINCAP_PRES_DETECT))
19536                         continue;
19537                 if (snd_hda_jack_detect(codec, nid)) {
19538                         if (cfg->inputs[i].type < type_found) {
19539                                 type_found = cfg->inputs[i].type;
19540                                 pin_found = nid;
19541                         }
19542                 }
19543         }
19544
19545         nid = 0x07;
19546         if (pin_found)
19547                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19548
19549         if (nid != spec->cur_adc)
19550                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19551         spec->cur_adc = nid;
19552         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19553                                    spec->cur_adc_format);
19554 }
19555
19556 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19557                                       struct hda_codec *codec,
19558                                       unsigned int stream_tag,
19559                                       unsigned int format,
19560                                       struct snd_pcm_substream *substream)
19561 {
19562         struct alc_spec *spec = codec->spec;
19563
19564         spec->cur_adc = 0x07;
19565         spec->cur_adc_stream_tag = stream_tag;
19566         spec->cur_adc_format = format;
19567
19568         alc680_rec_autoswitch(codec);
19569         return 0;
19570 }
19571
19572 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19573                                       struct hda_codec *codec,
19574                                       struct snd_pcm_substream *substream)
19575 {
19576         snd_hda_codec_cleanup_stream(codec, 0x07);
19577         snd_hda_codec_cleanup_stream(codec, 0x08);
19578         snd_hda_codec_cleanup_stream(codec, 0x09);
19579         return 0;
19580 }
19581
19582 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19583         .substreams = 1, /* can be overridden */
19584         .channels_min = 2,
19585         .channels_max = 2,
19586         /* NID is set in alc_build_pcms */
19587         .ops = {
19588                 .prepare = alc680_capture_pcm_prepare,
19589                 .cleanup = alc680_capture_pcm_cleanup
19590         },
19591 };
19592
19593 static struct snd_kcontrol_new alc680_base_mixer[] = {
19594         /* output mixer control */
19595         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19596         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19597         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19598         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19599         HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
19600         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
19601         HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
19602         { }
19603 };
19604
19605 static struct hda_bind_ctls alc680_bind_cap_vol = {
19606         .ops = &snd_hda_bind_vol,
19607         .values = {
19608                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19609                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19610                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19611                 0
19612         },
19613 };
19614
19615 static struct hda_bind_ctls alc680_bind_cap_switch = {
19616         .ops = &snd_hda_bind_sw,
19617         .values = {
19618                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19619                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19620                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19621                 0
19622         },
19623 };
19624
19625 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19626         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19627         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19628         { } /* end */
19629 };
19630
19631 /*
19632  * generic initialization of ADC, input mixers and output mixers
19633  */
19634 static struct hda_verb alc680_init_verbs[] = {
19635         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19636         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19637         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19638
19639         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19640         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19641         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19642         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19643         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19644         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19645
19646         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19647         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19648         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19649         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19650         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19651
19652         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19653         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19654         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19655
19656         { }
19657 };
19658
19659 /* toggle speaker-output according to the hp-jack state */
19660 static void alc680_base_setup(struct hda_codec *codec)
19661 {
19662         struct alc_spec *spec = codec->spec;
19663
19664         spec->autocfg.hp_pins[0] = 0x16;
19665         spec->autocfg.speaker_pins[0] = 0x14;
19666         spec->autocfg.speaker_pins[1] = 0x15;
19667         spec->autocfg.num_inputs = 2;
19668         spec->autocfg.inputs[0].pin = 0x18;
19669         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19670         spec->autocfg.inputs[1].pin = 0x19;
19671         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19672 }
19673
19674 static void alc680_unsol_event(struct hda_codec *codec,
19675                                            unsigned int res)
19676 {
19677         if ((res >> 26) == ALC880_HP_EVENT)
19678                 alc_automute_amp(codec);
19679         if ((res >> 26) == ALC880_MIC_EVENT)
19680                 alc680_rec_autoswitch(codec);
19681 }
19682
19683 static void alc680_inithook(struct hda_codec *codec)
19684 {
19685         alc_automute_amp(codec);
19686         alc680_rec_autoswitch(codec);
19687 }
19688
19689 /* create input playback/capture controls for the given pin */
19690 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19691                                     const char *ctlname, int idx)
19692 {
19693         hda_nid_t dac;
19694         int err;
19695
19696         switch (nid) {
19697         case 0x14:
19698                 dac = 0x02;
19699                 break;
19700         case 0x15:
19701                 dac = 0x03;
19702                 break;
19703         case 0x16:
19704                 dac = 0x04;
19705                 break;
19706         default:
19707                 return 0;
19708         }
19709         if (spec->multiout.dac_nids[0] != dac &&
19710             spec->multiout.dac_nids[1] != dac) {
19711                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19712                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19713                                                       HDA_OUTPUT));
19714                 if (err < 0)
19715                         return err;
19716
19717                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19718                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19719
19720                 if (err < 0)
19721                         return err;
19722                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19723         }
19724
19725         return 0;
19726 }
19727
19728 /* add playback controls from the parsed DAC table */
19729 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19730                                              const struct auto_pin_cfg *cfg)
19731 {
19732         hda_nid_t nid;
19733         int err;
19734
19735         spec->multiout.dac_nids = spec->private_dac_nids;
19736
19737         nid = cfg->line_out_pins[0];
19738         if (nid) {
19739                 const char *name;
19740                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19741                         name = "Speaker";
19742                 else
19743                         name = "Front";
19744                 err = alc680_new_analog_output(spec, nid, name, 0);
19745                 if (err < 0)
19746                         return err;
19747         }
19748
19749         nid = cfg->speaker_pins[0];
19750         if (nid) {
19751                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19752                 if (err < 0)
19753                         return err;
19754         }
19755         nid = cfg->hp_pins[0];
19756         if (nid) {
19757                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19758                 if (err < 0)
19759                         return err;
19760         }
19761
19762         return 0;
19763 }
19764
19765 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19766                                               hda_nid_t nid, int pin_type)
19767 {
19768         alc_set_pin_output(codec, nid, pin_type);
19769 }
19770
19771 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19772 {
19773         struct alc_spec *spec = codec->spec;
19774         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19775         if (nid) {
19776                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19777                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19778         }
19779 }
19780
19781 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19782 {
19783         struct alc_spec *spec = codec->spec;
19784         hda_nid_t pin;
19785
19786         pin = spec->autocfg.hp_pins[0];
19787         if (pin)
19788                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19789         pin = spec->autocfg.speaker_pins[0];
19790         if (pin)
19791                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19792 }
19793
19794 /* pcm configuration: identical with ALC880 */
19795 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19796 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19797 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19798 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19799 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19800
19801 /*
19802  * BIOS auto configuration
19803  */
19804 static int alc680_parse_auto_config(struct hda_codec *codec)
19805 {
19806         struct alc_spec *spec = codec->spec;
19807         int err;
19808         static hda_nid_t alc680_ignore[] = { 0 };
19809
19810         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19811                                            alc680_ignore);
19812         if (err < 0)
19813                 return err;
19814
19815         if (!spec->autocfg.line_outs) {
19816                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19817                         spec->multiout.max_channels = 2;
19818                         spec->no_analog = 1;
19819                         goto dig_only;
19820                 }
19821                 return 0; /* can't find valid BIOS pin config */
19822         }
19823         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19824         if (err < 0)
19825                 return err;
19826
19827         spec->multiout.max_channels = 2;
19828
19829  dig_only:
19830         /* digital only support output */
19831         alc_auto_parse_digital(codec);
19832         if (spec->kctls.list)
19833                 add_mixer(spec, spec->kctls.list);
19834
19835         add_verb(spec, alc680_init_verbs);
19836
19837         err = alc_auto_add_mic_boost(codec);
19838         if (err < 0)
19839                 return err;
19840
19841         return 1;
19842 }
19843
19844 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19845
19846 /* init callback for auto-configuration model -- overriding the default init */
19847 static void alc680_auto_init(struct hda_codec *codec)
19848 {
19849         struct alc_spec *spec = codec->spec;
19850         alc680_auto_init_multi_out(codec);
19851         alc680_auto_init_hp_out(codec);
19852         alc680_auto_init_analog_input(codec);
19853         alc_auto_init_digital(codec);
19854         if (spec->unsol_event)
19855                 alc_inithook(codec);
19856 }
19857
19858 /*
19859  * configuration and preset
19860  */
19861 static const char *alc680_models[ALC680_MODEL_LAST] = {
19862         [ALC680_BASE]           = "base",
19863         [ALC680_AUTO]           = "auto",
19864 };
19865
19866 static struct snd_pci_quirk alc680_cfg_tbl[] = {
19867         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19868         {}
19869 };
19870
19871 static struct alc_config_preset alc680_presets[] = {
19872         [ALC680_BASE] = {
19873                 .mixers = { alc680_base_mixer },
19874                 .cap_mixer =  alc680_master_capture_mixer,
19875                 .init_verbs = { alc680_init_verbs },
19876                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
19877                 .dac_nids = alc680_dac_nids,
19878                 .dig_out_nid = ALC680_DIGOUT_NID,
19879                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
19880                 .channel_mode = alc680_modes,
19881                 .unsol_event = alc680_unsol_event,
19882                 .setup = alc680_base_setup,
19883                 .init_hook = alc680_inithook,
19884
19885         },
19886 };
19887
19888 static int patch_alc680(struct hda_codec *codec)
19889 {
19890         struct alc_spec *spec;
19891         int board_config;
19892         int err;
19893
19894         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19895         if (spec == NULL)
19896                 return -ENOMEM;
19897
19898         codec->spec = spec;
19899
19900         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19901                                                   alc680_models,
19902                                                   alc680_cfg_tbl);
19903
19904         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19905                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19906                        codec->chip_name);
19907                 board_config = ALC680_AUTO;
19908         }
19909
19910         if (board_config == ALC680_AUTO) {
19911                 /* automatic parse from the BIOS config */
19912                 err = alc680_parse_auto_config(codec);
19913                 if (err < 0) {
19914                         alc_free(codec);
19915                         return err;
19916                 } else if (!err) {
19917                         printk(KERN_INFO
19918                                "hda_codec: Cannot set up configuration "
19919                                "from BIOS.  Using base mode...\n");
19920                         board_config = ALC680_BASE;
19921                 }
19922         }
19923
19924         if (board_config != ALC680_AUTO)
19925                 setup_preset(codec, &alc680_presets[board_config]);
19926
19927         spec->stream_analog_playback = &alc680_pcm_analog_playback;
19928         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19929         spec->stream_digital_playback = &alc680_pcm_digital_playback;
19930         spec->stream_digital_capture = &alc680_pcm_digital_capture;
19931
19932         if (!spec->adc_nids) {
19933                 spec->adc_nids = alc680_adc_nids;
19934                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19935         }
19936
19937         if (!spec->cap_mixer)
19938                 set_capture_mixer(codec);
19939
19940         spec->vmaster_nid = 0x02;
19941
19942         codec->patch_ops = alc_patch_ops;
19943         if (board_config == ALC680_AUTO)
19944                 spec->init_hook = alc680_auto_init;
19945
19946         return 0;
19947 }
19948
19949 /*
19950  * patch entries
19951  */
19952 static struct hda_codec_preset snd_hda_preset_realtek[] = {
19953         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
19954         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
19955         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
19956         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
19957         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
19958         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
19959         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
19960         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
19961         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
19962           .patch = patch_alc861 },
19963         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
19964         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
19965         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
19966         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
19967           .patch = patch_alc882 },
19968         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
19969           .patch = patch_alc662 },
19970         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
19971         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
19972         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
19973         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
19974         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
19975         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
19976         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
19977         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
19978           .patch = patch_alc882 },
19979         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
19980           .patch = patch_alc882 },
19981         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
19982         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
19983         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
19984           .patch = patch_alc882 },
19985         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
19986         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
19987         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
19988         {} /* terminator */
19989 };
19990
19991 MODULE_ALIAS("snd-hda-codec-id:10ec*");
19992
19993 MODULE_LICENSE("GPL");
19994 MODULE_DESCRIPTION("Realtek HD-audio codec");
19995
19996 static struct hda_codec_preset_list realtek_list = {
19997         .preset = snd_hda_preset_realtek,
19998         .owner = THIS_MODULE,
19999 };
20000
20001 static int __init patch_realtek_init(void)
20002 {
20003         return snd_hda_add_codec_preset(&realtek_list);
20004 }
20005
20006 static void __exit patch_realtek_exit(void)
20007 {
20008         snd_hda_delete_codec_preset(&realtek_list);
20009 }
20010
20011 module_init(patch_realtek_init)
20012 module_exit(patch_realtek_exit)