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         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2030         { }
2031 };
2032
2033 /*
2034  * ALC888 Acer Aspire 6530G model
2035  */
2036
2037 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2038 /* Route to built-in subwoofer as well as speakers */
2039         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2040         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2041         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2042         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2043 /* Bias voltage on for external mic port */
2044         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2045 /* Front Mic: set to PIN_IN (empty by default) */
2046         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2047 /* Unselect Front Mic by default in input mixer 3 */
2048         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2049 /* Enable unsolicited event for HP jack */
2050         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2051 /* Enable speaker output */
2052         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2053         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2054         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2055 /* Enable headphone output */
2056         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2057         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2058         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2059         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2060         { }
2061 };
2062
2063 /*
2064  *ALC888 Acer Aspire 7730G model
2065  */
2066
2067 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2068 /* Bias voltage on for external mic port */
2069         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2070 /* Front Mic: set to PIN_IN (empty by default) */
2071         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2072 /* Unselect Front Mic by default in input mixer 3 */
2073         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2074 /* Enable unsolicited event for HP jack */
2075         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2076 /* Enable speaker output */
2077         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2078         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2079         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2080 /* Enable headphone output */
2081         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2082         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2083         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2084         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2085 /*Enable internal subwoofer */
2086         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2087         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2088         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2089         {0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2090         { }
2091 };
2092
2093 /*
2094  * ALC889 Acer Aspire 8930G model
2095  */
2096
2097 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2098 /* Front Mic: set to PIN_IN (empty by default) */
2099         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2100 /* Unselect Front Mic by default in input mixer 3 */
2101         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2102 /* Enable unsolicited event for HP jack */
2103         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2104 /* Connect Internal Front to Front */
2105         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2106         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2107         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2108 /* Connect Internal Rear to Rear */
2109         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2110         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2111         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2112 /* Connect Internal CLFE to CLFE */
2113         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2114         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2115         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2116 /* Connect HP out to Front */
2117         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2118         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2119         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2120 /* Enable all DACs */
2121 /*  DAC DISABLE/MUTE 1? */
2122 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2123         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2124         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2125 /*  DAC DISABLE/MUTE 2? */
2126 /*  some bit here disables the other DACs. Init=0x4900 */
2127         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2128         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2129 /* DMIC fix
2130  * This laptop has a stereo digital microphone. The mics are only 1cm apart
2131  * which makes the stereo useless. However, either the mic or the ALC889
2132  * makes the signal become a difference/sum signal instead of standard
2133  * stereo, which is annoying. So instead we flip this bit which makes the
2134  * codec replicate the sum signal to both channels, turning it into a
2135  * normal mono mic.
2136  */
2137 /*  DMIC_CONTROL? Init value = 0x0001 */
2138         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2139         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2140         { }
2141 };
2142
2143 static struct hda_input_mux alc888_2_capture_sources[2] = {
2144         /* Front mic only available on one ADC */
2145         {
2146                 .num_items = 4,
2147                 .items = {
2148                         { "Mic", 0x0 },
2149                         { "Line", 0x2 },
2150                         { "CD", 0x4 },
2151                         { "Front Mic", 0xb },
2152                 },
2153         },
2154         {
2155                 .num_items = 3,
2156                 .items = {
2157                         { "Mic", 0x0 },
2158                         { "Line", 0x2 },
2159                         { "CD", 0x4 },
2160                 },
2161         }
2162 };
2163
2164 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2165         /* Interal mic only available on one ADC */
2166         {
2167                 .num_items = 5,
2168                 .items = {
2169                         { "Mic", 0x0 },
2170                         { "Line In", 0x2 },
2171                         { "CD", 0x4 },
2172                         { "Input Mix", 0xa },
2173                         { "Internal Mic", 0xb },
2174                 },
2175         },
2176         {
2177                 .num_items = 4,
2178                 .items = {
2179                         { "Mic", 0x0 },
2180                         { "Line In", 0x2 },
2181                         { "CD", 0x4 },
2182                         { "Input Mix", 0xa },
2183                 },
2184         }
2185 };
2186
2187 static struct hda_input_mux alc889_capture_sources[3] = {
2188         /* Digital mic only available on first "ADC" */
2189         {
2190                 .num_items = 5,
2191                 .items = {
2192                         { "Mic", 0x0 },
2193                         { "Line", 0x2 },
2194                         { "CD", 0x4 },
2195                         { "Front Mic", 0xb },
2196                         { "Input Mix", 0xa },
2197                 },
2198         },
2199         {
2200                 .num_items = 4,
2201                 .items = {
2202                         { "Mic", 0x0 },
2203                         { "Line", 0x2 },
2204                         { "CD", 0x4 },
2205                         { "Input Mix", 0xa },
2206                 },
2207         },
2208         {
2209                 .num_items = 4,
2210                 .items = {
2211                         { "Mic", 0x0 },
2212                         { "Line", 0x2 },
2213                         { "CD", 0x4 },
2214                         { "Input Mix", 0xa },
2215                 },
2216         }
2217 };
2218
2219 static struct snd_kcontrol_new alc888_base_mixer[] = {
2220         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2221         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2222         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2223         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2224         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2225                 HDA_OUTPUT),
2226         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2227         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2228         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2229         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2230         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2231         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2232         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2233         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2234         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2235         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2236         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2237         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2238         { } /* end */
2239 };
2240
2241 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2242         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2243         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2244         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2245         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2246         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2247                 HDA_OUTPUT),
2248         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2249         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2250         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2251         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2252         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2253         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2254         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2255         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2256         { } /* end */
2257 };
2258
2259
2260 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2261 {
2262         struct alc_spec *spec = codec->spec;
2263
2264         spec->autocfg.hp_pins[0] = 0x15;
2265         spec->autocfg.speaker_pins[0] = 0x14;
2266         spec->autocfg.speaker_pins[1] = 0x16;
2267         spec->autocfg.speaker_pins[2] = 0x17;
2268 }
2269
2270 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2271 {
2272         struct alc_spec *spec = codec->spec;
2273
2274         spec->autocfg.hp_pins[0] = 0x15;
2275         spec->autocfg.speaker_pins[0] = 0x14;
2276         spec->autocfg.speaker_pins[1] = 0x16;
2277         spec->autocfg.speaker_pins[2] = 0x17;
2278 }
2279
2280 static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2281 {
2282         struct alc_spec *spec = codec->spec;
2283
2284         spec->autocfg.hp_pins[0] = 0x15;
2285         spec->autocfg.speaker_pins[0] = 0x14;
2286         spec->autocfg.speaker_pins[1] = 0x16;
2287         spec->autocfg.speaker_pins[2] = 0x17;
2288 }
2289
2290 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2291 {
2292         struct alc_spec *spec = codec->spec;
2293
2294         spec->autocfg.hp_pins[0] = 0x15;
2295         spec->autocfg.speaker_pins[0] = 0x14;
2296         spec->autocfg.speaker_pins[1] = 0x16;
2297         spec->autocfg.speaker_pins[2] = 0x1b;
2298 }
2299
2300 /*
2301  * ALC880 3-stack model
2302  *
2303  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2304  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2305  *                 F-Mic = 0x1b, HP = 0x19
2306  */
2307
2308 static hda_nid_t alc880_dac_nids[4] = {
2309         /* front, rear, clfe, rear_surr */
2310         0x02, 0x05, 0x04, 0x03
2311 };
2312
2313 static hda_nid_t alc880_adc_nids[3] = {
2314         /* ADC0-2 */
2315         0x07, 0x08, 0x09,
2316 };
2317
2318 /* The datasheet says the node 0x07 is connected from inputs,
2319  * but it shows zero connection in the real implementation on some devices.
2320  * Note: this is a 915GAV bug, fixed on 915GLV
2321  */
2322 static hda_nid_t alc880_adc_nids_alt[2] = {
2323         /* ADC1-2 */
2324         0x08, 0x09,
2325 };
2326
2327 #define ALC880_DIGOUT_NID       0x06
2328 #define ALC880_DIGIN_NID        0x0a
2329
2330 static struct hda_input_mux alc880_capture_source = {
2331         .num_items = 4,
2332         .items = {
2333                 { "Mic", 0x0 },
2334                 { "Front Mic", 0x3 },
2335                 { "Line", 0x2 },
2336                 { "CD", 0x4 },
2337         },
2338 };
2339
2340 /* channel source setting (2/6 channel selection for 3-stack) */
2341 /* 2ch mode */
2342 static struct hda_verb alc880_threestack_ch2_init[] = {
2343         /* set line-in to input, mute it */
2344         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2345         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2346         /* set mic-in to input vref 80%, mute it */
2347         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2348         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2349         { } /* end */
2350 };
2351
2352 /* 6ch mode */
2353 static struct hda_verb alc880_threestack_ch6_init[] = {
2354         /* set line-in to output, unmute it */
2355         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2356         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2357         /* set mic-in to output, unmute it */
2358         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2359         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2360         { } /* end */
2361 };
2362
2363 static struct hda_channel_mode alc880_threestack_modes[2] = {
2364         { 2, alc880_threestack_ch2_init },
2365         { 6, alc880_threestack_ch6_init },
2366 };
2367
2368 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2369         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2370         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2371         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2372         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2373         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2374         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2375         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2376         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2377         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2378         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2379         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2380         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2381         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2382         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2383         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2384         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2385         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2386         {
2387                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2388                 .name = "Channel Mode",
2389                 .info = alc_ch_mode_info,
2390                 .get = alc_ch_mode_get,
2391                 .put = alc_ch_mode_put,
2392         },
2393         { } /* end */
2394 };
2395
2396 /* capture mixer elements */
2397 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2398                             struct snd_ctl_elem_info *uinfo)
2399 {
2400         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2401         struct alc_spec *spec = codec->spec;
2402         int err;
2403
2404         mutex_lock(&codec->control_mutex);
2405         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2406                                                       HDA_INPUT);
2407         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2408         mutex_unlock(&codec->control_mutex);
2409         return err;
2410 }
2411
2412 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2413                            unsigned int size, unsigned int __user *tlv)
2414 {
2415         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2416         struct alc_spec *spec = codec->spec;
2417         int err;
2418
2419         mutex_lock(&codec->control_mutex);
2420         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2421                                                       HDA_INPUT);
2422         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2423         mutex_unlock(&codec->control_mutex);
2424         return err;
2425 }
2426
2427 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2428                              struct snd_ctl_elem_value *ucontrol);
2429
2430 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2431                                  struct snd_ctl_elem_value *ucontrol,
2432                                  getput_call_t func)
2433 {
2434         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2435         struct alc_spec *spec = codec->spec;
2436         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2437         int err;
2438
2439         mutex_lock(&codec->control_mutex);
2440         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2441                                                       3, 0, HDA_INPUT);
2442         err = func(kcontrol, ucontrol);
2443         mutex_unlock(&codec->control_mutex);
2444         return err;
2445 }
2446
2447 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2448                            struct snd_ctl_elem_value *ucontrol)
2449 {
2450         return alc_cap_getput_caller(kcontrol, ucontrol,
2451                                      snd_hda_mixer_amp_volume_get);
2452 }
2453
2454 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2455                            struct snd_ctl_elem_value *ucontrol)
2456 {
2457         return alc_cap_getput_caller(kcontrol, ucontrol,
2458                                      snd_hda_mixer_amp_volume_put);
2459 }
2460
2461 /* capture mixer elements */
2462 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2463
2464 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2465                           struct snd_ctl_elem_value *ucontrol)
2466 {
2467         return alc_cap_getput_caller(kcontrol, ucontrol,
2468                                      snd_hda_mixer_amp_switch_get);
2469 }
2470
2471 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2472                           struct snd_ctl_elem_value *ucontrol)
2473 {
2474         return alc_cap_getput_caller(kcontrol, ucontrol,
2475                                      snd_hda_mixer_amp_switch_put);
2476 }
2477
2478 #define _DEFINE_CAPMIX(num) \
2479         { \
2480                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2481                 .name = "Capture Switch", \
2482                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2483                 .count = num, \
2484                 .info = alc_cap_sw_info, \
2485                 .get = alc_cap_sw_get, \
2486                 .put = alc_cap_sw_put, \
2487         }, \
2488         { \
2489                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2490                 .name = "Capture Volume", \
2491                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2492                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2493                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2494                 .count = num, \
2495                 .info = alc_cap_vol_info, \
2496                 .get = alc_cap_vol_get, \
2497                 .put = alc_cap_vol_put, \
2498                 .tlv = { .c = alc_cap_vol_tlv }, \
2499         }
2500
2501 #define _DEFINE_CAPSRC(num) \
2502         { \
2503                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2504                 /* .name = "Capture Source", */ \
2505                 .name = "Input Source", \
2506                 .count = num, \
2507                 .info = alc_mux_enum_info, \
2508                 .get = alc_mux_enum_get, \
2509                 .put = alc_mux_enum_put, \
2510         }
2511
2512 #define DEFINE_CAPMIX(num) \
2513 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2514         _DEFINE_CAPMIX(num),                                  \
2515         _DEFINE_CAPSRC(num),                                  \
2516         { } /* end */                                         \
2517 }
2518
2519 #define DEFINE_CAPMIX_NOSRC(num) \
2520 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2521         _DEFINE_CAPMIX(num),                                        \
2522         { } /* end */                                               \
2523 }
2524
2525 /* up to three ADCs */
2526 DEFINE_CAPMIX(1);
2527 DEFINE_CAPMIX(2);
2528 DEFINE_CAPMIX(3);
2529 DEFINE_CAPMIX_NOSRC(1);
2530 DEFINE_CAPMIX_NOSRC(2);
2531 DEFINE_CAPMIX_NOSRC(3);
2532
2533 /*
2534  * ALC880 5-stack model
2535  *
2536  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2537  *      Side = 0x02 (0xd)
2538  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2539  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2540  */
2541
2542 /* additional mixers to alc880_three_stack_mixer */
2543 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2544         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2545         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2546         { } /* end */
2547 };
2548
2549 /* channel source setting (6/8 channel selection for 5-stack) */
2550 /* 6ch mode */
2551 static struct hda_verb alc880_fivestack_ch6_init[] = {
2552         /* set line-in to input, mute it */
2553         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2554         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2555         { } /* end */
2556 };
2557
2558 /* 8ch mode */
2559 static struct hda_verb alc880_fivestack_ch8_init[] = {
2560         /* set line-in to output, unmute it */
2561         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2562         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2563         { } /* end */
2564 };
2565
2566 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2567         { 6, alc880_fivestack_ch6_init },
2568         { 8, alc880_fivestack_ch8_init },
2569 };
2570
2571
2572 /*
2573  * ALC880 6-stack model
2574  *
2575  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2576  *      Side = 0x05 (0x0f)
2577  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2578  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2579  */
2580
2581 static hda_nid_t alc880_6st_dac_nids[4] = {
2582         /* front, rear, clfe, rear_surr */
2583         0x02, 0x03, 0x04, 0x05
2584 };
2585
2586 static struct hda_input_mux alc880_6stack_capture_source = {
2587         .num_items = 4,
2588         .items = {
2589                 { "Mic", 0x0 },
2590                 { "Front Mic", 0x1 },
2591                 { "Line", 0x2 },
2592                 { "CD", 0x4 },
2593         },
2594 };
2595
2596 /* fixed 8-channels */
2597 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2598         { 8, NULL },
2599 };
2600
2601 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2602         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2603         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2604         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2605         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2606         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2607         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2608         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2609         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2610         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2611         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2612         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2613         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2614         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2615         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2616         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2617         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2618         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2619         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2620         {
2621                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2622                 .name = "Channel Mode",
2623                 .info = alc_ch_mode_info,
2624                 .get = alc_ch_mode_get,
2625                 .put = alc_ch_mode_put,
2626         },
2627         { } /* end */
2628 };
2629
2630
2631 /*
2632  * ALC880 W810 model
2633  *
2634  * W810 has rear IO for:
2635  * Front (DAC 02)
2636  * Surround (DAC 03)
2637  * Center/LFE (DAC 04)
2638  * Digital out (06)
2639  *
2640  * The system also has a pair of internal speakers, and a headphone jack.
2641  * These are both connected to Line2 on the codec, hence to DAC 02.
2642  *
2643  * There is a variable resistor to control the speaker or headphone
2644  * volume. This is a hardware-only device without a software API.
2645  *
2646  * Plugging headphones in will disable the internal speakers. This is
2647  * implemented in hardware, not via the driver using jack sense. In
2648  * a similar fashion, plugging into the rear socket marked "front" will
2649  * disable both the speakers and headphones.
2650  *
2651  * For input, there's a microphone jack, and an "audio in" jack.
2652  * These may not do anything useful with this driver yet, because I
2653  * haven't setup any initialization verbs for these yet...
2654  */
2655
2656 static hda_nid_t alc880_w810_dac_nids[3] = {
2657         /* front, rear/surround, clfe */
2658         0x02, 0x03, 0x04
2659 };
2660
2661 /* fixed 6 channels */
2662 static struct hda_channel_mode alc880_w810_modes[1] = {
2663         { 6, NULL }
2664 };
2665
2666 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2667 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2668         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2669         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2670         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2671         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2672         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2673         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2674         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2675         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2676         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2677         { } /* end */
2678 };
2679
2680
2681 /*
2682  * Z710V model
2683  *
2684  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2685  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2686  *                 Line = 0x1a
2687  */
2688
2689 static hda_nid_t alc880_z71v_dac_nids[1] = {
2690         0x02
2691 };
2692 #define ALC880_Z71V_HP_DAC      0x03
2693
2694 /* fixed 2 channels */
2695 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2696         { 2, NULL }
2697 };
2698
2699 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2700         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2701         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2702         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2703         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2704         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2705         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2706         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2707         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2708         { } /* end */
2709 };
2710
2711
2712 /*
2713  * ALC880 F1734 model
2714  *
2715  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2716  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2717  */
2718
2719 static hda_nid_t alc880_f1734_dac_nids[1] = {
2720         0x03
2721 };
2722 #define ALC880_F1734_HP_DAC     0x02
2723
2724 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2725         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2726         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2727         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2728         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2729         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2730         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2731         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2732         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2733         { } /* end */
2734 };
2735
2736 static struct hda_input_mux alc880_f1734_capture_source = {
2737         .num_items = 2,
2738         .items = {
2739                 { "Mic", 0x1 },
2740                 { "CD", 0x4 },
2741         },
2742 };
2743
2744
2745 /*
2746  * ALC880 ASUS model
2747  *
2748  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2749  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2750  *  Mic = 0x18, Line = 0x1a
2751  */
2752
2753 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2754 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2755
2756 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2757         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2758         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2759         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2760         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2761         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2762         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2763         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2764         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2765         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2766         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2767         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2768         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2769         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2770         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2771         {
2772                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2773                 .name = "Channel Mode",
2774                 .info = alc_ch_mode_info,
2775                 .get = alc_ch_mode_get,
2776                 .put = alc_ch_mode_put,
2777         },
2778         { } /* end */
2779 };
2780
2781 /*
2782  * ALC880 ASUS W1V model
2783  *
2784  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2785  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2786  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2787  */
2788
2789 /* additional mixers to alc880_asus_mixer */
2790 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2791         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2792         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2793         { } /* end */
2794 };
2795
2796 /* TCL S700 */
2797 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2798         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2799         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2800         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2801         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2802         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2803         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2805         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2806         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2807         { } /* end */
2808 };
2809
2810 /* Uniwill */
2811 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2812         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2813         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2814         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2815         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2816         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2817         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2818         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2819         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2820         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2821         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2822         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2823         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2824         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2825         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2826         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2827         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2828         {
2829                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2830                 .name = "Channel Mode",
2831                 .info = alc_ch_mode_info,
2832                 .get = alc_ch_mode_get,
2833                 .put = alc_ch_mode_put,
2834         },
2835         { } /* end */
2836 };
2837
2838 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2839         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2840         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2841         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2842         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2843         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2844         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2845         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2846         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2847         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2848         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2849         { } /* end */
2850 };
2851
2852 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2853         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2854         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2855         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2856         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2857         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2858         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2859         { } /* end */
2860 };
2861
2862 /*
2863  * virtual master controls
2864  */
2865
2866 /*
2867  * slave controls for virtual master
2868  */
2869 static const char *alc_slave_vols[] = {
2870         "Front Playback Volume",
2871         "Surround Playback Volume",
2872         "Center Playback Volume",
2873         "LFE Playback Volume",
2874         "Side Playback Volume",
2875         "Headphone Playback Volume",
2876         "Speaker Playback Volume",
2877         "Mono Playback Volume",
2878         "Line-Out Playback Volume",
2879         "PCM Playback Volume",
2880         NULL,
2881 };
2882
2883 static const char *alc_slave_sws[] = {
2884         "Front Playback Switch",
2885         "Surround Playback Switch",
2886         "Center Playback Switch",
2887         "LFE Playback Switch",
2888         "Side Playback Switch",
2889         "Headphone Playback Switch",
2890         "Speaker Playback Switch",
2891         "Mono Playback Switch",
2892         "IEC958 Playback Switch",
2893         "Line-Out Playback Switch",
2894         "PCM Playback Switch",
2895         NULL,
2896 };
2897
2898 /*
2899  * build control elements
2900  */
2901
2902 #define NID_MAPPING             (-1)
2903
2904 #define SUBDEV_SPEAKER_         (0 << 6)
2905 #define SUBDEV_HP_              (1 << 6)
2906 #define SUBDEV_LINE_            (2 << 6)
2907 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2908 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2909 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2910
2911 static void alc_free_kctls(struct hda_codec *codec);
2912
2913 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2914 /* additional beep mixers; the actual parameters are overwritten at build */
2915 static struct snd_kcontrol_new alc_beep_mixer[] = {
2916         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2917         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2918         { } /* end */
2919 };
2920 #endif
2921
2922 static int alc_build_controls(struct hda_codec *codec)
2923 {
2924         struct alc_spec *spec = codec->spec;
2925         struct snd_kcontrol *kctl = NULL;
2926         struct snd_kcontrol_new *knew;
2927         int i, j, err;
2928         unsigned int u;
2929         hda_nid_t nid;
2930
2931         for (i = 0; i < spec->num_mixers; i++) {
2932                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2933                 if (err < 0)
2934                         return err;
2935         }
2936         if (spec->cap_mixer) {
2937                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2938                 if (err < 0)
2939                         return err;
2940         }
2941         if (spec->multiout.dig_out_nid) {
2942                 err = snd_hda_create_spdif_out_ctls(codec,
2943                                                     spec->multiout.dig_out_nid);
2944                 if (err < 0)
2945                         return err;
2946                 if (!spec->no_analog) {
2947                         err = snd_hda_create_spdif_share_sw(codec,
2948                                                             &spec->multiout);
2949                         if (err < 0)
2950                                 return err;
2951                         spec->multiout.share_spdif = 1;
2952                 }
2953         }
2954         if (spec->dig_in_nid) {
2955                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2956                 if (err < 0)
2957                         return err;
2958         }
2959
2960 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2961         /* create beep controls if needed */
2962         if (spec->beep_amp) {
2963                 struct snd_kcontrol_new *knew;
2964                 for (knew = alc_beep_mixer; knew->name; knew++) {
2965                         struct snd_kcontrol *kctl;
2966                         kctl = snd_ctl_new1(knew, codec);
2967                         if (!kctl)
2968                                 return -ENOMEM;
2969                         kctl->private_value = spec->beep_amp;
2970                         err = snd_hda_ctl_add(codec, 0, kctl);
2971                         if (err < 0)
2972                                 return err;
2973                 }
2974         }
2975 #endif
2976
2977         /* if we have no master control, let's create it */
2978         if (!spec->no_analog &&
2979             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2980                 unsigned int vmaster_tlv[4];
2981                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2982                                         HDA_OUTPUT, vmaster_tlv);
2983                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2984                                           vmaster_tlv, alc_slave_vols);
2985                 if (err < 0)
2986                         return err;
2987         }
2988         if (!spec->no_analog &&
2989             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2990                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2991                                           NULL, alc_slave_sws);
2992                 if (err < 0)
2993                         return err;
2994         }
2995
2996         /* assign Capture Source enums to NID */
2997         if (spec->capsrc_nids || spec->adc_nids) {
2998                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2999                 if (!kctl)
3000                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3001                 for (i = 0; kctl && i < kctl->count; i++) {
3002                         hda_nid_t *nids = spec->capsrc_nids;
3003                         if (!nids)
3004                                 nids = spec->adc_nids;
3005                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3006                         if (err < 0)
3007                                 return err;
3008                 }
3009         }
3010         if (spec->cap_mixer) {
3011                 const char *kname = kctl ? kctl->id.name : NULL;
3012                 for (knew = spec->cap_mixer; knew->name; knew++) {
3013                         if (kname && strcmp(knew->name, kname) == 0)
3014                                 continue;
3015                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3016                         for (i = 0; kctl && i < kctl->count; i++) {
3017                                 err = snd_hda_add_nid(codec, kctl, i,
3018                                                       spec->adc_nids[i]);
3019                                 if (err < 0)
3020                                         return err;
3021                         }
3022                 }
3023         }
3024
3025         /* other nid->control mapping */
3026         for (i = 0; i < spec->num_mixers; i++) {
3027                 for (knew = spec->mixers[i]; knew->name; knew++) {
3028                         if (knew->iface != NID_MAPPING)
3029                                 continue;
3030                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3031                         if (kctl == NULL)
3032                                 continue;
3033                         u = knew->subdevice;
3034                         for (j = 0; j < 4; j++, u >>= 8) {
3035                                 nid = u & 0x3f;
3036                                 if (nid == 0)
3037                                         continue;
3038                                 switch (u & 0xc0) {
3039                                 case SUBDEV_SPEAKER_:
3040                                         nid = spec->autocfg.speaker_pins[nid];
3041                                         break;
3042                                 case SUBDEV_LINE_:
3043                                         nid = spec->autocfg.line_out_pins[nid];
3044                                         break;
3045                                 case SUBDEV_HP_:
3046                                         nid = spec->autocfg.hp_pins[nid];
3047                                         break;
3048                                 default:
3049                                         continue;
3050                                 }
3051                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3052                                 if (err < 0)
3053                                         return err;
3054                         }
3055                         u = knew->private_value;
3056                         for (j = 0; j < 4; j++, u >>= 8) {
3057                                 nid = u & 0xff;
3058                                 if (nid == 0)
3059                                         continue;
3060                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
3061                                 if (err < 0)
3062                                         return err;
3063                         }
3064                 }
3065         }
3066
3067         alc_free_kctls(codec); /* no longer needed */
3068
3069         return 0;
3070 }
3071
3072
3073 /*
3074  * initialize the codec volumes, etc
3075  */
3076
3077 /*
3078  * generic initialization of ADC, input mixers and output mixers
3079  */
3080 static struct hda_verb alc880_volume_init_verbs[] = {
3081         /*
3082          * Unmute ADC0-2 and set the default input to mic-in
3083          */
3084         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3085         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3086         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3087         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3088         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3089         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3090
3091         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3092          * mixer widget
3093          * Note: PASD motherboards uses the Line In 2 as the input for front
3094          * panel mic (mic 2)
3095          */
3096         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3097         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3098         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3099         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3101         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3102         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3103         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3104
3105         /*
3106          * Set up output mixers (0x0c - 0x0f)
3107          */
3108         /* set vol=0 to output mixers */
3109         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3110         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3111         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3112         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3113         /* set up input amps for analog loopback */
3114         /* Amp Indices: DAC = 0, mixer = 1 */
3115         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3116         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3117         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3118         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3119         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3120         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3121         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3122         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3123
3124         { }
3125 };
3126
3127 /*
3128  * 3-stack pin configuration:
3129  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3130  */
3131 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3132         /*
3133          * preset connection lists of input pins
3134          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3135          */
3136         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3137         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3138         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3139
3140         /*
3141          * Set pin mode and muting
3142          */
3143         /* set front pin widgets 0x14 for output */
3144         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3145         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3146         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3147         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3148         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3149         /* Mic2 (as headphone out) for HP output */
3150         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3151         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3152         /* Line In pin widget for input */
3153         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3154         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3155         /* Line2 (as front mic) pin widget for input and vref at 80% */
3156         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3157         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3158         /* CD pin widget for input */
3159         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3160
3161         { }
3162 };
3163
3164 /*
3165  * 5-stack pin configuration:
3166  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3167  * line-in/side = 0x1a, f-mic = 0x1b
3168  */
3169 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3170         /*
3171          * preset connection lists of input pins
3172          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3173          */
3174         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3175         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3176
3177         /*
3178          * Set pin mode and muting
3179          */
3180         /* set pin widgets 0x14-0x17 for output */
3181         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3182         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3183         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3184         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3185         /* unmute pins for output (no gain on this amp) */
3186         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3187         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3188         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3190
3191         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3192         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3193         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3194         /* Mic2 (as headphone out) for HP output */
3195         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3196         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3197         /* Line In pin widget for input */
3198         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3199         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3200         /* Line2 (as front mic) pin widget for input and vref at 80% */
3201         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3202         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3203         /* CD pin widget for input */
3204         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3205
3206         { }
3207 };
3208
3209 /*
3210  * W810 pin configuration:
3211  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3212  */
3213 static struct hda_verb alc880_pin_w810_init_verbs[] = {
3214         /* hphone/speaker input selector: front DAC */
3215         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3216
3217         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3218         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3219         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3220         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3221         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3222         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3223
3224         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3225         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3226
3227         { }
3228 };
3229
3230 /*
3231  * Z71V pin configuration:
3232  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3233  */
3234 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3235         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3236         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3237         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3238         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3239
3240         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3241         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3242         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3243         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3244
3245         { }
3246 };
3247
3248 /*
3249  * 6-stack pin configuration:
3250  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3251  * f-mic = 0x19, line = 0x1a, HP = 0x1b
3252  */
3253 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3254         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3255
3256         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3257         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3258         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3259         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3260         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3261         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3262         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3263         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3264
3265         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3266         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3267         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3268         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3269         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3270         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3271         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3272         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3273         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3274
3275         { }
3276 };
3277
3278 /*
3279  * Uniwill pin configuration:
3280  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3281  * line = 0x1a
3282  */
3283 static struct hda_verb alc880_uniwill_init_verbs[] = {
3284         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3285
3286         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3287         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3288         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3289         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3290         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3291         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3292         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3293         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3294         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3295         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3296         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3297         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3298         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3299         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3300
3301         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3302         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3303         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3304         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3305         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3306         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3307         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3308         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3309         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3310
3311         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3312         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3313
3314         { }
3315 };
3316
3317 /*
3318 * Uniwill P53
3319 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3320  */
3321 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3322         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3323
3324         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3325         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3326         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3327         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3328         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3329         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3330         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3331         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3332         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3333         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3334         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3335         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3336
3337         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3338         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3339         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3340         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3341         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3342         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3343
3344         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3345         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3346
3347         { }
3348 };
3349
3350 static struct hda_verb alc880_beep_init_verbs[] = {
3351         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3352         { }
3353 };
3354
3355 /* auto-toggle front mic */
3356 static void alc88x_simple_mic_automute(struct hda_codec *codec)
3357 {
3358         unsigned int present;
3359         unsigned char bits;
3360
3361         present = snd_hda_jack_detect(codec, 0x18);
3362         bits = present ? HDA_AMP_MUTE : 0;
3363         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3364 }
3365
3366 static void alc880_uniwill_setup(struct hda_codec *codec)
3367 {
3368         struct alc_spec *spec = codec->spec;
3369
3370         spec->autocfg.hp_pins[0] = 0x14;
3371         spec->autocfg.speaker_pins[0] = 0x15;
3372         spec->autocfg.speaker_pins[0] = 0x16;
3373 }
3374
3375 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3376 {
3377         alc_automute_amp(codec);
3378         alc88x_simple_mic_automute(codec);
3379 }
3380
3381 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3382                                        unsigned int res)
3383 {
3384         /* Looks like the unsol event is incompatible with the standard
3385          * definition.  4bit tag is placed at 28 bit!
3386          */
3387         switch (res >> 28) {
3388         case ALC880_MIC_EVENT:
3389                 alc88x_simple_mic_automute(codec);
3390                 break;
3391         default:
3392                 alc_automute_amp_unsol_event(codec, res);
3393                 break;
3394         }
3395 }
3396
3397 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3398 {
3399         struct alc_spec *spec = codec->spec;
3400
3401         spec->autocfg.hp_pins[0] = 0x14;
3402         spec->autocfg.speaker_pins[0] = 0x15;
3403 }
3404
3405 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3406 {
3407         unsigned int present;
3408
3409         present = snd_hda_codec_read(codec, 0x21, 0,
3410                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3411         present &= HDA_AMP_VOLMASK;
3412         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3413                                  HDA_AMP_VOLMASK, present);
3414         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3415                                  HDA_AMP_VOLMASK, present);
3416 }
3417
3418 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3419                                            unsigned int res)
3420 {
3421         /* Looks like the unsol event is incompatible with the standard
3422          * definition.  4bit tag is placed at 28 bit!
3423          */
3424         if ((res >> 28) == ALC880_DCVOL_EVENT)
3425                 alc880_uniwill_p53_dcvol_automute(codec);
3426         else
3427                 alc_automute_amp_unsol_event(codec, res);
3428 }
3429
3430 /*
3431  * F1734 pin configuration:
3432  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3433  */
3434 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3435         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3436         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3437         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3438         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3439         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3440
3441         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3442         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3443         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3444         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3445
3446         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3447         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3448         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3449         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3450         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3451         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3452         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3453         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3454         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3455
3456         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3457         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3458
3459         { }
3460 };
3461
3462 /*
3463  * ASUS pin configuration:
3464  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3465  */
3466 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3467         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3468         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3469         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3470         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3471
3472         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3473         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3474         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3475         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3476         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3477         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3478         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3479         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3480
3481         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3482         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3483         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3484         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3485         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3486         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3487         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3488         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3489         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3490
3491         { }
3492 };
3493
3494 /* Enable GPIO mask and set output */
3495 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3496 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3497 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3498
3499 /* Clevo m520g init */
3500 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3501         /* headphone output */
3502         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3503         /* line-out */
3504         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3505         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3506         /* Line-in */
3507         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3508         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3509         /* CD */
3510         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3511         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3512         /* Mic1 (rear panel) */
3513         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3514         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3515         /* Mic2 (front panel) */
3516         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3517         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3518         /* headphone */
3519         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3520         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3521         /* change to EAPD mode */
3522         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3523         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3524
3525         { }
3526 };
3527
3528 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3529         /* change to EAPD mode */
3530         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3531         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3532
3533         /* Headphone output */
3534         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3535         /* Front output*/
3536         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3537         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3538
3539         /* Line In pin widget for input */
3540         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3541         /* CD pin widget for input */
3542         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3543         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3544         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3545
3546         /* change to EAPD mode */
3547         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3548         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3549
3550         { }
3551 };
3552
3553 /*
3554  * LG m1 express dual
3555  *
3556  * Pin assignment:
3557  *   Rear Line-In/Out (blue): 0x14
3558  *   Build-in Mic-In: 0x15
3559  *   Speaker-out: 0x17
3560  *   HP-Out (green): 0x1b
3561  *   Mic-In/Out (red): 0x19
3562  *   SPDIF-Out: 0x1e
3563  */
3564
3565 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3566 static hda_nid_t alc880_lg_dac_nids[3] = {
3567         0x05, 0x02, 0x03
3568 };
3569
3570 /* seems analog CD is not working */
3571 static struct hda_input_mux alc880_lg_capture_source = {
3572         .num_items = 3,
3573         .items = {
3574                 { "Mic", 0x1 },
3575                 { "Line", 0x5 },
3576                 { "Internal Mic", 0x6 },
3577         },
3578 };
3579
3580 /* 2,4,6 channel modes */
3581 static struct hda_verb alc880_lg_ch2_init[] = {
3582         /* set line-in and mic-in to input */
3583         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3584         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3585         { }
3586 };
3587
3588 static struct hda_verb alc880_lg_ch4_init[] = {
3589         /* set line-in to out and mic-in to input */
3590         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3591         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3592         { }
3593 };
3594
3595 static struct hda_verb alc880_lg_ch6_init[] = {
3596         /* set line-in and mic-in to output */
3597         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3598         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3599         { }
3600 };
3601
3602 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3603         { 2, alc880_lg_ch2_init },
3604         { 4, alc880_lg_ch4_init },
3605         { 6, alc880_lg_ch6_init },
3606 };
3607
3608 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3609         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3610         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3611         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3612         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3613         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3614         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3615         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3616         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3617         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3618         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3619         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3620         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3621         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3622         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3623         {
3624                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3625                 .name = "Channel Mode",
3626                 .info = alc_ch_mode_info,
3627                 .get = alc_ch_mode_get,
3628                 .put = alc_ch_mode_put,
3629         },
3630         { } /* end */
3631 };
3632
3633 static struct hda_verb alc880_lg_init_verbs[] = {
3634         /* set capture source to mic-in */
3635         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3636         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3637         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3638         /* mute all amp mixer inputs */
3639         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3641         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3642         /* line-in to input */
3643         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3644         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3645         /* built-in mic */
3646         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3647         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3648         /* speaker-out */
3649         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3650         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3651         /* mic-in to input */
3652         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3653         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3654         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3655         /* HP-out */
3656         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3657         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3658         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3659         /* jack sense */
3660         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3661         { }
3662 };
3663
3664 /* toggle speaker-output according to the hp-jack state */
3665 static void alc880_lg_setup(struct hda_codec *codec)
3666 {
3667         struct alc_spec *spec = codec->spec;
3668
3669         spec->autocfg.hp_pins[0] = 0x1b;
3670         spec->autocfg.speaker_pins[0] = 0x17;
3671 }
3672
3673 /*
3674  * LG LW20
3675  *
3676  * Pin assignment:
3677  *   Speaker-out: 0x14
3678  *   Mic-In: 0x18
3679  *   Built-in Mic-In: 0x19
3680  *   Line-In: 0x1b
3681  *   HP-Out: 0x1a
3682  *   SPDIF-Out: 0x1e
3683  */
3684
3685 static struct hda_input_mux alc880_lg_lw_capture_source = {
3686         .num_items = 3,
3687         .items = {
3688                 { "Mic", 0x0 },
3689                 { "Internal Mic", 0x1 },
3690                 { "Line In", 0x2 },
3691         },
3692 };
3693
3694 #define alc880_lg_lw_modes alc880_threestack_modes
3695
3696 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3697         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3698         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3699         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3700         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3701         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3702         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3703         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3704         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3705         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3706         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3707         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3708         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3709         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3710         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3711         {
3712                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3713                 .name = "Channel Mode",
3714                 .info = alc_ch_mode_info,
3715                 .get = alc_ch_mode_get,
3716                 .put = alc_ch_mode_put,
3717         },
3718         { } /* end */
3719 };
3720
3721 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3722         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3723         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3724         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3725
3726         /* set capture source to mic-in */
3727         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3728         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3729         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3730         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3731         /* speaker-out */
3732         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3733         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3734         /* HP-out */
3735         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3736         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3737         /* mic-in to input */
3738         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3739         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3740         /* built-in mic */
3741         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3742         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3743         /* jack sense */
3744         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3745         { }
3746 };
3747
3748 /* toggle speaker-output according to the hp-jack state */
3749 static void alc880_lg_lw_setup(struct hda_codec *codec)
3750 {
3751         struct alc_spec *spec = codec->spec;
3752
3753         spec->autocfg.hp_pins[0] = 0x1b;
3754         spec->autocfg.speaker_pins[0] = 0x14;
3755 }
3756
3757 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3758         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3759         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3761         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3762         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3763         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3764         { } /* end */
3765 };
3766
3767 static struct hda_input_mux alc880_medion_rim_capture_source = {
3768         .num_items = 2,
3769         .items = {
3770                 { "Mic", 0x0 },
3771                 { "Internal Mic", 0x1 },
3772         },
3773 };
3774
3775 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3776         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3777
3778         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3779         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3780
3781         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3782         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3783         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3784         /* Mic2 (as headphone out) for HP output */
3785         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3786         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3787         /* Internal Speaker */
3788         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3789         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3790
3791         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3792         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3793
3794         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3795         { }
3796 };
3797
3798 /* toggle speaker-output according to the hp-jack state */
3799 static void alc880_medion_rim_automute(struct hda_codec *codec)
3800 {
3801         struct alc_spec *spec = codec->spec;
3802         alc_automute_amp(codec);
3803         /* toggle EAPD */
3804         if (spec->jack_present)
3805                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3806         else
3807                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3808 }
3809
3810 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3811                                           unsigned int res)
3812 {
3813         /* Looks like the unsol event is incompatible with the standard
3814          * definition.  4bit tag is placed at 28 bit!
3815          */
3816         if ((res >> 28) == ALC880_HP_EVENT)
3817                 alc880_medion_rim_automute(codec);
3818 }
3819
3820 static void alc880_medion_rim_setup(struct hda_codec *codec)
3821 {
3822         struct alc_spec *spec = codec->spec;
3823
3824         spec->autocfg.hp_pins[0] = 0x14;
3825         spec->autocfg.speaker_pins[0] = 0x1b;
3826 }
3827
3828 #ifdef CONFIG_SND_HDA_POWER_SAVE
3829 static struct hda_amp_list alc880_loopbacks[] = {
3830         { 0x0b, HDA_INPUT, 0 },
3831         { 0x0b, HDA_INPUT, 1 },
3832         { 0x0b, HDA_INPUT, 2 },
3833         { 0x0b, HDA_INPUT, 3 },
3834         { 0x0b, HDA_INPUT, 4 },
3835         { } /* end */
3836 };
3837
3838 static struct hda_amp_list alc880_lg_loopbacks[] = {
3839         { 0x0b, HDA_INPUT, 1 },
3840         { 0x0b, HDA_INPUT, 6 },
3841         { 0x0b, HDA_INPUT, 7 },
3842         { } /* end */
3843 };
3844 #endif
3845
3846 /*
3847  * Common callbacks
3848  */
3849
3850 static int alc_init(struct hda_codec *codec)
3851 {
3852         struct alc_spec *spec = codec->spec;
3853         unsigned int i;
3854
3855         alc_fix_pll(codec);
3856         alc_auto_init_amp(codec, spec->init_amp);
3857
3858         for (i = 0; i < spec->num_init_verbs; i++)
3859                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3860
3861         if (spec->init_hook)
3862                 spec->init_hook(codec);
3863
3864         hda_call_check_power_status(codec, 0x01);
3865         return 0;
3866 }
3867
3868 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3869 {
3870         struct alc_spec *spec = codec->spec;
3871
3872         if (spec->unsol_event)
3873                 spec->unsol_event(codec, res);
3874 }
3875
3876 #ifdef CONFIG_SND_HDA_POWER_SAVE
3877 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3878 {
3879         struct alc_spec *spec = codec->spec;
3880         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3881 }
3882 #endif
3883
3884 /*
3885  * Analog playback callbacks
3886  */
3887 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3888                                     struct hda_codec *codec,
3889                                     struct snd_pcm_substream *substream)
3890 {
3891         struct alc_spec *spec = codec->spec;
3892         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3893                                              hinfo);
3894 }
3895
3896 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3897                                        struct hda_codec *codec,
3898                                        unsigned int stream_tag,
3899                                        unsigned int format,
3900                                        struct snd_pcm_substream *substream)
3901 {
3902         struct alc_spec *spec = codec->spec;
3903         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3904                                                 stream_tag, format, substream);
3905 }
3906
3907 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3908                                        struct hda_codec *codec,
3909                                        struct snd_pcm_substream *substream)
3910 {
3911         struct alc_spec *spec = codec->spec;
3912         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3913 }
3914
3915 /*
3916  * Digital out
3917  */
3918 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3919                                         struct hda_codec *codec,
3920                                         struct snd_pcm_substream *substream)
3921 {
3922         struct alc_spec *spec = codec->spec;
3923         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3924 }
3925
3926 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3927                                            struct hda_codec *codec,
3928                                            unsigned int stream_tag,
3929                                            unsigned int format,
3930                                            struct snd_pcm_substream *substream)
3931 {
3932         struct alc_spec *spec = codec->spec;
3933         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3934                                              stream_tag, format, substream);
3935 }
3936
3937 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3938                                            struct hda_codec *codec,
3939                                            struct snd_pcm_substream *substream)
3940 {
3941         struct alc_spec *spec = codec->spec;
3942         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3943 }
3944
3945 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3946                                          struct hda_codec *codec,
3947                                          struct snd_pcm_substream *substream)
3948 {
3949         struct alc_spec *spec = codec->spec;
3950         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3951 }
3952
3953 /*
3954  * Analog capture
3955  */
3956 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3957                                       struct hda_codec *codec,
3958                                       unsigned int stream_tag,
3959                                       unsigned int format,
3960                                       struct snd_pcm_substream *substream)
3961 {
3962         struct alc_spec *spec = codec->spec;
3963
3964         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3965                                    stream_tag, 0, format);
3966         return 0;
3967 }
3968
3969 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3970                                       struct hda_codec *codec,
3971                                       struct snd_pcm_substream *substream)
3972 {
3973         struct alc_spec *spec = codec->spec;
3974
3975         snd_hda_codec_cleanup_stream(codec,
3976                                      spec->adc_nids[substream->number + 1]);
3977         return 0;
3978 }
3979
3980 /* analog capture with dynamic dual-adc changes */
3981 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3982                                        struct hda_codec *codec,
3983                                        unsigned int stream_tag,
3984                                        unsigned int format,
3985                                        struct snd_pcm_substream *substream)
3986 {
3987         struct alc_spec *spec = codec->spec;
3988         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3989         spec->cur_adc_stream_tag = stream_tag;
3990         spec->cur_adc_format = format;
3991         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3992         return 0;
3993 }
3994
3995 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3996                                        struct hda_codec *codec,
3997                                        struct snd_pcm_substream *substream)
3998 {
3999         struct alc_spec *spec = codec->spec;
4000         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4001         spec->cur_adc = 0;
4002         return 0;
4003 }
4004
4005 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
4006         .substreams = 1,
4007         .channels_min = 2,
4008         .channels_max = 2,
4009         .nid = 0, /* fill later */
4010         .ops = {
4011                 .prepare = dualmic_capture_pcm_prepare,
4012                 .cleanup = dualmic_capture_pcm_cleanup
4013         },
4014 };
4015
4016 /*
4017  */
4018 static struct hda_pcm_stream alc880_pcm_analog_playback = {
4019         .substreams = 1,
4020         .channels_min = 2,
4021         .channels_max = 8,
4022         /* NID is set in alc_build_pcms */
4023         .ops = {
4024                 .open = alc880_playback_pcm_open,
4025                 .prepare = alc880_playback_pcm_prepare,
4026                 .cleanup = alc880_playback_pcm_cleanup
4027         },
4028 };
4029
4030 static struct hda_pcm_stream alc880_pcm_analog_capture = {
4031         .substreams = 1,
4032         .channels_min = 2,
4033         .channels_max = 2,
4034         /* NID is set in alc_build_pcms */
4035 };
4036
4037 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4038         .substreams = 1,
4039         .channels_min = 2,
4040         .channels_max = 2,
4041         /* NID is set in alc_build_pcms */
4042 };
4043
4044 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4045         .substreams = 2, /* can be overridden */
4046         .channels_min = 2,
4047         .channels_max = 2,
4048         /* NID is set in alc_build_pcms */
4049         .ops = {
4050                 .prepare = alc880_alt_capture_pcm_prepare,
4051                 .cleanup = alc880_alt_capture_pcm_cleanup
4052         },
4053 };
4054
4055 static struct hda_pcm_stream alc880_pcm_digital_playback = {
4056         .substreams = 1,
4057         .channels_min = 2,
4058         .channels_max = 2,
4059         /* NID is set in alc_build_pcms */
4060         .ops = {
4061                 .open = alc880_dig_playback_pcm_open,
4062                 .close = alc880_dig_playback_pcm_close,
4063                 .prepare = alc880_dig_playback_pcm_prepare,
4064                 .cleanup = alc880_dig_playback_pcm_cleanup
4065         },
4066 };
4067
4068 static struct hda_pcm_stream alc880_pcm_digital_capture = {
4069         .substreams = 1,
4070         .channels_min = 2,
4071         .channels_max = 2,
4072         /* NID is set in alc_build_pcms */
4073 };
4074
4075 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
4076 static struct hda_pcm_stream alc_pcm_null_stream = {
4077         .substreams = 0,
4078         .channels_min = 0,
4079         .channels_max = 0,
4080 };
4081
4082 static int alc_build_pcms(struct hda_codec *codec)
4083 {
4084         struct alc_spec *spec = codec->spec;
4085         struct hda_pcm *info = spec->pcm_rec;
4086         int i;
4087
4088         codec->num_pcms = 1;
4089         codec->pcm_info = info;
4090
4091         if (spec->no_analog)
4092                 goto skip_analog;
4093
4094         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4095                  "%s Analog", codec->chip_name);
4096         info->name = spec->stream_name_analog;
4097
4098         if (spec->stream_analog_playback) {
4099                 if (snd_BUG_ON(!spec->multiout.dac_nids))
4100                         return -EINVAL;
4101                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4102                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4103         }
4104         if (spec->stream_analog_capture) {
4105                 if (snd_BUG_ON(!spec->adc_nids))
4106                         return -EINVAL;
4107                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4108                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4109         }
4110
4111         if (spec->channel_mode) {
4112                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4113                 for (i = 0; i < spec->num_channel_mode; i++) {
4114                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4115                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4116                         }
4117                 }
4118         }
4119
4120  skip_analog:
4121         /* SPDIF for stream index #1 */
4122         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4123                 snprintf(spec->stream_name_digital,
4124                          sizeof(spec->stream_name_digital),
4125                          "%s Digital", codec->chip_name);
4126                 codec->num_pcms = 2;
4127                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4128                 info = spec->pcm_rec + 1;
4129                 info->name = spec->stream_name_digital;
4130                 if (spec->dig_out_type)
4131                         info->pcm_type = spec->dig_out_type;
4132                 else
4133                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
4134                 if (spec->multiout.dig_out_nid &&
4135                     spec->stream_digital_playback) {
4136                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4137                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4138                 }
4139                 if (spec->dig_in_nid &&
4140                     spec->stream_digital_capture) {
4141                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4142                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4143                 }
4144                 /* FIXME: do we need this for all Realtek codec models? */
4145                 codec->spdif_status_reset = 1;
4146         }
4147
4148         if (spec->no_analog)
4149                 return 0;
4150
4151         /* If the use of more than one ADC is requested for the current
4152          * model, configure a second analog capture-only PCM.
4153          */
4154         /* Additional Analaog capture for index #2 */
4155         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4156             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4157                 codec->num_pcms = 3;
4158                 info = spec->pcm_rec + 2;
4159                 info->name = spec->stream_name_analog;
4160                 if (spec->alt_dac_nid) {
4161                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4162                                 *spec->stream_analog_alt_playback;
4163                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4164                                 spec->alt_dac_nid;
4165                 } else {
4166                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4167                                 alc_pcm_null_stream;
4168                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4169                 }
4170                 if (spec->num_adc_nids > 1) {
4171                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4172                                 *spec->stream_analog_alt_capture;
4173                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4174                                 spec->adc_nids[1];
4175                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4176                                 spec->num_adc_nids - 1;
4177                 } else {
4178                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4179                                 alc_pcm_null_stream;
4180                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4181                 }
4182         }
4183
4184         return 0;
4185 }
4186
4187 static inline void alc_shutup(struct hda_codec *codec)
4188 {
4189         snd_hda_shutup_pins(codec);
4190 }
4191
4192 static void alc_free_kctls(struct hda_codec *codec)
4193 {
4194         struct alc_spec *spec = codec->spec;
4195
4196         if (spec->kctls.list) {
4197                 struct snd_kcontrol_new *kctl = spec->kctls.list;
4198                 int i;
4199                 for (i = 0; i < spec->kctls.used; i++)
4200                         kfree(kctl[i].name);
4201         }
4202         snd_array_free(&spec->kctls);
4203 }
4204
4205 static void alc_free(struct hda_codec *codec)
4206 {
4207         struct alc_spec *spec = codec->spec;
4208
4209         if (!spec)
4210                 return;
4211
4212         alc_shutup(codec);
4213         alc_free_kctls(codec);
4214         kfree(spec);
4215         snd_hda_detach_beep_device(codec);
4216 }
4217
4218 #ifdef CONFIG_SND_HDA_POWER_SAVE
4219 static void alc_power_eapd(struct hda_codec *codec)
4220 {
4221         /* We currently only handle front, HP */
4222         switch (codec->vendor_id) {
4223         case 0x10ec0260:
4224                 set_eapd(codec, 0x0f, 0);
4225                 set_eapd(codec, 0x10, 0);
4226                 break;
4227         case 0x10ec0262:
4228         case 0x10ec0267:
4229         case 0x10ec0268:
4230         case 0x10ec0269:
4231         case 0x10ec0270:
4232         case 0x10ec0272:
4233         case 0x10ec0660:
4234         case 0x10ec0662:
4235         case 0x10ec0663:
4236         case 0x10ec0862:
4237         case 0x10ec0889:
4238                 set_eapd(codec, 0x14, 0);
4239                 set_eapd(codec, 0x15, 0);
4240                 break;
4241         }
4242 }
4243
4244 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4245 {
4246         struct alc_spec *spec = codec->spec;
4247         alc_shutup(codec);
4248         if (spec && spec->power_hook)
4249                 spec->power_hook(codec);
4250         return 0;
4251 }
4252 #endif
4253
4254 #ifdef SND_HDA_NEEDS_RESUME
4255 static int alc_resume(struct hda_codec *codec)
4256 {
4257         codec->patch_ops.init(codec);
4258         snd_hda_codec_resume_amp(codec);
4259         snd_hda_codec_resume_cache(codec);
4260         hda_call_check_power_status(codec, 0x01);
4261         return 0;
4262 }
4263 #endif
4264
4265 /*
4266  */
4267 static struct hda_codec_ops alc_patch_ops = {
4268         .build_controls = alc_build_controls,
4269         .build_pcms = alc_build_pcms,
4270         .init = alc_init,
4271         .free = alc_free,
4272         .unsol_event = alc_unsol_event,
4273 #ifdef SND_HDA_NEEDS_RESUME
4274         .resume = alc_resume,
4275 #endif
4276 #ifdef CONFIG_SND_HDA_POWER_SAVE
4277         .suspend = alc_suspend,
4278         .check_power_status = alc_check_power_status,
4279 #endif
4280         .reboot_notify = alc_shutup,
4281 };
4282
4283 /* replace the codec chip_name with the given string */
4284 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4285 {
4286         kfree(codec->chip_name);
4287         codec->chip_name = kstrdup(name, GFP_KERNEL);
4288         if (!codec->chip_name) {
4289                 alc_free(codec);
4290                 return -ENOMEM;
4291         }
4292         return 0;
4293 }
4294
4295 /*
4296  * Test configuration for debugging
4297  *
4298  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4299  * enum controls.
4300  */
4301 #ifdef CONFIG_SND_DEBUG
4302 static hda_nid_t alc880_test_dac_nids[4] = {
4303         0x02, 0x03, 0x04, 0x05
4304 };
4305
4306 static struct hda_input_mux alc880_test_capture_source = {
4307         .num_items = 7,
4308         .items = {
4309                 { "In-1", 0x0 },
4310                 { "In-2", 0x1 },
4311                 { "In-3", 0x2 },
4312                 { "In-4", 0x3 },
4313                 { "CD", 0x4 },
4314                 { "Front", 0x5 },
4315                 { "Surround", 0x6 },
4316         },
4317 };
4318
4319 static struct hda_channel_mode alc880_test_modes[4] = {
4320         { 2, NULL },
4321         { 4, NULL },
4322         { 6, NULL },
4323         { 8, NULL },
4324 };
4325
4326 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4327                                  struct snd_ctl_elem_info *uinfo)
4328 {
4329         static char *texts[] = {
4330                 "N/A", "Line Out", "HP Out",
4331                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4332         };
4333         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4334         uinfo->count = 1;
4335         uinfo->value.enumerated.items = 8;
4336         if (uinfo->value.enumerated.item >= 8)
4337                 uinfo->value.enumerated.item = 7;
4338         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4339         return 0;
4340 }
4341
4342 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4343                                 struct snd_ctl_elem_value *ucontrol)
4344 {
4345         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4346         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4347         unsigned int pin_ctl, item = 0;
4348
4349         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4350                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4351         if (pin_ctl & AC_PINCTL_OUT_EN) {
4352                 if (pin_ctl & AC_PINCTL_HP_EN)
4353                         item = 2;
4354                 else
4355                         item = 1;
4356         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4357                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4358                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4359                 case AC_PINCTL_VREF_50:  item = 4; break;
4360                 case AC_PINCTL_VREF_GRD: item = 5; break;
4361                 case AC_PINCTL_VREF_80:  item = 6; break;
4362                 case AC_PINCTL_VREF_100: item = 7; break;
4363                 }
4364         }
4365         ucontrol->value.enumerated.item[0] = item;
4366         return 0;
4367 }
4368
4369 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4370                                 struct snd_ctl_elem_value *ucontrol)
4371 {
4372         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4373         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4374         static unsigned int ctls[] = {
4375                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4376                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4377                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4378                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4379                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4380                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4381         };
4382         unsigned int old_ctl, new_ctl;
4383
4384         old_ctl = snd_hda_codec_read(codec, nid, 0,
4385                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4386         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4387         if (old_ctl != new_ctl) {
4388                 int val;
4389                 snd_hda_codec_write_cache(codec, nid, 0,
4390                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4391                                           new_ctl);
4392                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4393                         HDA_AMP_MUTE : 0;
4394                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4395                                          HDA_AMP_MUTE, val);
4396                 return 1;
4397         }
4398         return 0;
4399 }
4400
4401 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4402                                  struct snd_ctl_elem_info *uinfo)
4403 {
4404         static char *texts[] = {
4405                 "Front", "Surround", "CLFE", "Side"
4406         };
4407         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4408         uinfo->count = 1;
4409         uinfo->value.enumerated.items = 4;
4410         if (uinfo->value.enumerated.item >= 4)
4411                 uinfo->value.enumerated.item = 3;
4412         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4413         return 0;
4414 }
4415
4416 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4417                                 struct snd_ctl_elem_value *ucontrol)
4418 {
4419         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4420         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4421         unsigned int sel;
4422
4423         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4424         ucontrol->value.enumerated.item[0] = sel & 3;
4425         return 0;
4426 }
4427
4428 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4429                                 struct snd_ctl_elem_value *ucontrol)
4430 {
4431         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4432         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4433         unsigned int sel;
4434
4435         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4436         if (ucontrol->value.enumerated.item[0] != sel) {
4437                 sel = ucontrol->value.enumerated.item[0] & 3;
4438                 snd_hda_codec_write_cache(codec, nid, 0,
4439                                           AC_VERB_SET_CONNECT_SEL, sel);
4440                 return 1;
4441         }
4442         return 0;
4443 }
4444
4445 #define PIN_CTL_TEST(xname,nid) {                       \
4446                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4447                         .name = xname,                 \
4448                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4449                         .info = alc_test_pin_ctl_info, \
4450                         .get = alc_test_pin_ctl_get,   \
4451                         .put = alc_test_pin_ctl_put,   \
4452                         .private_value = nid           \
4453                         }
4454
4455 #define PIN_SRC_TEST(xname,nid) {                       \
4456                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4457                         .name = xname,                 \
4458                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4459                         .info = alc_test_pin_src_info, \
4460                         .get = alc_test_pin_src_get,   \
4461                         .put = alc_test_pin_src_put,   \
4462                         .private_value = nid           \
4463                         }
4464
4465 static struct snd_kcontrol_new alc880_test_mixer[] = {
4466         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4467         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4468         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4469         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4470         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4471         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4472         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4473         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4474         PIN_CTL_TEST("Front Pin Mode", 0x14),
4475         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4476         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4477         PIN_CTL_TEST("Side Pin Mode", 0x17),
4478         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4479         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4480         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4481         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4482         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4483         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4484         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4485         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4486         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4487         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4488         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4489         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4490         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4491         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4492         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4493         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4494         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4495         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4496         {
4497                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4498                 .name = "Channel Mode",
4499                 .info = alc_ch_mode_info,
4500                 .get = alc_ch_mode_get,
4501                 .put = alc_ch_mode_put,
4502         },
4503         { } /* end */
4504 };
4505
4506 static struct hda_verb alc880_test_init_verbs[] = {
4507         /* Unmute inputs of 0x0c - 0x0f */
4508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4509         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4510         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4511         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4512         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4513         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4514         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4515         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4516         /* Vol output for 0x0c-0x0f */
4517         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4518         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4519         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4520         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4521         /* Set output pins 0x14-0x17 */
4522         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4523         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4524         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4525         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4526         /* Unmute output pins 0x14-0x17 */
4527         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4528         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4529         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4530         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4531         /* Set input pins 0x18-0x1c */
4532         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4533         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4534         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4535         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4536         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4537         /* Mute input pins 0x18-0x1b */
4538         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4539         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4540         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4541         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4542         /* ADC set up */
4543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4544         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4545         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4546         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4547         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4548         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4549         /* Analog input/passthru */
4550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4551         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4552         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4553         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4554         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4555         { }
4556 };
4557 #endif
4558
4559 /*
4560  */
4561
4562 static const char *alc880_models[ALC880_MODEL_LAST] = {
4563         [ALC880_3ST]            = "3stack",
4564         [ALC880_TCL_S700]       = "tcl",
4565         [ALC880_3ST_DIG]        = "3stack-digout",
4566         [ALC880_CLEVO]          = "clevo",
4567         [ALC880_5ST]            = "5stack",
4568         [ALC880_5ST_DIG]        = "5stack-digout",
4569         [ALC880_W810]           = "w810",
4570         [ALC880_Z71V]           = "z71v",
4571         [ALC880_6ST]            = "6stack",
4572         [ALC880_6ST_DIG]        = "6stack-digout",
4573         [ALC880_ASUS]           = "asus",
4574         [ALC880_ASUS_W1V]       = "asus-w1v",
4575         [ALC880_ASUS_DIG]       = "asus-dig",
4576         [ALC880_ASUS_DIG2]      = "asus-dig2",
4577         [ALC880_UNIWILL_DIG]    = "uniwill",
4578         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4579         [ALC880_FUJITSU]        = "fujitsu",
4580         [ALC880_F1734]          = "F1734",
4581         [ALC880_LG]             = "lg",
4582         [ALC880_LG_LW]          = "lg-lw",
4583         [ALC880_MEDION_RIM]     = "medion",
4584 #ifdef CONFIG_SND_DEBUG
4585         [ALC880_TEST]           = "test",
4586 #endif
4587         [ALC880_AUTO]           = "auto",
4588 };
4589
4590 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4591         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4592         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4593         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4594         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4595         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4596         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4597         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4598         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4599         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4600         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4601         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4602         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4603         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4604         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4605         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4606         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4607         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4608         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4609         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4610         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4611         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4612         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4613         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4614         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4615         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4616         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4617         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4618         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4619         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4620         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4621         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4622         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4623         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4624         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4625         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4626         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4627         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4628         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4629         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4630         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4631         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4632         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4633         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4634         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4635         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4636         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4637         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4638         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4639         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4640         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4641         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4642         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4643         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4644         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4645         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4646         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4647         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4648         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4649         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4650         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4651         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4652         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4653         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4654         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4655         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4656         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4657         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4658         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4659         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4660         /* default Intel */
4661         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4662         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4663         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4664         {}
4665 };
4666
4667 /*
4668  * ALC880 codec presets
4669  */
4670 static struct alc_config_preset alc880_presets[] = {
4671         [ALC880_3ST] = {
4672                 .mixers = { alc880_three_stack_mixer },
4673                 .init_verbs = { alc880_volume_init_verbs,
4674                                 alc880_pin_3stack_init_verbs },
4675                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4676                 .dac_nids = alc880_dac_nids,
4677                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4678                 .channel_mode = alc880_threestack_modes,
4679                 .need_dac_fix = 1,
4680                 .input_mux = &alc880_capture_source,
4681         },
4682         [ALC880_3ST_DIG] = {
4683                 .mixers = { alc880_three_stack_mixer },
4684                 .init_verbs = { alc880_volume_init_verbs,
4685                                 alc880_pin_3stack_init_verbs },
4686                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4687                 .dac_nids = alc880_dac_nids,
4688                 .dig_out_nid = ALC880_DIGOUT_NID,
4689                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4690                 .channel_mode = alc880_threestack_modes,
4691                 .need_dac_fix = 1,
4692                 .input_mux = &alc880_capture_source,
4693         },
4694         [ALC880_TCL_S700] = {
4695                 .mixers = { alc880_tcl_s700_mixer },
4696                 .init_verbs = { alc880_volume_init_verbs,
4697                                 alc880_pin_tcl_S700_init_verbs,
4698                                 alc880_gpio2_init_verbs },
4699                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4700                 .dac_nids = alc880_dac_nids,
4701                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4702                 .num_adc_nids = 1, /* single ADC */
4703                 .hp_nid = 0x03,
4704                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4705                 .channel_mode = alc880_2_jack_modes,
4706                 .input_mux = &alc880_capture_source,
4707         },
4708         [ALC880_5ST] = {
4709                 .mixers = { alc880_three_stack_mixer,
4710                             alc880_five_stack_mixer},
4711                 .init_verbs = { alc880_volume_init_verbs,
4712                                 alc880_pin_5stack_init_verbs },
4713                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4714                 .dac_nids = alc880_dac_nids,
4715                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4716                 .channel_mode = alc880_fivestack_modes,
4717                 .input_mux = &alc880_capture_source,
4718         },
4719         [ALC880_5ST_DIG] = {
4720                 .mixers = { alc880_three_stack_mixer,
4721                             alc880_five_stack_mixer },
4722                 .init_verbs = { alc880_volume_init_verbs,
4723                                 alc880_pin_5stack_init_verbs },
4724                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4725                 .dac_nids = alc880_dac_nids,
4726                 .dig_out_nid = ALC880_DIGOUT_NID,
4727                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4728                 .channel_mode = alc880_fivestack_modes,
4729                 .input_mux = &alc880_capture_source,
4730         },
4731         [ALC880_6ST] = {
4732                 .mixers = { alc880_six_stack_mixer },
4733                 .init_verbs = { alc880_volume_init_verbs,
4734                                 alc880_pin_6stack_init_verbs },
4735                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4736                 .dac_nids = alc880_6st_dac_nids,
4737                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4738                 .channel_mode = alc880_sixstack_modes,
4739                 .input_mux = &alc880_6stack_capture_source,
4740         },
4741         [ALC880_6ST_DIG] = {
4742                 .mixers = { alc880_six_stack_mixer },
4743                 .init_verbs = { alc880_volume_init_verbs,
4744                                 alc880_pin_6stack_init_verbs },
4745                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4746                 .dac_nids = alc880_6st_dac_nids,
4747                 .dig_out_nid = ALC880_DIGOUT_NID,
4748                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4749                 .channel_mode = alc880_sixstack_modes,
4750                 .input_mux = &alc880_6stack_capture_source,
4751         },
4752         [ALC880_W810] = {
4753                 .mixers = { alc880_w810_base_mixer },
4754                 .init_verbs = { alc880_volume_init_verbs,
4755                                 alc880_pin_w810_init_verbs,
4756                                 alc880_gpio2_init_verbs },
4757                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4758                 .dac_nids = alc880_w810_dac_nids,
4759                 .dig_out_nid = ALC880_DIGOUT_NID,
4760                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4761                 .channel_mode = alc880_w810_modes,
4762                 .input_mux = &alc880_capture_source,
4763         },
4764         [ALC880_Z71V] = {
4765                 .mixers = { alc880_z71v_mixer },
4766                 .init_verbs = { alc880_volume_init_verbs,
4767                                 alc880_pin_z71v_init_verbs },
4768                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4769                 .dac_nids = alc880_z71v_dac_nids,
4770                 .dig_out_nid = ALC880_DIGOUT_NID,
4771                 .hp_nid = 0x03,
4772                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4773                 .channel_mode = alc880_2_jack_modes,
4774                 .input_mux = &alc880_capture_source,
4775         },
4776         [ALC880_F1734] = {
4777                 .mixers = { alc880_f1734_mixer },
4778                 .init_verbs = { alc880_volume_init_verbs,
4779                                 alc880_pin_f1734_init_verbs },
4780                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4781                 .dac_nids = alc880_f1734_dac_nids,
4782                 .hp_nid = 0x02,
4783                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4784                 .channel_mode = alc880_2_jack_modes,
4785                 .input_mux = &alc880_f1734_capture_source,
4786                 .unsol_event = alc880_uniwill_p53_unsol_event,
4787                 .setup = alc880_uniwill_p53_setup,
4788                 .init_hook = alc_automute_amp,
4789         },
4790         [ALC880_ASUS] = {
4791                 .mixers = { alc880_asus_mixer },
4792                 .init_verbs = { alc880_volume_init_verbs,
4793                                 alc880_pin_asus_init_verbs,
4794                                 alc880_gpio1_init_verbs },
4795                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4796                 .dac_nids = alc880_asus_dac_nids,
4797                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4798                 .channel_mode = alc880_asus_modes,
4799                 .need_dac_fix = 1,
4800                 .input_mux = &alc880_capture_source,
4801         },
4802         [ALC880_ASUS_DIG] = {
4803                 .mixers = { alc880_asus_mixer },
4804                 .init_verbs = { alc880_volume_init_verbs,
4805                                 alc880_pin_asus_init_verbs,
4806                                 alc880_gpio1_init_verbs },
4807                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4808                 .dac_nids = alc880_asus_dac_nids,
4809                 .dig_out_nid = ALC880_DIGOUT_NID,
4810                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4811                 .channel_mode = alc880_asus_modes,
4812                 .need_dac_fix = 1,
4813                 .input_mux = &alc880_capture_source,
4814         },
4815         [ALC880_ASUS_DIG2] = {
4816                 .mixers = { alc880_asus_mixer },
4817                 .init_verbs = { alc880_volume_init_verbs,
4818                                 alc880_pin_asus_init_verbs,
4819                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4820                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4821                 .dac_nids = alc880_asus_dac_nids,
4822                 .dig_out_nid = ALC880_DIGOUT_NID,
4823                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4824                 .channel_mode = alc880_asus_modes,
4825                 .need_dac_fix = 1,
4826                 .input_mux = &alc880_capture_source,
4827         },
4828         [ALC880_ASUS_W1V] = {
4829                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4830                 .init_verbs = { alc880_volume_init_verbs,
4831                                 alc880_pin_asus_init_verbs,
4832                                 alc880_gpio1_init_verbs },
4833                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4834                 .dac_nids = alc880_asus_dac_nids,
4835                 .dig_out_nid = ALC880_DIGOUT_NID,
4836                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4837                 .channel_mode = alc880_asus_modes,
4838                 .need_dac_fix = 1,
4839                 .input_mux = &alc880_capture_source,
4840         },
4841         [ALC880_UNIWILL_DIG] = {
4842                 .mixers = { alc880_asus_mixer },
4843                 .init_verbs = { alc880_volume_init_verbs,
4844                                 alc880_pin_asus_init_verbs },
4845                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4846                 .dac_nids = alc880_asus_dac_nids,
4847                 .dig_out_nid = ALC880_DIGOUT_NID,
4848                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4849                 .channel_mode = alc880_asus_modes,
4850                 .need_dac_fix = 1,
4851                 .input_mux = &alc880_capture_source,
4852         },
4853         [ALC880_UNIWILL] = {
4854                 .mixers = { alc880_uniwill_mixer },
4855                 .init_verbs = { alc880_volume_init_verbs,
4856                                 alc880_uniwill_init_verbs },
4857                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4858                 .dac_nids = alc880_asus_dac_nids,
4859                 .dig_out_nid = ALC880_DIGOUT_NID,
4860                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4861                 .channel_mode = alc880_threestack_modes,
4862                 .need_dac_fix = 1,
4863                 .input_mux = &alc880_capture_source,
4864                 .unsol_event = alc880_uniwill_unsol_event,
4865                 .setup = alc880_uniwill_setup,
4866                 .init_hook = alc880_uniwill_init_hook,
4867         },
4868         [ALC880_UNIWILL_P53] = {
4869                 .mixers = { alc880_uniwill_p53_mixer },
4870                 .init_verbs = { alc880_volume_init_verbs,
4871                                 alc880_uniwill_p53_init_verbs },
4872                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4873                 .dac_nids = alc880_asus_dac_nids,
4874                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4875                 .channel_mode = alc880_threestack_modes,
4876                 .input_mux = &alc880_capture_source,
4877                 .unsol_event = alc880_uniwill_p53_unsol_event,
4878                 .setup = alc880_uniwill_p53_setup,
4879                 .init_hook = alc_automute_amp,
4880         },
4881         [ALC880_FUJITSU] = {
4882                 .mixers = { alc880_fujitsu_mixer },
4883                 .init_verbs = { alc880_volume_init_verbs,
4884                                 alc880_uniwill_p53_init_verbs,
4885                                 alc880_beep_init_verbs },
4886                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4887                 .dac_nids = alc880_dac_nids,
4888                 .dig_out_nid = ALC880_DIGOUT_NID,
4889                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4890                 .channel_mode = alc880_2_jack_modes,
4891                 .input_mux = &alc880_capture_source,
4892                 .unsol_event = alc880_uniwill_p53_unsol_event,
4893                 .setup = alc880_uniwill_p53_setup,
4894                 .init_hook = alc_automute_amp,
4895         },
4896         [ALC880_CLEVO] = {
4897                 .mixers = { alc880_three_stack_mixer },
4898                 .init_verbs = { alc880_volume_init_verbs,
4899                                 alc880_pin_clevo_init_verbs },
4900                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4901                 .dac_nids = alc880_dac_nids,
4902                 .hp_nid = 0x03,
4903                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4904                 .channel_mode = alc880_threestack_modes,
4905                 .need_dac_fix = 1,
4906                 .input_mux = &alc880_capture_source,
4907         },
4908         [ALC880_LG] = {
4909                 .mixers = { alc880_lg_mixer },
4910                 .init_verbs = { alc880_volume_init_verbs,
4911                                 alc880_lg_init_verbs },
4912                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4913                 .dac_nids = alc880_lg_dac_nids,
4914                 .dig_out_nid = ALC880_DIGOUT_NID,
4915                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4916                 .channel_mode = alc880_lg_ch_modes,
4917                 .need_dac_fix = 1,
4918                 .input_mux = &alc880_lg_capture_source,
4919                 .unsol_event = alc_automute_amp_unsol_event,
4920                 .setup = alc880_lg_setup,
4921                 .init_hook = alc_automute_amp,
4922 #ifdef CONFIG_SND_HDA_POWER_SAVE
4923                 .loopbacks = alc880_lg_loopbacks,
4924 #endif
4925         },
4926         [ALC880_LG_LW] = {
4927                 .mixers = { alc880_lg_lw_mixer },
4928                 .init_verbs = { alc880_volume_init_verbs,
4929                                 alc880_lg_lw_init_verbs },
4930                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4931                 .dac_nids = alc880_dac_nids,
4932                 .dig_out_nid = ALC880_DIGOUT_NID,
4933                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4934                 .channel_mode = alc880_lg_lw_modes,
4935                 .input_mux = &alc880_lg_lw_capture_source,
4936                 .unsol_event = alc_automute_amp_unsol_event,
4937                 .setup = alc880_lg_lw_setup,
4938                 .init_hook = alc_automute_amp,
4939         },
4940         [ALC880_MEDION_RIM] = {
4941                 .mixers = { alc880_medion_rim_mixer },
4942                 .init_verbs = { alc880_volume_init_verbs,
4943                                 alc880_medion_rim_init_verbs,
4944                                 alc_gpio2_init_verbs },
4945                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4946                 .dac_nids = alc880_dac_nids,
4947                 .dig_out_nid = ALC880_DIGOUT_NID,
4948                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4949                 .channel_mode = alc880_2_jack_modes,
4950                 .input_mux = &alc880_medion_rim_capture_source,
4951                 .unsol_event = alc880_medion_rim_unsol_event,
4952                 .setup = alc880_medion_rim_setup,
4953                 .init_hook = alc880_medion_rim_automute,
4954         },
4955 #ifdef CONFIG_SND_DEBUG
4956         [ALC880_TEST] = {
4957                 .mixers = { alc880_test_mixer },
4958                 .init_verbs = { alc880_test_init_verbs },
4959                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4960                 .dac_nids = alc880_test_dac_nids,
4961                 .dig_out_nid = ALC880_DIGOUT_NID,
4962                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4963                 .channel_mode = alc880_test_modes,
4964                 .input_mux = &alc880_test_capture_source,
4965         },
4966 #endif
4967 };
4968
4969 /*
4970  * Automatic parse of I/O pins from the BIOS configuration
4971  */
4972
4973 enum {
4974         ALC_CTL_WIDGET_VOL,
4975         ALC_CTL_WIDGET_MUTE,
4976         ALC_CTL_BIND_MUTE,
4977 };
4978 static struct snd_kcontrol_new alc880_control_templates[] = {
4979         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4980         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4981         HDA_BIND_MUTE(NULL, 0, 0, 0),
4982 };
4983
4984 /* add dynamic controls */
4985 static int add_control(struct alc_spec *spec, int type, const char *name,
4986                        int cidx, unsigned long val)
4987 {
4988         struct snd_kcontrol_new *knew;
4989
4990         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4991         knew = snd_array_new(&spec->kctls);
4992         if (!knew)
4993                 return -ENOMEM;
4994         *knew = alc880_control_templates[type];
4995         knew->name = kstrdup(name, GFP_KERNEL);
4996         if (!knew->name)
4997                 return -ENOMEM;
4998         knew->index = cidx;
4999         if (get_amp_nid_(val))
5000                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5001         knew->private_value = val;
5002         return 0;
5003 }
5004
5005 static int add_control_with_pfx(struct alc_spec *spec, int type,
5006                                 const char *pfx, const char *dir,
5007                                 const char *sfx, int cidx, unsigned long val)
5008 {
5009         char name[32];
5010         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5011         return add_control(spec, type, name, cidx, val);
5012 }
5013
5014 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
5015         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5016 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
5017         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5018 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
5019         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5020 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
5021         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5022
5023 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
5024 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
5025 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
5026 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
5027 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
5028 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
5029 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
5030 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
5031 #define ALC880_PIN_CD_NID               0x1c
5032
5033 /* fill in the dac_nids table from the parsed pin configuration */
5034 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5035                                      const struct auto_pin_cfg *cfg)
5036 {
5037         hda_nid_t nid;
5038         int assigned[4];
5039         int i, j;
5040
5041         memset(assigned, 0, sizeof(assigned));
5042         spec->multiout.dac_nids = spec->private_dac_nids;
5043
5044         /* check the pins hardwired to audio widget */
5045         for (i = 0; i < cfg->line_outs; i++) {
5046                 nid = cfg->line_out_pins[i];
5047                 if (alc880_is_fixed_pin(nid)) {
5048                         int idx = alc880_fixed_pin_idx(nid);
5049                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5050                         assigned[idx] = 1;
5051                 }
5052         }
5053         /* left pins can be connect to any audio widget */
5054         for (i = 0; i < cfg->line_outs; i++) {
5055                 nid = cfg->line_out_pins[i];
5056                 if (alc880_is_fixed_pin(nid))
5057                         continue;
5058                 /* search for an empty channel */
5059                 for (j = 0; j < cfg->line_outs; j++) {
5060                         if (!assigned[j]) {
5061                                 spec->multiout.dac_nids[i] =
5062                                         alc880_idx_to_dac(j);
5063                                 assigned[j] = 1;
5064                                 break;
5065                         }
5066                 }
5067         }
5068         spec->multiout.num_dacs = cfg->line_outs;
5069         return 0;
5070 }
5071
5072 static const char *alc_get_line_out_pfx(const struct auto_pin_cfg *cfg,
5073                                         bool can_be_master)
5074 {
5075         if (!cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5076                 return "Master";
5077
5078         switch (cfg->line_out_type) {
5079         case AUTO_PIN_SPEAKER_OUT:
5080                 return "Speaker";
5081         case AUTO_PIN_HP_OUT:
5082                 return "Headphone";
5083         default:
5084                 if (cfg->line_outs == 1)
5085                         return "PCM";
5086                 break;
5087         }
5088         return NULL;
5089 }
5090
5091 /* add playback controls from the parsed DAC table */
5092 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5093                                              const struct auto_pin_cfg *cfg)
5094 {
5095         static const char *chname[4] = {
5096                 "Front", "Surround", NULL /*CLFE*/, "Side"
5097         };
5098         const char *pfx = alc_get_line_out_pfx(cfg, false);
5099         hda_nid_t nid;
5100         int i, err;
5101
5102         for (i = 0; i < cfg->line_outs; i++) {
5103                 if (!spec->multiout.dac_nids[i])
5104                         continue;
5105                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5106                 if (!pfx && i == 2) {
5107                         /* Center/LFE */
5108                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5109                                               "Center",
5110                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5111                                                               HDA_OUTPUT));
5112                         if (err < 0)
5113                                 return err;
5114                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5115                                               "LFE",
5116                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5117                                                               HDA_OUTPUT));
5118                         if (err < 0)
5119                                 return err;
5120                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5121                                              "Center",
5122                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5123                                                               HDA_INPUT));
5124                         if (err < 0)
5125                                 return err;
5126                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5127                                              "LFE",
5128                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5129                                                               HDA_INPUT));
5130                         if (err < 0)
5131                                 return err;
5132                 } else {
5133                         const char *name = pfx;
5134                         if (!name)
5135                                 name = chname[i];
5136                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5137                                                 name, i,
5138                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5139                                                               HDA_OUTPUT));
5140                         if (err < 0)
5141                                 return err;
5142                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5143                                                name, i,
5144                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5145                                                               HDA_INPUT));
5146                         if (err < 0)
5147                                 return err;
5148                 }
5149         }
5150         return 0;
5151 }
5152
5153 /* add playback controls for speaker and HP outputs */
5154 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5155                                         const char *pfx)
5156 {
5157         hda_nid_t nid;
5158         int err;
5159
5160         if (!pin)
5161                 return 0;
5162
5163         if (alc880_is_fixed_pin(pin)) {
5164                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5165                 /* specify the DAC as the extra output */
5166                 if (!spec->multiout.hp_nid)
5167                         spec->multiout.hp_nid = nid;
5168                 else
5169                         spec->multiout.extra_out_nid[0] = nid;
5170                 /* control HP volume/switch on the output mixer amp */
5171                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5172                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5173                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5174                 if (err < 0)
5175                         return err;
5176                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5177                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5178                 if (err < 0)
5179                         return err;
5180         } else if (alc880_is_multi_pin(pin)) {
5181                 /* set manual connection */
5182                 /* we have only a switch on HP-out PIN */
5183                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5184                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5185                 if (err < 0)
5186                         return err;
5187         }
5188         return 0;
5189 }
5190
5191 /* create input playback/capture controls for the given pin */
5192 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5193                             const char *ctlname, int ctlidx,
5194                             int idx, hda_nid_t mix_nid)
5195 {
5196         int err;
5197
5198         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5199                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5200         if (err < 0)
5201                 return err;
5202         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5203                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5204         if (err < 0)
5205                 return err;
5206         return 0;
5207 }
5208
5209 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5210 {
5211         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5212         return (pincap & AC_PINCAP_IN) != 0;
5213 }
5214
5215 /* create playback/capture controls for input pins */
5216 static int alc_auto_create_input_ctls(struct hda_codec *codec,
5217                                       const struct auto_pin_cfg *cfg,
5218                                       hda_nid_t mixer,
5219                                       hda_nid_t cap1, hda_nid_t cap2)
5220 {
5221         struct alc_spec *spec = codec->spec;
5222         struct hda_input_mux *imux = &spec->private_imux[0];
5223         int i, err, idx, type_idx = 0;
5224         const char *prev_label = NULL;
5225
5226         for (i = 0; i < cfg->num_inputs; i++) {
5227                 hda_nid_t pin;
5228                 const char *label;
5229
5230                 pin = cfg->inputs[i].pin;
5231                 if (!alc_is_input_pin(codec, pin))
5232                         continue;
5233
5234                 label = hda_get_autocfg_input_label(codec, cfg, i);
5235                 if (prev_label && !strcmp(label, prev_label))
5236                         type_idx++;
5237                 else
5238                         type_idx = 0;
5239                 prev_label = label;
5240
5241                 if (mixer) {
5242                         idx = get_connection_index(codec, mixer, pin);
5243                         if (idx >= 0) {
5244                                 err = new_analog_input(spec, pin,
5245                                                        label, type_idx,
5246                                                        idx, mixer);
5247                                 if (err < 0)
5248                                         return err;
5249                         }
5250                 }
5251
5252                 if (!cap1)
5253                         continue;
5254                 idx = get_connection_index(codec, cap1, pin);
5255                 if (idx < 0 && cap2)
5256                         idx = get_connection_index(codec, cap2, pin);
5257                 if (idx >= 0)
5258                         snd_hda_add_imux_item(imux, label, idx, NULL);
5259         }
5260         return 0;
5261 }
5262
5263 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5264                                                 const struct auto_pin_cfg *cfg)
5265 {
5266         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5267 }
5268
5269 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5270                                unsigned int pin_type)
5271 {
5272         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5273                             pin_type);
5274         /* unmute pin */
5275         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5276                             AMP_OUT_UNMUTE);
5277 }
5278
5279 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5280                                               hda_nid_t nid, int pin_type,
5281                                               int dac_idx)
5282 {
5283         alc_set_pin_output(codec, nid, pin_type);
5284         /* need the manual connection? */
5285         if (alc880_is_multi_pin(nid)) {
5286                 struct alc_spec *spec = codec->spec;
5287                 int idx = alc880_multi_pin_idx(nid);
5288                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5289                                     AC_VERB_SET_CONNECT_SEL,
5290                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5291         }
5292 }
5293
5294 static int get_pin_type(int line_out_type)
5295 {
5296         if (line_out_type == AUTO_PIN_HP_OUT)
5297                 return PIN_HP;
5298         else
5299                 return PIN_OUT;
5300 }
5301
5302 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5303 {
5304         struct alc_spec *spec = codec->spec;
5305         int i;
5306
5307         for (i = 0; i < spec->autocfg.line_outs; i++) {
5308                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5309                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5310                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5311         }
5312 }
5313
5314 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5315 {
5316         struct alc_spec *spec = codec->spec;
5317         hda_nid_t pin;
5318
5319         pin = spec->autocfg.speaker_pins[0];
5320         if (pin) /* connect to front */
5321                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5322         pin = spec->autocfg.hp_pins[0];
5323         if (pin) /* connect to front */
5324                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5325 }
5326
5327 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5328 {
5329         struct alc_spec *spec = codec->spec;
5330         struct auto_pin_cfg *cfg = &spec->autocfg;
5331         int i;
5332
5333         for (i = 0; i < cfg->num_inputs; i++) {
5334                 hda_nid_t nid = cfg->inputs[i].pin;
5335                 if (alc_is_input_pin(codec, nid)) {
5336                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5337                         if (nid != ALC880_PIN_CD_NID &&
5338                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5339                                 snd_hda_codec_write(codec, nid, 0,
5340                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5341                                                     AMP_OUT_MUTE);
5342                 }
5343         }
5344 }
5345
5346 static void alc880_auto_init_input_src(struct hda_codec *codec)
5347 {
5348         struct alc_spec *spec = codec->spec;
5349         int c;
5350
5351         for (c = 0; c < spec->num_adc_nids; c++) {
5352                 unsigned int mux_idx;
5353                 const struct hda_input_mux *imux;
5354                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5355                 imux = &spec->input_mux[mux_idx];
5356                 if (!imux->num_items && mux_idx > 0)
5357                         imux = &spec->input_mux[0];
5358                 if (imux)
5359                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5360                                             AC_VERB_SET_CONNECT_SEL,
5361                                             imux->items[0].index);
5362         }
5363 }
5364
5365 /* parse the BIOS configuration and set up the alc_spec */
5366 /* return 1 if successful, 0 if the proper config is not found,
5367  * or a negative error code
5368  */
5369 static int alc880_parse_auto_config(struct hda_codec *codec)
5370 {
5371         struct alc_spec *spec = codec->spec;
5372         int err;
5373         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5374
5375         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5376                                            alc880_ignore);
5377         if (err < 0)
5378                 return err;
5379         if (!spec->autocfg.line_outs)
5380                 return 0; /* can't find valid BIOS pin config */
5381
5382         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5383         if (err < 0)
5384                 return err;
5385         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5386         if (err < 0)
5387                 return err;
5388         err = alc880_auto_create_extra_out(spec,
5389                                            spec->autocfg.speaker_pins[0],
5390                                            "Speaker");
5391         if (err < 0)
5392                 return err;
5393         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5394                                            "Headphone");
5395         if (err < 0)
5396                 return err;
5397         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5398         if (err < 0)
5399                 return err;
5400
5401         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5402
5403         alc_auto_parse_digital(codec);
5404
5405         if (spec->kctls.list)
5406                 add_mixer(spec, spec->kctls.list);
5407
5408         add_verb(spec, alc880_volume_init_verbs);
5409
5410         spec->num_mux_defs = 1;
5411         spec->input_mux = &spec->private_imux[0];
5412
5413         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5414
5415         return 1;
5416 }
5417
5418 /* additional initialization for auto-configuration model */
5419 static void alc880_auto_init(struct hda_codec *codec)
5420 {
5421         struct alc_spec *spec = codec->spec;
5422         alc880_auto_init_multi_out(codec);
5423         alc880_auto_init_extra_out(codec);
5424         alc880_auto_init_analog_input(codec);
5425         alc880_auto_init_input_src(codec);
5426         alc_auto_init_digital(codec);
5427         if (spec->unsol_event)
5428                 alc_inithook(codec);
5429 }
5430
5431 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5432  * one of two digital mic pins, e.g. on ALC272
5433  */
5434 static void fixup_automic_adc(struct hda_codec *codec)
5435 {
5436         struct alc_spec *spec = codec->spec;
5437         int i;
5438
5439         for (i = 0; i < spec->num_adc_nids; i++) {
5440                 hda_nid_t cap = spec->capsrc_nids ?
5441                         spec->capsrc_nids[i] : spec->adc_nids[i];
5442                 int iidx, eidx;
5443
5444                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5445                 if (iidx < 0)
5446                         continue;
5447                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5448                 if (eidx < 0)
5449                         continue;
5450                 spec->int_mic.mux_idx = iidx;
5451                 spec->ext_mic.mux_idx = eidx;
5452                 if (spec->capsrc_nids)
5453                         spec->capsrc_nids += i;
5454                 spec->adc_nids += i;
5455                 spec->num_adc_nids = 1;
5456                 return;
5457         }
5458         snd_printd(KERN_INFO "hda_codec: %s: "
5459                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5460                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5461         spec->auto_mic = 0; /* disable auto-mic to be sure */
5462 }
5463
5464 /* select or unmute the given capsrc route */
5465 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5466                                     int idx)
5467 {
5468         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5469                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5470                                          HDA_AMP_MUTE, 0);
5471         } else {
5472                 snd_hda_codec_write_cache(codec, cap, 0,
5473                                           AC_VERB_SET_CONNECT_SEL, idx);
5474         }
5475 }
5476
5477 /* set the default connection to that pin */
5478 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5479 {
5480         struct alc_spec *spec = codec->spec;
5481         int i;
5482
5483         for (i = 0; i < spec->num_adc_nids; i++) {
5484                 hda_nid_t cap = spec->capsrc_nids ?
5485                         spec->capsrc_nids[i] : spec->adc_nids[i];
5486                 int idx;
5487
5488                 idx = get_connection_index(codec, cap, pin);
5489                 if (idx < 0)
5490                         continue;
5491                 select_or_unmute_capsrc(codec, cap, idx);
5492                 return i; /* return the found index */
5493         }
5494         return -1; /* not found */
5495 }
5496
5497 /* choose the ADC/MUX containing the input pin and initialize the setup */
5498 static void fixup_single_adc(struct hda_codec *codec)
5499 {
5500         struct alc_spec *spec = codec->spec;
5501         struct auto_pin_cfg *cfg = &spec->autocfg;
5502         int i;
5503
5504         /* search for the input pin; there must be only one */
5505         if (cfg->num_inputs != 1)
5506                 return;
5507         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5508         if (i >= 0) {
5509                 /* use only this ADC */
5510                 if (spec->capsrc_nids)
5511                         spec->capsrc_nids += i;
5512                 spec->adc_nids += i;
5513                 spec->num_adc_nids = 1;
5514         }
5515 }
5516
5517 /* initialize dual adcs */
5518 static void fixup_dual_adc_switch(struct hda_codec *codec)
5519 {
5520         struct alc_spec *spec = codec->spec;
5521         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5522         init_capsrc_for_pin(codec, spec->int_mic.pin);
5523 }
5524
5525 static void set_capture_mixer(struct hda_codec *codec)
5526 {
5527         struct alc_spec *spec = codec->spec;
5528         static struct snd_kcontrol_new *caps[2][3] = {
5529                 { alc_capture_mixer_nosrc1,
5530                   alc_capture_mixer_nosrc2,
5531                   alc_capture_mixer_nosrc3 },
5532                 { alc_capture_mixer1,
5533                   alc_capture_mixer2,
5534                   alc_capture_mixer3 },
5535         };
5536         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5537                 int mux = 0;
5538                 int num_adcs = spec->num_adc_nids;
5539                 if (spec->dual_adc_switch)
5540                         fixup_dual_adc_switch(codec);
5541                 else if (spec->auto_mic)
5542                         fixup_automic_adc(codec);
5543                 else if (spec->input_mux) {
5544                         if (spec->input_mux->num_items > 1)
5545                                 mux = 1;
5546                         else if (spec->input_mux->num_items == 1)
5547                                 fixup_single_adc(codec);
5548                 }
5549                 if (spec->dual_adc_switch)
5550                         num_adcs = 1;
5551                 spec->cap_mixer = caps[mux][num_adcs - 1];
5552         }
5553 }
5554
5555 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5556 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5557                                  int num_nids)
5558 {
5559         struct alc_spec *spec = codec->spec;
5560         struct auto_pin_cfg *cfg = &spec->autocfg;
5561         int n;
5562         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5563
5564         for (n = 0; n < num_nids; n++) {
5565                 hda_nid_t adc, cap;
5566                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5567                 int nconns, i, j;
5568
5569                 adc = nids[n];
5570                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5571                         continue;
5572                 cap = adc;
5573                 nconns = snd_hda_get_connections(codec, cap, conn,
5574                                                  ARRAY_SIZE(conn));
5575                 if (nconns == 1) {
5576                         cap = conn[0];
5577                         nconns = snd_hda_get_connections(codec, cap, conn,
5578                                                          ARRAY_SIZE(conn));
5579                 }
5580                 if (nconns <= 0)
5581                         continue;
5582                 if (!fallback_adc) {
5583                         fallback_adc = adc;
5584                         fallback_cap = cap;
5585                 }
5586                 for (i = 0; i < cfg->num_inputs; i++) {
5587                         hda_nid_t nid = cfg->inputs[i].pin;
5588                         for (j = 0; j < nconns; j++) {
5589                                 if (conn[j] == nid)
5590                                         break;
5591                         }
5592                         if (j >= nconns)
5593                                 break;
5594                 }
5595                 if (i >= cfg->num_inputs) {
5596                         int num_adcs = spec->num_adc_nids;
5597                         spec->private_adc_nids[num_adcs] = adc;
5598                         spec->private_capsrc_nids[num_adcs] = cap;
5599                         spec->num_adc_nids++;
5600                         spec->adc_nids = spec->private_adc_nids;
5601                         if (adc != cap)
5602                                 spec->capsrc_nids = spec->private_capsrc_nids;
5603                 }
5604         }
5605         if (!spec->num_adc_nids) {
5606                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5607                        " using fallback 0x%x\n",
5608                        codec->chip_name, fallback_adc);
5609                 spec->private_adc_nids[0] = fallback_adc;
5610                 spec->adc_nids = spec->private_adc_nids;
5611                 if (fallback_adc != fallback_cap) {
5612                         spec->private_capsrc_nids[0] = fallback_cap;
5613                         spec->capsrc_nids = spec->private_adc_nids;
5614                 }
5615         }
5616 }
5617
5618 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5619 #define set_beep_amp(spec, nid, idx, dir) \
5620         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5621
5622 static struct snd_pci_quirk beep_white_list[] = {
5623         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5624         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5625         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5626         {}
5627 };
5628
5629 static inline int has_cdefine_beep(struct hda_codec *codec)
5630 {
5631         struct alc_spec *spec = codec->spec;
5632         const struct snd_pci_quirk *q;
5633         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5634         if (q)
5635                 return q->value;
5636         return spec->cdefine.enable_pcbeep;
5637 }
5638 #else
5639 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5640 #define has_cdefine_beep(codec)         0
5641 #endif
5642
5643 /*
5644  * OK, here we have finally the patch for ALC880
5645  */
5646
5647 static int patch_alc880(struct hda_codec *codec)
5648 {
5649         struct alc_spec *spec;
5650         int board_config;
5651         int err;
5652
5653         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5654         if (spec == NULL)
5655                 return -ENOMEM;
5656
5657         codec->spec = spec;
5658
5659         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5660                                                   alc880_models,
5661                                                   alc880_cfg_tbl);
5662         if (board_config < 0) {
5663                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5664                        codec->chip_name);
5665                 board_config = ALC880_AUTO;
5666         }
5667
5668         if (board_config == ALC880_AUTO) {
5669                 /* automatic parse from the BIOS config */
5670                 err = alc880_parse_auto_config(codec);
5671                 if (err < 0) {
5672                         alc_free(codec);
5673                         return err;
5674                 } else if (!err) {
5675                         printk(KERN_INFO
5676                                "hda_codec: Cannot set up configuration "
5677                                "from BIOS.  Using 3-stack mode...\n");
5678                         board_config = ALC880_3ST;
5679                 }
5680         }
5681
5682         err = snd_hda_attach_beep_device(codec, 0x1);
5683         if (err < 0) {
5684                 alc_free(codec);
5685                 return err;
5686         }
5687
5688         if (board_config != ALC880_AUTO)
5689                 setup_preset(codec, &alc880_presets[board_config]);
5690
5691         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5692         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5693         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5694
5695         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5696         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5697
5698         if (!spec->adc_nids && spec->input_mux) {
5699                 /* check whether NID 0x07 is valid */
5700                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5701                 /* get type */
5702                 wcap = get_wcaps_type(wcap);
5703                 if (wcap != AC_WID_AUD_IN) {
5704                         spec->adc_nids = alc880_adc_nids_alt;
5705                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5706                 } else {
5707                         spec->adc_nids = alc880_adc_nids;
5708                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5709                 }
5710         }
5711         set_capture_mixer(codec);
5712         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5713
5714         spec->vmaster_nid = 0x0c;
5715
5716         codec->patch_ops = alc_patch_ops;
5717         if (board_config == ALC880_AUTO)
5718                 spec->init_hook = alc880_auto_init;
5719 #ifdef CONFIG_SND_HDA_POWER_SAVE
5720         if (!spec->loopback.amplist)
5721                 spec->loopback.amplist = alc880_loopbacks;
5722 #endif
5723
5724         return 0;
5725 }
5726
5727
5728 /*
5729  * ALC260 support
5730  */
5731
5732 static hda_nid_t alc260_dac_nids[1] = {
5733         /* front */
5734         0x02,
5735 };
5736
5737 static hda_nid_t alc260_adc_nids[1] = {
5738         /* ADC0 */
5739         0x04,
5740 };
5741
5742 static hda_nid_t alc260_adc_nids_alt[1] = {
5743         /* ADC1 */
5744         0x05,
5745 };
5746
5747 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5748  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5749  */
5750 static hda_nid_t alc260_dual_adc_nids[2] = {
5751         /* ADC0, ADC1 */
5752         0x04, 0x05
5753 };
5754
5755 #define ALC260_DIGOUT_NID       0x03
5756 #define ALC260_DIGIN_NID        0x06
5757
5758 static struct hda_input_mux alc260_capture_source = {
5759         .num_items = 4,
5760         .items = {
5761                 { "Mic", 0x0 },
5762                 { "Front Mic", 0x1 },
5763                 { "Line", 0x2 },
5764                 { "CD", 0x4 },
5765         },
5766 };
5767
5768 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5769  * headphone jack and the internal CD lines since these are the only pins at
5770  * which audio can appear.  For flexibility, also allow the option of
5771  * recording the mixer output on the second ADC (ADC0 doesn't have a
5772  * connection to the mixer output).
5773  */
5774 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5775         {
5776                 .num_items = 3,
5777                 .items = {
5778                         { "Mic/Line", 0x0 },
5779                         { "CD", 0x4 },
5780                         { "Headphone", 0x2 },
5781                 },
5782         },
5783         {
5784                 .num_items = 4,
5785                 .items = {
5786                         { "Mic/Line", 0x0 },
5787                         { "CD", 0x4 },
5788                         { "Headphone", 0x2 },
5789                         { "Mixer", 0x5 },
5790                 },
5791         },
5792
5793 };
5794
5795 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5796  * the Fujitsu S702x, but jacks are marked differently.
5797  */
5798 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5799         {
5800                 .num_items = 4,
5801                 .items = {
5802                         { "Mic", 0x0 },
5803                         { "Line", 0x2 },
5804                         { "CD", 0x4 },
5805                         { "Headphone", 0x5 },
5806                 },
5807         },
5808         {
5809                 .num_items = 5,
5810                 .items = {
5811                         { "Mic", 0x0 },
5812                         { "Line", 0x2 },
5813                         { "CD", 0x4 },
5814                         { "Headphone", 0x6 },
5815                         { "Mixer", 0x5 },
5816                 },
5817         },
5818 };
5819
5820 /* Maxdata Favorit 100XS */
5821 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5822         {
5823                 .num_items = 2,
5824                 .items = {
5825                         { "Line/Mic", 0x0 },
5826                         { "CD", 0x4 },
5827                 },
5828         },
5829         {
5830                 .num_items = 3,
5831                 .items = {
5832                         { "Line/Mic", 0x0 },
5833                         { "CD", 0x4 },
5834                         { "Mixer", 0x5 },
5835                 },
5836         },
5837 };
5838
5839 /*
5840  * This is just place-holder, so there's something for alc_build_pcms to look
5841  * at when it calculates the maximum number of channels. ALC260 has no mixer
5842  * element which allows changing the channel mode, so the verb list is
5843  * never used.
5844  */
5845 static struct hda_channel_mode alc260_modes[1] = {
5846         { 2, NULL },
5847 };
5848
5849
5850 /* Mixer combinations
5851  *
5852  * basic: base_output + input + pc_beep + capture
5853  * HP: base_output + input + capture_alt
5854  * HP_3013: hp_3013 + input + capture
5855  * fujitsu: fujitsu + capture
5856  * acer: acer + capture
5857  */
5858
5859 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5860         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5861         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5862         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5863         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5864         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5865         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5866         { } /* end */
5867 };
5868
5869 static struct snd_kcontrol_new alc260_input_mixer[] = {
5870         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5871         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5872         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5873         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5874         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5875         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5876         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5877         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5878         { } /* end */
5879 };
5880
5881 /* update HP, line and mono out pins according to the master switch */
5882 static void alc260_hp_master_update(struct hda_codec *codec,
5883                                     hda_nid_t hp, hda_nid_t line,
5884                                     hda_nid_t mono)
5885 {
5886         struct alc_spec *spec = codec->spec;
5887         unsigned int val = spec->master_sw ? PIN_HP : 0;
5888         /* change HP and line-out pins */
5889         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5890                             val);
5891         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5892                             val);
5893         /* mono (speaker) depending on the HP jack sense */
5894         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5895         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5896                             val);
5897 }
5898
5899 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5900                                    struct snd_ctl_elem_value *ucontrol)
5901 {
5902         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5903         struct alc_spec *spec = codec->spec;
5904         *ucontrol->value.integer.value = spec->master_sw;
5905         return 0;
5906 }
5907
5908 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5909                                    struct snd_ctl_elem_value *ucontrol)
5910 {
5911         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5912         struct alc_spec *spec = codec->spec;
5913         int val = !!*ucontrol->value.integer.value;
5914         hda_nid_t hp, line, mono;
5915
5916         if (val == spec->master_sw)
5917                 return 0;
5918         spec->master_sw = val;
5919         hp = (kcontrol->private_value >> 16) & 0xff;
5920         line = (kcontrol->private_value >> 8) & 0xff;
5921         mono = kcontrol->private_value & 0xff;
5922         alc260_hp_master_update(codec, hp, line, mono);
5923         return 1;
5924 }
5925
5926 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5927         {
5928                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5929                 .name = "Master Playback Switch",
5930                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5931                 .info = snd_ctl_boolean_mono_info,
5932                 .get = alc260_hp_master_sw_get,
5933                 .put = alc260_hp_master_sw_put,
5934                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5935         },
5936         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5937         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5938         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5939         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5940         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5941                               HDA_OUTPUT),
5942         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5943         { } /* end */
5944 };
5945
5946 static struct hda_verb alc260_hp_unsol_verbs[] = {
5947         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5948         {},
5949 };
5950
5951 static void alc260_hp_automute(struct hda_codec *codec)
5952 {
5953         struct alc_spec *spec = codec->spec;
5954
5955         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5956         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5957 }
5958
5959 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5960 {
5961         if ((res >> 26) == ALC880_HP_EVENT)
5962                 alc260_hp_automute(codec);
5963 }
5964
5965 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5966         {
5967                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5968                 .name = "Master Playback Switch",
5969                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5970                 .info = snd_ctl_boolean_mono_info,
5971                 .get = alc260_hp_master_sw_get,
5972                 .put = alc260_hp_master_sw_put,
5973                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5974         },
5975         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5976         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5977         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5978         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5979         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5980         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5981         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5982         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5983         { } /* end */
5984 };
5985
5986 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5987         .ops = &snd_hda_bind_vol,
5988         .values = {
5989                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5990                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5991                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5992                 0
5993         },
5994 };
5995
5996 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5997         .ops = &snd_hda_bind_sw,
5998         .values = {
5999                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6000                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6001                 0
6002         },
6003 };
6004
6005 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6006         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6007         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6008         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6009         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6010         { } /* end */
6011 };
6012
6013 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6014         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6015         {},
6016 };
6017
6018 static void alc260_hp_3013_automute(struct hda_codec *codec)
6019 {
6020         struct alc_spec *spec = codec->spec;
6021
6022         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
6023         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
6024 }
6025
6026 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
6027                                        unsigned int res)
6028 {
6029         if ((res >> 26) == ALC880_HP_EVENT)
6030                 alc260_hp_3013_automute(codec);
6031 }
6032
6033 static void alc260_hp_3012_automute(struct hda_codec *codec)
6034 {
6035         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
6036
6037         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6038                             bits);
6039         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6040                             bits);
6041         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6042                             bits);
6043 }
6044
6045 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
6046                                        unsigned int res)
6047 {
6048         if ((res >> 26) == ALC880_HP_EVENT)
6049                 alc260_hp_3012_automute(codec);
6050 }
6051
6052 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6053  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6054  */
6055 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6056         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6057         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6058         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6059         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6060         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6061         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6062         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6063         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6064         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6065         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6066         { } /* end */
6067 };
6068
6069 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6070  * versions of the ALC260 don't act on requests to enable mic bias from NID
6071  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6072  * datasheet doesn't mention this restriction.  At this stage it's not clear
6073  * whether this behaviour is intentional or is a hardware bug in chip
6074  * revisions available in early 2006.  Therefore for now allow the
6075  * "Headphone Jack Mode" control to span all choices, but if it turns out
6076  * that the lack of mic bias for this NID is intentional we could change the
6077  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6078  *
6079  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6080  * don't appear to make the mic bias available from the "line" jack, even
6081  * though the NID used for this jack (0x14) can supply it.  The theory is
6082  * that perhaps Acer have included blocking capacitors between the ALC260
6083  * and the output jack.  If this turns out to be the case for all such
6084  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6085  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6086  *
6087  * The C20x Tablet series have a mono internal speaker which is controlled
6088  * via the chip's Mono sum widget and pin complex, so include the necessary
6089  * controls for such models.  On models without a "mono speaker" the control
6090  * won't do anything.
6091  */
6092 static struct snd_kcontrol_new alc260_acer_mixer[] = {
6093         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6094         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6095         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6096         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6097                               HDA_OUTPUT),
6098         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6099                            HDA_INPUT),
6100         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6101         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6102         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6103         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6104         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6105         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6106         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6107         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6108         { } /* end */
6109 };
6110
6111 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
6112  */
6113 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6114         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6115         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6116         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6117         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6118         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6119         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6120         { } /* end */
6121 };
6122
6123 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6124  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6125  */
6126 static struct snd_kcontrol_new alc260_will_mixer[] = {
6127         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6128         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6130         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6131         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6132         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6133         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6134         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6135         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6136         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6137         { } /* end */
6138 };
6139
6140 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6141  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6142  */
6143 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6144         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6145         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6146         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6147         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6148         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6149         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6150         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6151         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6152         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6153         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6154         { } /* end */
6155 };
6156
6157 /*
6158  * initialization verbs
6159  */
6160 static struct hda_verb alc260_init_verbs[] = {
6161         /* Line In pin widget for input */
6162         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6163         /* CD pin widget for input */
6164         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6165         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6166         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6167         /* Mic2 (front panel) pin widget for input and vref at 80% */
6168         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6169         /* LINE-2 is used for line-out in rear */
6170         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6171         /* select line-out */
6172         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6173         /* LINE-OUT pin */
6174         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6175         /* enable HP */
6176         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6177         /* enable Mono */
6178         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6179         /* mute capture amp left and right */
6180         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6181         /* set connection select to line in (default select for this ADC) */
6182         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6183         /* mute capture amp left and right */
6184         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6185         /* set connection select to line in (default select for this ADC) */
6186         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6187         /* set vol=0 Line-Out mixer amp left and right */
6188         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6189         /* unmute pin widget amp left and right (no gain on this amp) */
6190         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6191         /* set vol=0 HP mixer amp left and right */
6192         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6193         /* unmute pin widget amp left and right (no gain on this amp) */
6194         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6195         /* set vol=0 Mono mixer amp left and right */
6196         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6197         /* unmute pin widget amp left and right (no gain on this amp) */
6198         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6199         /* unmute LINE-2 out pin */
6200         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6201         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6202          * Line In 2 = 0x03
6203          */
6204         /* mute analog inputs */
6205         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6206         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6207         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6208         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6209         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6210         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6211         /* mute Front out path */
6212         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6213         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6214         /* mute Headphone out path */
6215         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6216         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6217         /* mute Mono out path */
6218         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6219         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6220         { }
6221 };
6222
6223 #if 0 /* should be identical with alc260_init_verbs? */
6224 static struct hda_verb alc260_hp_init_verbs[] = {
6225         /* Headphone and output */
6226         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6227         /* mono output */
6228         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6229         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6230         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6231         /* Mic2 (front panel) pin widget for input and vref at 80% */
6232         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6233         /* Line In pin widget for input */
6234         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6235         /* Line-2 pin widget for output */
6236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6237         /* CD pin widget for input */
6238         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6239         /* unmute amp left and right */
6240         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6241         /* set connection select to line in (default select for this ADC) */
6242         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6243         /* unmute Line-Out mixer amp left and right (volume = 0) */
6244         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6245         /* mute pin widget amp left and right (no gain on this amp) */
6246         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6247         /* unmute HP mixer amp left and right (volume = 0) */
6248         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6249         /* mute pin widget amp left and right (no gain on this amp) */
6250         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6251         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6252          * Line In 2 = 0x03
6253          */
6254         /* mute analog inputs */
6255         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6256         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6257         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6258         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6259         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6260         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6261         /* Unmute Front out path */
6262         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6263         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6264         /* Unmute Headphone out path */
6265         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6266         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6267         /* Unmute Mono out path */
6268         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6269         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6270         { }
6271 };
6272 #endif
6273
6274 static struct hda_verb alc260_hp_3013_init_verbs[] = {
6275         /* Line out and output */
6276         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6277         /* mono output */
6278         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6279         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6280         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6281         /* Mic2 (front panel) pin widget for input and vref at 80% */
6282         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6283         /* Line In pin widget for input */
6284         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6285         /* Headphone pin widget for output */
6286         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6287         /* CD pin widget for input */
6288         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6289         /* unmute amp left and right */
6290         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6291         /* set connection select to line in (default select for this ADC) */
6292         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6293         /* unmute Line-Out mixer amp left and right (volume = 0) */
6294         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6295         /* mute pin widget amp left and right (no gain on this amp) */
6296         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6297         /* unmute HP mixer amp left and right (volume = 0) */
6298         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6299         /* mute pin widget amp left and right (no gain on this amp) */
6300         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6301         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6302          * Line In 2 = 0x03
6303          */
6304         /* mute analog inputs */
6305         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6306         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6307         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6308         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6309         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6310         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6311         /* Unmute Front out path */
6312         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6313         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6314         /* Unmute Headphone out path */
6315         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6316         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6317         /* Unmute Mono out path */
6318         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6319         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6320         { }
6321 };
6322
6323 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6324  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6325  * audio = 0x16, internal speaker = 0x10.
6326  */
6327 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6328         /* Disable all GPIOs */
6329         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6330         /* Internal speaker is connected to headphone pin */
6331         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6332         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6333         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6334         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6335         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6336         /* Ensure all other unused pins are disabled and muted. */
6337         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6338         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6339         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6340         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6341         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6342         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6343         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6344         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6345
6346         /* Disable digital (SPDIF) pins */
6347         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6348         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6349
6350         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6351          * when acting as an output.
6352          */
6353         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6354
6355         /* Start with output sum widgets muted and their output gains at min */
6356         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6357         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6358         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6359         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6360         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6361         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6362         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6363         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6364         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6365
6366         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6367         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6368         /* Unmute Line1 pin widget output buffer since it starts as an output.
6369          * If the pin mode is changed by the user the pin mode control will
6370          * take care of enabling the pin's input/output buffers as needed.
6371          * Therefore there's no need to enable the input buffer at this
6372          * stage.
6373          */
6374         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6375         /* Unmute input buffer of pin widget used for Line-in (no equiv
6376          * mixer ctrl)
6377          */
6378         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6379
6380         /* Mute capture amp left and right */
6381         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6382         /* Set ADC connection select to match default mixer setting - line
6383          * in (on mic1 pin)
6384          */
6385         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6386
6387         /* Do the same for the second ADC: mute capture input amp and
6388          * set ADC connection to line in (on mic1 pin)
6389          */
6390         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6391         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6392
6393         /* Mute all inputs to mixer widget (even unconnected ones) */
6394         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6395         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6396         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6397         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6398         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6399         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6400         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6401         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6402
6403         { }
6404 };
6405
6406 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6407  * similar laptops (adapted from Fujitsu init verbs).
6408  */
6409 static struct hda_verb alc260_acer_init_verbs[] = {
6410         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6411          * the headphone jack.  Turn this on and rely on the standard mute
6412          * methods whenever the user wants to turn these outputs off.
6413          */
6414         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6415         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6416         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6417         /* Internal speaker/Headphone jack is connected to Line-out pin */
6418         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6419         /* Internal microphone/Mic jack is connected to Mic1 pin */
6420         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6421         /* Line In jack is connected to Line1 pin */
6422         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6423         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6424         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6425         /* Ensure all other unused pins are disabled and muted. */
6426         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6427         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6428         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6429         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6430         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6431         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6432         /* Disable digital (SPDIF) pins */
6433         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6434         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6435
6436         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6437          * bus when acting as outputs.
6438          */
6439         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6440         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6441
6442         /* Start with output sum widgets muted and their output gains at min */
6443         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6444         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6445         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6446         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6447         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6448         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6449         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6450         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6451         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6452
6453         /* Unmute Line-out pin widget amp left and right
6454          * (no equiv mixer ctrl)
6455          */
6456         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6457         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6458         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6459         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6460          * inputs. If the pin mode is changed by the user the pin mode control
6461          * will take care of enabling the pin's input/output buffers as needed.
6462          * Therefore there's no need to enable the input buffer at this
6463          * stage.
6464          */
6465         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6466         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6467
6468         /* Mute capture amp left and right */
6469         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6470         /* Set ADC connection select to match default mixer setting - mic
6471          * (on mic1 pin)
6472          */
6473         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6474
6475         /* Do similar with the second ADC: mute capture input amp and
6476          * set ADC connection to mic to match ALSA's default state.
6477          */
6478         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6479         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6480
6481         /* Mute all inputs to mixer widget (even unconnected ones) */
6482         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6483         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6484         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6485         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6486         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6487         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6488         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6489         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6490
6491         { }
6492 };
6493
6494 /* Initialisation sequence for Maxdata Favorit 100XS
6495  * (adapted from Acer init verbs).
6496  */
6497 static struct hda_verb alc260_favorit100_init_verbs[] = {
6498         /* GPIO 0 enables the output jack.
6499          * Turn this on and rely on the standard mute
6500          * methods whenever the user wants to turn these outputs off.
6501          */
6502         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6503         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6504         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6505         /* Line/Mic input jack is connected to Mic1 pin */
6506         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6507         /* Ensure all other unused pins are disabled and muted. */
6508         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6509         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6510         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6511         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6512         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6513         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6515         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6516         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6517         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6518         /* Disable digital (SPDIF) pins */
6519         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6520         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6521
6522         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6523          * bus when acting as outputs.
6524          */
6525         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6526         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6527
6528         /* Start with output sum widgets muted and their output gains at min */
6529         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6530         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6531         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6532         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6533         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6534         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6535         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6536         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6537         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6538
6539         /* Unmute Line-out pin widget amp left and right
6540          * (no equiv mixer ctrl)
6541          */
6542         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6543         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6544          * inputs. If the pin mode is changed by the user the pin mode control
6545          * will take care of enabling the pin's input/output buffers as needed.
6546          * Therefore there's no need to enable the input buffer at this
6547          * stage.
6548          */
6549         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6550
6551         /* Mute capture amp left and right */
6552         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6553         /* Set ADC connection select to match default mixer setting - mic
6554          * (on mic1 pin)
6555          */
6556         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6557
6558         /* Do similar with the second ADC: mute capture input amp and
6559          * set ADC connection to mic to match ALSA's default state.
6560          */
6561         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6562         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6563
6564         /* Mute all inputs to mixer widget (even unconnected ones) */
6565         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6566         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6567         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6568         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6569         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6570         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6571         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6572         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6573
6574         { }
6575 };
6576
6577 static struct hda_verb alc260_will_verbs[] = {
6578         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6579         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6580         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6581         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6582         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6583         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6584         {}
6585 };
6586
6587 static struct hda_verb alc260_replacer_672v_verbs[] = {
6588         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6589         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6590         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6591
6592         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6593         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6594         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6595
6596         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6597         {}
6598 };
6599
6600 /* toggle speaker-output according to the hp-jack state */
6601 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6602 {
6603         unsigned int present;
6604
6605         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6606         present = snd_hda_jack_detect(codec, 0x0f);
6607         if (present) {
6608                 snd_hda_codec_write_cache(codec, 0x01, 0,
6609                                           AC_VERB_SET_GPIO_DATA, 1);
6610                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6611                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6612                                           PIN_HP);
6613         } else {
6614                 snd_hda_codec_write_cache(codec, 0x01, 0,
6615                                           AC_VERB_SET_GPIO_DATA, 0);
6616                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6617                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6618                                           PIN_OUT);
6619         }
6620 }
6621
6622 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6623                                        unsigned int res)
6624 {
6625         if ((res >> 26) == ALC880_HP_EVENT)
6626                 alc260_replacer_672v_automute(codec);
6627 }
6628
6629 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6630         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6631         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6632         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6633         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6634         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6635         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6636         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6637         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6638         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6639         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6640         {}
6641 };
6642
6643 /* Test configuration for debugging, modelled after the ALC880 test
6644  * configuration.
6645  */
6646 #ifdef CONFIG_SND_DEBUG
6647 static hda_nid_t alc260_test_dac_nids[1] = {
6648         0x02,
6649 };
6650 static hda_nid_t alc260_test_adc_nids[2] = {
6651         0x04, 0x05,
6652 };
6653 /* For testing the ALC260, each input MUX needs its own definition since
6654  * the signal assignments are different.  This assumes that the first ADC
6655  * is NID 0x04.
6656  */
6657 static struct hda_input_mux alc260_test_capture_sources[2] = {
6658         {
6659                 .num_items = 7,
6660                 .items = {
6661                         { "MIC1 pin", 0x0 },
6662                         { "MIC2 pin", 0x1 },
6663                         { "LINE1 pin", 0x2 },
6664                         { "LINE2 pin", 0x3 },
6665                         { "CD pin", 0x4 },
6666                         { "LINE-OUT pin", 0x5 },
6667                         { "HP-OUT pin", 0x6 },
6668                 },
6669         },
6670         {
6671                 .num_items = 8,
6672                 .items = {
6673                         { "MIC1 pin", 0x0 },
6674                         { "MIC2 pin", 0x1 },
6675                         { "LINE1 pin", 0x2 },
6676                         { "LINE2 pin", 0x3 },
6677                         { "CD pin", 0x4 },
6678                         { "Mixer", 0x5 },
6679                         { "LINE-OUT pin", 0x6 },
6680                         { "HP-OUT pin", 0x7 },
6681                 },
6682         },
6683 };
6684 static struct snd_kcontrol_new alc260_test_mixer[] = {
6685         /* Output driver widgets */
6686         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6687         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6688         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6689         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6690         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6691         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6692
6693         /* Modes for retasking pin widgets
6694          * Note: the ALC260 doesn't seem to act on requests to enable mic
6695          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6696          * mention this restriction.  At this stage it's not clear whether
6697          * this behaviour is intentional or is a hardware bug in chip
6698          * revisions available at least up until early 2006.  Therefore for
6699          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6700          * choices, but if it turns out that the lack of mic bias for these
6701          * NIDs is intentional we could change their modes from
6702          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6703          */
6704         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6705         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6706         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6707         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6708         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6709         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6710
6711         /* Loopback mixer controls */
6712         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6713         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6714         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6715         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6716         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6717         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6718         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6719         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6720         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6721         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6722         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6723         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6724         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6725         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6726
6727         /* Controls for GPIO pins, assuming they are configured as outputs */
6728         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6729         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6730         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6731         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6732
6733         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6734          * is ambigious as to which NID is which; testing on laptops which
6735          * make this output available should provide clarification.
6736          */
6737         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6738         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6739
6740         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6741          * this output to turn on an external amplifier.
6742          */
6743         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6744         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6745
6746         { } /* end */
6747 };
6748 static struct hda_verb alc260_test_init_verbs[] = {
6749         /* Enable all GPIOs as outputs with an initial value of 0 */
6750         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6751         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6752         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6753
6754         /* Enable retasking pins as output, initially without power amp */
6755         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6756         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6757         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6758         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6759         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6760         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6761
6762         /* Disable digital (SPDIF) pins initially, but users can enable
6763          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6764          * payload also sets the generation to 0, output to be in "consumer"
6765          * PCM format, copyright asserted, no pre-emphasis and no validity
6766          * control.
6767          */
6768         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6769         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6770
6771         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6772          * OUT1 sum bus when acting as an output.
6773          */
6774         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6775         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6776         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6777         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6778
6779         /* Start with output sum widgets muted and their output gains at min */
6780         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6781         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6782         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6783         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6784         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6785         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6786         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6787         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6788         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6789
6790         /* Unmute retasking pin widget output buffers since the default
6791          * state appears to be output.  As the pin mode is changed by the
6792          * user the pin mode control will take care of enabling the pin's
6793          * input/output buffers as needed.
6794          */
6795         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6796         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6797         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6798         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6799         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6800         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6801         /* Also unmute the mono-out pin widget */
6802         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6803
6804         /* Mute capture amp left and right */
6805         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6806         /* Set ADC connection select to match default mixer setting (mic1
6807          * pin)
6808          */
6809         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6810
6811         /* Do the same for the second ADC: mute capture input amp and
6812          * set ADC connection to mic1 pin
6813          */
6814         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6815         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6816
6817         /* Mute all inputs to mixer widget (even unconnected ones) */
6818         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6819         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6820         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6821         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6822         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6823         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6824         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6825         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6826
6827         { }
6828 };
6829 #endif
6830
6831 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6832 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6833
6834 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6835 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6836
6837 /*
6838  * for BIOS auto-configuration
6839  */
6840
6841 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6842                                         const char *pfx, int *vol_bits)
6843 {
6844         hda_nid_t nid_vol;
6845         unsigned long vol_val, sw_val;
6846         int err;
6847
6848         if (nid >= 0x0f && nid < 0x11) {
6849                 nid_vol = nid - 0x7;
6850                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6851                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6852         } else if (nid == 0x11) {
6853                 nid_vol = nid - 0x7;
6854                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6855                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6856         } else if (nid >= 0x12 && nid <= 0x15) {
6857                 nid_vol = 0x08;
6858                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6859                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6860         } else
6861                 return 0; /* N/A */
6862
6863         if (!(*vol_bits & (1 << nid_vol))) {
6864                 /* first control for the volume widget */
6865                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6866                 if (err < 0)
6867                         return err;
6868                 *vol_bits |= (1 << nid_vol);
6869         }
6870         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6871         if (err < 0)
6872                 return err;
6873         return 1;
6874 }
6875
6876 /* add playback controls from the parsed DAC table */
6877 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6878                                              const struct auto_pin_cfg *cfg)
6879 {
6880         hda_nid_t nid;
6881         int err;
6882         int vols = 0;
6883
6884         spec->multiout.num_dacs = 1;
6885         spec->multiout.dac_nids = spec->private_dac_nids;
6886         spec->multiout.dac_nids[0] = 0x02;
6887
6888         nid = cfg->line_out_pins[0];
6889         if (nid) {
6890                 const char *pfx;
6891                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6892                         pfx = "Master";
6893                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6894                         pfx = "Speaker";
6895                 else
6896                         pfx = "Front";
6897                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6898                 if (err < 0)
6899                         return err;
6900         }
6901
6902         nid = cfg->speaker_pins[0];
6903         if (nid) {
6904                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6905                 if (err < 0)
6906                         return err;
6907         }
6908
6909         nid = cfg->hp_pins[0];
6910         if (nid) {
6911                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6912                                                    &vols);
6913                 if (err < 0)
6914                         return err;
6915         }
6916         return 0;
6917 }
6918
6919 /* create playback/capture controls for input pins */
6920 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6921                                                 const struct auto_pin_cfg *cfg)
6922 {
6923         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6924 }
6925
6926 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6927                                               hda_nid_t nid, int pin_type,
6928                                               int sel_idx)
6929 {
6930         alc_set_pin_output(codec, nid, pin_type);
6931         /* need the manual connection? */
6932         if (nid >= 0x12) {
6933                 int idx = nid - 0x12;
6934                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6935                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6936         }
6937 }
6938
6939 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6940 {
6941         struct alc_spec *spec = codec->spec;
6942         hda_nid_t nid;
6943
6944         nid = spec->autocfg.line_out_pins[0];
6945         if (nid) {
6946                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6947                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6948         }
6949
6950         nid = spec->autocfg.speaker_pins[0];
6951         if (nid)
6952                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6953
6954         nid = spec->autocfg.hp_pins[0];
6955         if (nid)
6956                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6957 }
6958
6959 #define ALC260_PIN_CD_NID               0x16
6960 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6961 {
6962         struct alc_spec *spec = codec->spec;
6963         struct auto_pin_cfg *cfg = &spec->autocfg;
6964         int i;
6965
6966         for (i = 0; i < cfg->num_inputs; i++) {
6967                 hda_nid_t nid = cfg->inputs[i].pin;
6968                 if (nid >= 0x12) {
6969                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6970                         if (nid != ALC260_PIN_CD_NID &&
6971                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6972                                 snd_hda_codec_write(codec, nid, 0,
6973                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6974                                                     AMP_OUT_MUTE);
6975                 }
6976         }
6977 }
6978
6979 #define alc260_auto_init_input_src      alc880_auto_init_input_src
6980
6981 /*
6982  * generic initialization of ADC, input mixers and output mixers
6983  */
6984 static struct hda_verb alc260_volume_init_verbs[] = {
6985         /*
6986          * Unmute ADC0-1 and set the default input to mic-in
6987          */
6988         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6989         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6990         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6991         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6992
6993         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6994          * mixer widget
6995          * Note: PASD motherboards uses the Line In 2 as the input for
6996          * front panel mic (mic 2)
6997          */
6998         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6999         /* mute analog inputs */
7000         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7001         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7002         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7003         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7004         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7005
7006         /*
7007          * Set up output mixers (0x08 - 0x0a)
7008          */
7009         /* set vol=0 to output mixers */
7010         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7011         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7012         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7013         /* set up input amps for analog loopback */
7014         /* Amp Indices: DAC = 0, mixer = 1 */
7015         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7016         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7017         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7018         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7019         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7020         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7021
7022         { }
7023 };
7024
7025 static int alc260_parse_auto_config(struct hda_codec *codec)
7026 {
7027         struct alc_spec *spec = codec->spec;
7028         int err;
7029         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
7030
7031         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7032                                            alc260_ignore);
7033         if (err < 0)
7034                 return err;
7035         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7036         if (err < 0)
7037                 return err;
7038         if (!spec->kctls.list)
7039                 return 0; /* can't find valid BIOS pin config */
7040         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7041         if (err < 0)
7042                 return err;
7043
7044         spec->multiout.max_channels = 2;
7045
7046         if (spec->autocfg.dig_outs)
7047                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7048         if (spec->kctls.list)
7049                 add_mixer(spec, spec->kctls.list);
7050
7051         add_verb(spec, alc260_volume_init_verbs);
7052
7053         spec->num_mux_defs = 1;
7054         spec->input_mux = &spec->private_imux[0];
7055
7056         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7057
7058         return 1;
7059 }
7060
7061 /* additional initialization for auto-configuration model */
7062 static void alc260_auto_init(struct hda_codec *codec)
7063 {
7064         struct alc_spec *spec = codec->spec;
7065         alc260_auto_init_multi_out(codec);
7066         alc260_auto_init_analog_input(codec);
7067         alc260_auto_init_input_src(codec);
7068         alc_auto_init_digital(codec);
7069         if (spec->unsol_event)
7070                 alc_inithook(codec);
7071 }
7072
7073 #ifdef CONFIG_SND_HDA_POWER_SAVE
7074 static struct hda_amp_list alc260_loopbacks[] = {
7075         { 0x07, HDA_INPUT, 0 },
7076         { 0x07, HDA_INPUT, 1 },
7077         { 0x07, HDA_INPUT, 2 },
7078         { 0x07, HDA_INPUT, 3 },
7079         { 0x07, HDA_INPUT, 4 },
7080         { } /* end */
7081 };
7082 #endif
7083
7084 /*
7085  * Pin config fixes
7086  */
7087 enum {
7088         PINFIX_HP_DC5750,
7089 };
7090
7091 static const struct alc_fixup alc260_fixups[] = {
7092         [PINFIX_HP_DC5750] = {
7093                 .pins = (const struct alc_pincfg[]) {
7094                         { 0x11, 0x90130110 }, /* speaker */
7095                         { }
7096                 }
7097         },
7098 };
7099
7100 static struct snd_pci_quirk alc260_fixup_tbl[] = {
7101         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7102         {}
7103 };
7104
7105 /*
7106  * ALC260 configurations
7107  */
7108 static const char *alc260_models[ALC260_MODEL_LAST] = {
7109         [ALC260_BASIC]          = "basic",
7110         [ALC260_HP]             = "hp",
7111         [ALC260_HP_3013]        = "hp-3013",
7112         [ALC260_HP_DC7600]      = "hp-dc7600",
7113         [ALC260_FUJITSU_S702X]  = "fujitsu",
7114         [ALC260_ACER]           = "acer",
7115         [ALC260_WILL]           = "will",
7116         [ALC260_REPLACER_672V]  = "replacer",
7117         [ALC260_FAVORIT100]     = "favorit100",
7118 #ifdef CONFIG_SND_DEBUG
7119         [ALC260_TEST]           = "test",
7120 #endif
7121         [ALC260_AUTO]           = "auto",
7122 };
7123
7124 static struct snd_pci_quirk alc260_cfg_tbl[] = {
7125         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7126         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7127         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7128         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7129         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7130         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7131         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7132         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7133         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7134         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7135         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7136         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7137         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7138         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7139         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7140         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7141         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7142         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7143         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7144         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7145         {}
7146 };
7147
7148 static struct alc_config_preset alc260_presets[] = {
7149         [ALC260_BASIC] = {
7150                 .mixers = { alc260_base_output_mixer,
7151                             alc260_input_mixer },
7152                 .init_verbs = { alc260_init_verbs },
7153                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7154                 .dac_nids = alc260_dac_nids,
7155                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7156                 .adc_nids = alc260_dual_adc_nids,
7157                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7158                 .channel_mode = alc260_modes,
7159                 .input_mux = &alc260_capture_source,
7160         },
7161         [ALC260_HP] = {
7162                 .mixers = { alc260_hp_output_mixer,
7163                             alc260_input_mixer },
7164                 .init_verbs = { alc260_init_verbs,
7165                                 alc260_hp_unsol_verbs },
7166                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7167                 .dac_nids = alc260_dac_nids,
7168                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7169                 .adc_nids = alc260_adc_nids_alt,
7170                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7171                 .channel_mode = alc260_modes,
7172                 .input_mux = &alc260_capture_source,
7173                 .unsol_event = alc260_hp_unsol_event,
7174                 .init_hook = alc260_hp_automute,
7175         },
7176         [ALC260_HP_DC7600] = {
7177                 .mixers = { alc260_hp_dc7600_mixer,
7178                             alc260_input_mixer },
7179                 .init_verbs = { alc260_init_verbs,
7180                                 alc260_hp_dc7600_verbs },
7181                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7182                 .dac_nids = alc260_dac_nids,
7183                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7184                 .adc_nids = alc260_adc_nids_alt,
7185                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7186                 .channel_mode = alc260_modes,
7187                 .input_mux = &alc260_capture_source,
7188                 .unsol_event = alc260_hp_3012_unsol_event,
7189                 .init_hook = alc260_hp_3012_automute,
7190         },
7191         [ALC260_HP_3013] = {
7192                 .mixers = { alc260_hp_3013_mixer,
7193                             alc260_input_mixer },
7194                 .init_verbs = { alc260_hp_3013_init_verbs,
7195                                 alc260_hp_3013_unsol_verbs },
7196                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7197                 .dac_nids = alc260_dac_nids,
7198                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7199                 .adc_nids = alc260_adc_nids_alt,
7200                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7201                 .channel_mode = alc260_modes,
7202                 .input_mux = &alc260_capture_source,
7203                 .unsol_event = alc260_hp_3013_unsol_event,
7204                 .init_hook = alc260_hp_3013_automute,
7205         },
7206         [ALC260_FUJITSU_S702X] = {
7207                 .mixers = { alc260_fujitsu_mixer },
7208                 .init_verbs = { alc260_fujitsu_init_verbs },
7209                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7210                 .dac_nids = alc260_dac_nids,
7211                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7212                 .adc_nids = alc260_dual_adc_nids,
7213                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7214                 .channel_mode = alc260_modes,
7215                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7216                 .input_mux = alc260_fujitsu_capture_sources,
7217         },
7218         [ALC260_ACER] = {
7219                 .mixers = { alc260_acer_mixer },
7220                 .init_verbs = { alc260_acer_init_verbs },
7221                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7222                 .dac_nids = alc260_dac_nids,
7223                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7224                 .adc_nids = alc260_dual_adc_nids,
7225                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7226                 .channel_mode = alc260_modes,
7227                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7228                 .input_mux = alc260_acer_capture_sources,
7229         },
7230         [ALC260_FAVORIT100] = {
7231                 .mixers = { alc260_favorit100_mixer },
7232                 .init_verbs = { alc260_favorit100_init_verbs },
7233                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7234                 .dac_nids = alc260_dac_nids,
7235                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7236                 .adc_nids = alc260_dual_adc_nids,
7237                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7238                 .channel_mode = alc260_modes,
7239                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7240                 .input_mux = alc260_favorit100_capture_sources,
7241         },
7242         [ALC260_WILL] = {
7243                 .mixers = { alc260_will_mixer },
7244                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
7245                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7246                 .dac_nids = alc260_dac_nids,
7247                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7248                 .adc_nids = alc260_adc_nids,
7249                 .dig_out_nid = ALC260_DIGOUT_NID,
7250                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7251                 .channel_mode = alc260_modes,
7252                 .input_mux = &alc260_capture_source,
7253         },
7254         [ALC260_REPLACER_672V] = {
7255                 .mixers = { alc260_replacer_672v_mixer },
7256                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7257                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
7258                 .dac_nids = alc260_dac_nids,
7259                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7260                 .adc_nids = alc260_adc_nids,
7261                 .dig_out_nid = ALC260_DIGOUT_NID,
7262                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7263                 .channel_mode = alc260_modes,
7264                 .input_mux = &alc260_capture_source,
7265                 .unsol_event = alc260_replacer_672v_unsol_event,
7266                 .init_hook = alc260_replacer_672v_automute,
7267         },
7268 #ifdef CONFIG_SND_DEBUG
7269         [ALC260_TEST] = {
7270                 .mixers = { alc260_test_mixer },
7271                 .init_verbs = { alc260_test_init_verbs },
7272                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7273                 .dac_nids = alc260_test_dac_nids,
7274                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7275                 .adc_nids = alc260_test_adc_nids,
7276                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7277                 .channel_mode = alc260_modes,
7278                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7279                 .input_mux = alc260_test_capture_sources,
7280         },
7281 #endif
7282 };
7283
7284 static int patch_alc260(struct hda_codec *codec)
7285 {
7286         struct alc_spec *spec;
7287         int err, board_config;
7288
7289         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7290         if (spec == NULL)
7291                 return -ENOMEM;
7292
7293         codec->spec = spec;
7294
7295         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7296                                                   alc260_models,
7297                                                   alc260_cfg_tbl);
7298         if (board_config < 0) {
7299                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7300                            codec->chip_name);
7301                 board_config = ALC260_AUTO;
7302         }
7303
7304         if (board_config == ALC260_AUTO)
7305                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7306
7307         if (board_config == ALC260_AUTO) {
7308                 /* automatic parse from the BIOS config */
7309                 err = alc260_parse_auto_config(codec);
7310                 if (err < 0) {
7311                         alc_free(codec);
7312                         return err;
7313                 } else if (!err) {
7314                         printk(KERN_INFO
7315                                "hda_codec: Cannot set up configuration "
7316                                "from BIOS.  Using base mode...\n");
7317                         board_config = ALC260_BASIC;
7318                 }
7319         }
7320
7321         err = snd_hda_attach_beep_device(codec, 0x1);
7322         if (err < 0) {
7323                 alc_free(codec);
7324                 return err;
7325         }
7326
7327         if (board_config != ALC260_AUTO)
7328                 setup_preset(codec, &alc260_presets[board_config]);
7329
7330         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7331         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7332         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7333
7334         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7335         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7336
7337         if (!spec->adc_nids && spec->input_mux) {
7338                 /* check whether NID 0x04 is valid */
7339                 unsigned int wcap = get_wcaps(codec, 0x04);
7340                 wcap = get_wcaps_type(wcap);
7341                 /* get type */
7342                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7343                         spec->adc_nids = alc260_adc_nids_alt;
7344                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7345                 } else {
7346                         spec->adc_nids = alc260_adc_nids;
7347                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7348                 }
7349         }
7350         set_capture_mixer(codec);
7351         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7352
7353         if (board_config == ALC260_AUTO)
7354                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7355
7356         spec->vmaster_nid = 0x08;
7357
7358         codec->patch_ops = alc_patch_ops;
7359         if (board_config == ALC260_AUTO)
7360                 spec->init_hook = alc260_auto_init;
7361 #ifdef CONFIG_SND_HDA_POWER_SAVE
7362         if (!spec->loopback.amplist)
7363                 spec->loopback.amplist = alc260_loopbacks;
7364 #endif
7365
7366         return 0;
7367 }
7368
7369
7370 /*
7371  * ALC882/883/885/888/889 support
7372  *
7373  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7374  * configuration.  Each pin widget can choose any input DACs and a mixer.
7375  * Each ADC is connected from a mixer of all inputs.  This makes possible
7376  * 6-channel independent captures.
7377  *
7378  * In addition, an independent DAC for the multi-playback (not used in this
7379  * driver yet).
7380  */
7381 #define ALC882_DIGOUT_NID       0x06
7382 #define ALC882_DIGIN_NID        0x0a
7383 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7384 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7385 #define ALC1200_DIGOUT_NID      0x10
7386
7387
7388 static struct hda_channel_mode alc882_ch_modes[1] = {
7389         { 8, NULL }
7390 };
7391
7392 /* DACs */
7393 static hda_nid_t alc882_dac_nids[4] = {
7394         /* front, rear, clfe, rear_surr */
7395         0x02, 0x03, 0x04, 0x05
7396 };
7397 #define alc883_dac_nids         alc882_dac_nids
7398
7399 /* ADCs */
7400 #define alc882_adc_nids         alc880_adc_nids
7401 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7402 #define alc883_adc_nids         alc882_adc_nids_alt
7403 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7404 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7405 #define alc889_adc_nids         alc880_adc_nids
7406
7407 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7408 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7409 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7410 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7411 #define alc889_capsrc_nids      alc882_capsrc_nids
7412
7413 /* input MUX */
7414 /* FIXME: should be a matrix-type input source selection */
7415
7416 static struct hda_input_mux alc882_capture_source = {
7417         .num_items = 4,
7418         .items = {
7419                 { "Mic", 0x0 },
7420                 { "Front Mic", 0x1 },
7421                 { "Line", 0x2 },
7422                 { "CD", 0x4 },
7423         },
7424 };
7425
7426 #define alc883_capture_source   alc882_capture_source
7427
7428 static struct hda_input_mux alc889_capture_source = {
7429         .num_items = 3,
7430         .items = {
7431                 { "Front Mic", 0x0 },
7432                 { "Mic", 0x3 },
7433                 { "Line", 0x2 },
7434         },
7435 };
7436
7437 static struct hda_input_mux mb5_capture_source = {
7438         .num_items = 3,
7439         .items = {
7440                 { "Mic", 0x1 },
7441                 { "Line", 0x7 },
7442                 { "CD", 0x4 },
7443         },
7444 };
7445
7446 static struct hda_input_mux macmini3_capture_source = {
7447         .num_items = 2,
7448         .items = {
7449                 { "Line", 0x2 },
7450                 { "CD", 0x4 },
7451         },
7452 };
7453
7454 static struct hda_input_mux alc883_3stack_6ch_intel = {
7455         .num_items = 4,
7456         .items = {
7457                 { "Mic", 0x1 },
7458                 { "Front Mic", 0x0 },
7459                 { "Line", 0x2 },
7460                 { "CD", 0x4 },
7461         },
7462 };
7463
7464 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7465         .num_items = 2,
7466         .items = {
7467                 { "Mic", 0x1 },
7468                 { "Line", 0x2 },
7469         },
7470 };
7471
7472 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7473         .num_items = 4,
7474         .items = {
7475                 { "Mic", 0x0 },
7476                 { "Internal Mic", 0x1 },
7477                 { "Line", 0x2 },
7478                 { "CD", 0x4 },
7479         },
7480 };
7481
7482 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7483         .num_items = 2,
7484         .items = {
7485                 { "Mic", 0x0 },
7486                 { "Internal Mic", 0x1 },
7487         },
7488 };
7489
7490 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7491         .num_items = 3,
7492         .items = {
7493                 { "Mic", 0x0 },
7494                 { "Front Mic", 0x1 },
7495                 { "Line", 0x4 },
7496         },
7497 };
7498
7499 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7500         .num_items = 2,
7501         .items = {
7502                 { "Mic", 0x0 },
7503                 { "Line", 0x2 },
7504         },
7505 };
7506
7507 static struct hda_input_mux alc889A_mb31_capture_source = {
7508         .num_items = 2,
7509         .items = {
7510                 { "Mic", 0x0 },
7511                 /* Front Mic (0x01) unused */
7512                 { "Line", 0x2 },
7513                 /* Line 2 (0x03) unused */
7514                 /* CD (0x04) unused? */
7515         },
7516 };
7517
7518 static struct hda_input_mux alc889A_imac91_capture_source = {
7519         .num_items = 2,
7520         .items = {
7521                 { "Mic", 0x01 },
7522                 { "Line", 0x2 }, /* Not sure! */
7523         },
7524 };
7525
7526 /*
7527  * 2ch mode
7528  */
7529 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7530         { 2, NULL }
7531 };
7532
7533 /*
7534  * 2ch mode
7535  */
7536 static struct hda_verb alc882_3ST_ch2_init[] = {
7537         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7538         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7539         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7540         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7541         { } /* end */
7542 };
7543
7544 /*
7545  * 4ch mode
7546  */
7547 static struct hda_verb alc882_3ST_ch4_init[] = {
7548         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7549         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7550         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7551         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7552         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7553         { } /* end */
7554 };
7555
7556 /*
7557  * 6ch mode
7558  */
7559 static struct hda_verb alc882_3ST_ch6_init[] = {
7560         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7561         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7562         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7563         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7564         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7565         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7566         { } /* end */
7567 };
7568
7569 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7570         { 2, alc882_3ST_ch2_init },
7571         { 4, alc882_3ST_ch4_init },
7572         { 6, alc882_3ST_ch6_init },
7573 };
7574
7575 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7576
7577 /*
7578  * 2ch mode
7579  */
7580 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7581         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7582         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7583         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7584         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7585         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7586         { } /* end */
7587 };
7588
7589 /*
7590  * 4ch mode
7591  */
7592 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7593         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7594         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7595         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7596         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7597         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7598         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7599         { } /* end */
7600 };
7601
7602 /*
7603  * 6ch mode
7604  */
7605 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7606         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7607         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7608         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7609         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7610         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7611         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7612         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7613         { } /* end */
7614 };
7615
7616 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7617         { 2, alc883_3ST_ch2_clevo_init },
7618         { 4, alc883_3ST_ch4_clevo_init },
7619         { 6, alc883_3ST_ch6_clevo_init },
7620 };
7621
7622
7623 /*
7624  * 6ch mode
7625  */
7626 static struct hda_verb alc882_sixstack_ch6_init[] = {
7627         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7628         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7629         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7630         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7631         { } /* end */
7632 };
7633
7634 /*
7635  * 8ch mode
7636  */
7637 static struct hda_verb alc882_sixstack_ch8_init[] = {
7638         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7639         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7640         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7641         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7642         { } /* end */
7643 };
7644
7645 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7646         { 6, alc882_sixstack_ch6_init },
7647         { 8, alc882_sixstack_ch8_init },
7648 };
7649
7650
7651 /* Macbook Air 2,1 */
7652
7653 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7654       { 2, NULL },
7655 };
7656
7657 /*
7658  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7659  */
7660
7661 /*
7662  * 2ch mode
7663  */
7664 static struct hda_verb alc885_mbp_ch2_init[] = {
7665         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7666         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7667         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7668         { } /* end */
7669 };
7670
7671 /*
7672  * 4ch mode
7673  */
7674 static struct hda_verb alc885_mbp_ch4_init[] = {
7675         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7676         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7677         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7678         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7679         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7680         { } /* end */
7681 };
7682
7683 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7684         { 2, alc885_mbp_ch2_init },
7685         { 4, alc885_mbp_ch4_init },
7686 };
7687
7688 /*
7689  * 2ch
7690  * Speakers/Woofer/HP = Front
7691  * LineIn = Input
7692  */
7693 static struct hda_verb alc885_mb5_ch2_init[] = {
7694         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7695         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7696         { } /* end */
7697 };
7698
7699 /*
7700  * 6ch mode
7701  * Speakers/HP = Front
7702  * Woofer = LFE
7703  * LineIn = Surround
7704  */
7705 static struct hda_verb alc885_mb5_ch6_init[] = {
7706         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7707         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7708         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7709         { } /* end */
7710 };
7711
7712 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7713         { 2, alc885_mb5_ch2_init },
7714         { 6, alc885_mb5_ch6_init },
7715 };
7716
7717 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7718
7719 /*
7720  * 2ch mode
7721  */
7722 static struct hda_verb alc883_4ST_ch2_init[] = {
7723         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7724         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7725         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7726         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7727         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7728         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7729         { } /* end */
7730 };
7731
7732 /*
7733  * 4ch mode
7734  */
7735 static struct hda_verb alc883_4ST_ch4_init[] = {
7736         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7737         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7738         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7739         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7740         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7741         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7742         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7743         { } /* end */
7744 };
7745
7746 /*
7747  * 6ch mode
7748  */
7749 static struct hda_verb alc883_4ST_ch6_init[] = {
7750         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7751         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7752         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7753         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7754         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7755         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7756         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7757         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7758         { } /* end */
7759 };
7760
7761 /*
7762  * 8ch mode
7763  */
7764 static struct hda_verb alc883_4ST_ch8_init[] = {
7765         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7766         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7767         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7768         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7769         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7770         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7771         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7772         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7773         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7774         { } /* end */
7775 };
7776
7777 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7778         { 2, alc883_4ST_ch2_init },
7779         { 4, alc883_4ST_ch4_init },
7780         { 6, alc883_4ST_ch6_init },
7781         { 8, alc883_4ST_ch8_init },
7782 };
7783
7784
7785 /*
7786  * 2ch mode
7787  */
7788 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7789         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7790         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7791         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7792         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7793         { } /* end */
7794 };
7795
7796 /*
7797  * 4ch mode
7798  */
7799 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7800         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7801         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7802         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7803         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7804         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7805         { } /* end */
7806 };
7807
7808 /*
7809  * 6ch mode
7810  */
7811 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7812         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7813         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7814         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7815         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7816         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7817         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7818         { } /* end */
7819 };
7820
7821 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7822         { 2, alc883_3ST_ch2_intel_init },
7823         { 4, alc883_3ST_ch4_intel_init },
7824         { 6, alc883_3ST_ch6_intel_init },
7825 };
7826
7827 /*
7828  * 2ch mode
7829  */
7830 static struct hda_verb alc889_ch2_intel_init[] = {
7831         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7832         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7833         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7834         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7835         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7836         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7837         { } /* end */
7838 };
7839
7840 /*
7841  * 6ch mode
7842  */
7843 static struct hda_verb alc889_ch6_intel_init[] = {
7844         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7845         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7846         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7847         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7848         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7849         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7850         { } /* end */
7851 };
7852
7853 /*
7854  * 8ch mode
7855  */
7856 static struct hda_verb alc889_ch8_intel_init[] = {
7857         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7858         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7859         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7860         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7861         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7862         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7863         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7864         { } /* end */
7865 };
7866
7867 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7868         { 2, alc889_ch2_intel_init },
7869         { 6, alc889_ch6_intel_init },
7870         { 8, alc889_ch8_intel_init },
7871 };
7872
7873 /*
7874  * 6ch mode
7875  */
7876 static struct hda_verb alc883_sixstack_ch6_init[] = {
7877         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7878         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7879         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7880         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7881         { } /* end */
7882 };
7883
7884 /*
7885  * 8ch mode
7886  */
7887 static struct hda_verb alc883_sixstack_ch8_init[] = {
7888         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7889         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7890         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7891         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7892         { } /* end */
7893 };
7894
7895 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7896         { 6, alc883_sixstack_ch6_init },
7897         { 8, alc883_sixstack_ch8_init },
7898 };
7899
7900
7901 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7902  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7903  */
7904 static struct snd_kcontrol_new alc882_base_mixer[] = {
7905         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7906         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7907         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7908         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7909         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7910         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7911         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7912         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7913         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7914         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7915         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7916         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7917         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7918         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7919         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7920         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7921         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
7922         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7923         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7924         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
7925         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7926         { } /* end */
7927 };
7928
7929 /* Macbook Air 2,1 same control for HP and internal Speaker */
7930
7931 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7932       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7933       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7934      { }
7935 };
7936
7937
7938 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7939         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7940         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7941         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7942         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7943         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7944         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7945         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7946         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7947         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7948         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
7949         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
7950         { } /* end */
7951 };
7952
7953 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7954         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7955         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7956         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7957         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7958         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7959         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7960         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7961         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7962         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7963         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7964         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7965         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7966         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
7967         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
7968         { } /* end */
7969 };
7970
7971 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7972         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7973         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7974         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7975         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7976         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7977         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7978         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7979         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7980         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7981         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7982         HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
7983         { } /* end */
7984 };
7985
7986 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7987         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7988         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7989         { } /* end */
7990 };
7991
7992
7993 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7994         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7995         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7996         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7997         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7998         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7999         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8000         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8001         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8002         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8003         { } /* end */
8004 };
8005
8006 static struct snd_kcontrol_new alc882_targa_mixer[] = {
8007         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8008         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8009         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8010         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8011         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8012         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8013         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8014         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8015         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8016         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8017         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8018         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8019         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8020         { } /* end */
8021 };
8022
8023 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8024  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8025  */
8026 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8027         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8028         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8029         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8030         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8031         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8032         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8033         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8034         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8035         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8036         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8038         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8039         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8040         { } /* end */
8041 };
8042
8043 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8044         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8045         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8046         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8047         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8048         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8049         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8050         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8051         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8052         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8053         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8054         { } /* end */
8055 };
8056
8057 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
8058         {
8059                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8060                 .name = "Channel Mode",
8061                 .info = alc_ch_mode_info,
8062                 .get = alc_ch_mode_get,
8063                 .put = alc_ch_mode_put,
8064         },
8065         { } /* end */
8066 };
8067
8068 static struct hda_verb alc882_base_init_verbs[] = {
8069         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8070         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8071         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8072         /* Rear mixer */
8073         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8074         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8075         /* CLFE mixer */
8076         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8077         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8078         /* Side mixer */
8079         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8080         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8081
8082         /* Front Pin: output 0 (0x0c) */
8083         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8084         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8085         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8086         /* Rear Pin: output 1 (0x0d) */
8087         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8088         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8089         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8090         /* CLFE Pin: output 2 (0x0e) */
8091         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8092         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8093         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8094         /* Side Pin: output 3 (0x0f) */
8095         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8096         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8097         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8098         /* Mic (rear) pin: input vref at 80% */
8099         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8100         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8101         /* Front Mic pin: input vref at 80% */
8102         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8103         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8104         /* Line In pin: input */
8105         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8106         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8107         /* Line-2 In: Headphone output (output 0 - 0x0c) */
8108         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8109         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8110         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8111         /* CD pin widget for input */
8112         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8113
8114         /* FIXME: use matrix-type input source selection */
8115         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8116         /* Input mixer2 */
8117         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8118         /* Input mixer3 */
8119         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8120         /* ADC2: mute amp left and right */
8121         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8122         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8123         /* ADC3: mute amp left and right */
8124         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8125         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8126
8127         { }
8128 };
8129
8130 static struct hda_verb alc882_adc1_init_verbs[] = {
8131         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8132         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8133         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8134         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8135         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8136         /* ADC1: mute amp left and right */
8137         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8138         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8139         { }
8140 };
8141
8142 static struct hda_verb alc882_eapd_verbs[] = {
8143         /* change to EAPD mode */
8144         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8145         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8146         { }
8147 };
8148
8149 static struct hda_verb alc889_eapd_verbs[] = {
8150         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8151         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8152         { }
8153 };
8154
8155 static struct hda_verb alc_hp15_unsol_verbs[] = {
8156         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8157         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8158         {}
8159 };
8160
8161 static struct hda_verb alc885_init_verbs[] = {
8162         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8163         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8164         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8165         /* Rear mixer */
8166         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8167         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8168         /* CLFE mixer */
8169         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8170         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8171         /* Side mixer */
8172         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8173         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8174
8175         /* Front HP Pin: output 0 (0x0c) */
8176         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8177         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8178         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8179         /* Front Pin: output 0 (0x0c) */
8180         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8181         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8182         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8183         /* Rear Pin: output 1 (0x0d) */
8184         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8185         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8186         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8187         /* CLFE Pin: output 2 (0x0e) */
8188         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8189         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8190         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8191         /* Side Pin: output 3 (0x0f) */
8192         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8193         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8194         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8195         /* Mic (rear) pin: input vref at 80% */
8196         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8197         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8198         /* Front Mic pin: input vref at 80% */
8199         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8200         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8201         /* Line In pin: input */
8202         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8203         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8204
8205         /* Mixer elements: 0x18, , 0x1a, 0x1b */
8206         /* Input mixer1 */
8207         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8208         /* Input mixer2 */
8209         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8210         /* Input mixer3 */
8211         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8212         /* ADC2: mute amp left and right */
8213         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8214         /* ADC3: mute amp left and right */
8215         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8216
8217         { }
8218 };
8219
8220 static struct hda_verb alc885_init_input_verbs[] = {
8221         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8222         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8223         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8224         { }
8225 };
8226
8227
8228 /* Unmute Selector 24h and set the default input to front mic */
8229 static struct hda_verb alc889_init_input_verbs[] = {
8230         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8231         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8232         { }
8233 };
8234
8235
8236 #define alc883_init_verbs       alc882_base_init_verbs
8237
8238 /* Mac Pro test */
8239 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8240         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8241         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8242         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8243         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8244         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8245         /* FIXME: this looks suspicious...
8246         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8247         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8248         */
8249         { } /* end */
8250 };
8251
8252 static struct hda_verb alc882_macpro_init_verbs[] = {
8253         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8254         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8255         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8256         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8257         /* Front Pin: output 0 (0x0c) */
8258         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8259         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8260         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8261         /* Front Mic pin: input vref at 80% */
8262         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8263         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8264         /* Speaker:  output */
8265         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8266         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8267         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8268         /* Headphone output (output 0 - 0x0c) */
8269         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8270         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8271         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8272
8273         /* FIXME: use matrix-type input source selection */
8274         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8275         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8276         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8277         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8278         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8279         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8280         /* Input mixer2 */
8281         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8282         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8283         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8284         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8285         /* Input mixer3 */
8286         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8287         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8288         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8289         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8290         /* ADC1: mute amp left and right */
8291         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8292         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8293         /* ADC2: mute amp left and right */
8294         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8295         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8296         /* ADC3: mute amp left and right */
8297         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8298         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8299
8300         { }
8301 };
8302
8303 /* Macbook 5,1 */
8304 static struct hda_verb alc885_mb5_init_verbs[] = {
8305         /* DACs */
8306         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8307         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8308         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8309         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8310         /* Front mixer */
8311         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8312         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8313         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8314         /* Surround mixer */
8315         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8316         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8317         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8318         /* LFE mixer */
8319         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8320         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8321         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8322         /* HP mixer */
8323         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8324         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8325         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8326         /* Front Pin (0x0c) */
8327         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8328         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8329         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8330         /* LFE Pin (0x0e) */
8331         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8332         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8333         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8334         /* HP Pin (0x0f) */
8335         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8336         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8337         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8338         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8339         /* Front Mic pin: input vref at 80% */
8340         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8341         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8342         /* Line In pin */
8343         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8344         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8345
8346         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8347         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8348         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8349         { }
8350 };
8351
8352 /* Macmini 3,1 */
8353 static struct hda_verb alc885_macmini3_init_verbs[] = {
8354         /* DACs */
8355         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8356         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8357         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8358         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8359         /* Front mixer */
8360         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8361         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8362         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8363         /* Surround mixer */
8364         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8365         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8366         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8367         /* LFE mixer */
8368         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8369         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8370         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8371         /* HP mixer */
8372         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8373         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8374         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8375         /* Front Pin (0x0c) */
8376         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8377         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8378         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8379         /* LFE Pin (0x0e) */
8380         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8381         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8382         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8383         /* HP Pin (0x0f) */
8384         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8385         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8386         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8387         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8388         /* Line In pin */
8389         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8390         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8391
8392         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8393         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8394         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8395         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8396         { }
8397 };
8398
8399
8400 static struct hda_verb alc885_mba21_init_verbs[] = {
8401         /*Internal and HP Speaker Mixer*/
8402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8404         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8405         /*Internal Speaker Pin (0x0c)*/
8406         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8407         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8408         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8409         /* HP Pin: output 0 (0x0e) */
8410         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8411         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8412         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8413         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8414         /* Line in (is hp when jack connected)*/
8415         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8416         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8417
8418         { }
8419  };
8420
8421
8422 /* Macbook Pro rev3 */
8423 static struct hda_verb alc885_mbp3_init_verbs[] = {
8424         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8425         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8426         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8427         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8428         /* Rear mixer */
8429         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8430         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8431         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8432         /* HP mixer */
8433         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8434         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8435         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8436         /* Front Pin: output 0 (0x0c) */
8437         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8438         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8439         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8440         /* HP Pin: output 0 (0x0e) */
8441         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8442         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8443         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8444         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8445         /* Mic (rear) pin: input vref at 80% */
8446         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8447         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8448         /* Front Mic pin: input vref at 80% */
8449         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8450         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8451         /* Line In pin: use output 1 when in LineOut mode */
8452         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8453         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8454         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8455
8456         /* FIXME: use matrix-type input source selection */
8457         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8458         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8459         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8460         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8461         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8462         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8463         /* Input mixer2 */
8464         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8465         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8466         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8467         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8468         /* Input mixer3 */
8469         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8470         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8471         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8472         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8473         /* ADC1: mute amp left and right */
8474         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8475         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8476         /* ADC2: mute amp left and right */
8477         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8478         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8479         /* ADC3: mute amp left and right */
8480         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8481         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8482
8483         { }
8484 };
8485
8486 /* iMac 9,1 */
8487 static struct hda_verb alc885_imac91_init_verbs[] = {
8488         /* Internal Speaker Pin (0x0c) */
8489         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8490         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8491         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8492         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8493         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8494         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8495         /* HP Pin: Rear */
8496         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8497         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8498         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8499         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8500         /* Line in Rear */
8501         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8502         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8503         /* Front Mic pin: input vref at 80% */
8504         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8505         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8506         /* Rear mixer */
8507         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8508         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8510         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8511         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8512         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8513         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8514         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8515         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8516         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8517         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8518         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8519         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8520         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8521         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8522         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8523         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8524         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8525         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8526         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8527         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8528         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8529         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8530         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8531         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8532         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8533         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8534         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8535         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8536         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8537         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8538         { }
8539 };
8540
8541 /* iMac 24 mixer. */
8542 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8543         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8544         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8545         { } /* end */
8546 };
8547
8548 /* iMac 24 init verbs. */
8549 static struct hda_verb alc885_imac24_init_verbs[] = {
8550         /* Internal speakers: output 0 (0x0c) */
8551         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8552         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8553         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8554         /* Internal speakers: output 0 (0x0c) */
8555         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8556         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8557         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8558         /* Headphone: output 0 (0x0c) */
8559         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8560         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8561         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8562         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8563         /* Front Mic: input vref at 80% */
8564         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8565         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8566         { }
8567 };
8568
8569 /* Toggle speaker-output according to the hp-jack state */
8570 static void alc885_imac24_setup(struct hda_codec *codec)
8571 {
8572         struct alc_spec *spec = codec->spec;
8573
8574         spec->autocfg.hp_pins[0] = 0x14;
8575         spec->autocfg.speaker_pins[0] = 0x18;
8576         spec->autocfg.speaker_pins[1] = 0x1a;
8577 }
8578
8579 #define alc885_mb5_setup        alc885_imac24_setup
8580 #define alc885_macmini3_setup   alc885_imac24_setup
8581
8582 /* Macbook Air 2,1 */
8583 static void alc885_mba21_setup(struct hda_codec *codec)
8584 {
8585        struct alc_spec *spec = codec->spec;
8586
8587        spec->autocfg.hp_pins[0] = 0x14;
8588        spec->autocfg.speaker_pins[0] = 0x18;
8589 }
8590
8591
8592
8593 static void alc885_mbp3_setup(struct hda_codec *codec)
8594 {
8595         struct alc_spec *spec = codec->spec;
8596
8597         spec->autocfg.hp_pins[0] = 0x15;
8598         spec->autocfg.speaker_pins[0] = 0x14;
8599 }
8600
8601 static void alc885_imac91_setup(struct hda_codec *codec)
8602 {
8603         struct alc_spec *spec = codec->spec;
8604
8605         spec->autocfg.hp_pins[0] = 0x14;
8606         spec->autocfg.speaker_pins[0] = 0x18;
8607         spec->autocfg.speaker_pins[1] = 0x1a;
8608 }
8609
8610 static struct hda_verb alc882_targa_verbs[] = {
8611         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8612         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8613
8614         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8615         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8616
8617         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8618         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8619         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8620
8621         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8622         { } /* end */
8623 };
8624
8625 /* toggle speaker-output according to the hp-jack state */
8626 static void alc882_targa_automute(struct hda_codec *codec)
8627 {
8628         struct alc_spec *spec = codec->spec;
8629         alc_automute_amp(codec);
8630         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8631                                   spec->jack_present ? 1 : 3);
8632 }
8633
8634 static void alc882_targa_setup(struct hda_codec *codec)
8635 {
8636         struct alc_spec *spec = codec->spec;
8637
8638         spec->autocfg.hp_pins[0] = 0x14;
8639         spec->autocfg.speaker_pins[0] = 0x1b;
8640 }
8641
8642 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8643 {
8644         if ((res >> 26) == ALC880_HP_EVENT)
8645                 alc882_targa_automute(codec);
8646 }
8647
8648 static struct hda_verb alc882_asus_a7j_verbs[] = {
8649         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8650         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8651
8652         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8653         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8654         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8655
8656         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8657         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8658         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8659
8660         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8661         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8662         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8663         { } /* end */
8664 };
8665
8666 static struct hda_verb alc882_asus_a7m_verbs[] = {
8667         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8668         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8669
8670         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8671         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8672         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8673
8674         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8675         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8676         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8677
8678         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8679         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8680         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8681         { } /* end */
8682 };
8683
8684 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8685 {
8686         unsigned int gpiostate, gpiomask, gpiodir;
8687
8688         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8689                                        AC_VERB_GET_GPIO_DATA, 0);
8690
8691         if (!muted)
8692                 gpiostate |= (1 << pin);
8693         else
8694                 gpiostate &= ~(1 << pin);
8695
8696         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8697                                       AC_VERB_GET_GPIO_MASK, 0);
8698         gpiomask |= (1 << pin);
8699
8700         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8701                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8702         gpiodir |= (1 << pin);
8703
8704
8705         snd_hda_codec_write(codec, codec->afg, 0,
8706                             AC_VERB_SET_GPIO_MASK, gpiomask);
8707         snd_hda_codec_write(codec, codec->afg, 0,
8708                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8709
8710         msleep(1);
8711
8712         snd_hda_codec_write(codec, codec->afg, 0,
8713                             AC_VERB_SET_GPIO_DATA, gpiostate);
8714 }
8715
8716 /* set up GPIO at initialization */
8717 static void alc885_macpro_init_hook(struct hda_codec *codec)
8718 {
8719         alc882_gpio_mute(codec, 0, 0);
8720         alc882_gpio_mute(codec, 1, 0);
8721 }
8722
8723 /* set up GPIO and update auto-muting at initialization */
8724 static void alc885_imac24_init_hook(struct hda_codec *codec)
8725 {
8726         alc885_macpro_init_hook(codec);
8727         alc_automute_amp(codec);
8728 }
8729
8730 /*
8731  * generic initialization of ADC, input mixers and output mixers
8732  */
8733 static struct hda_verb alc883_auto_init_verbs[] = {
8734         /*
8735          * Unmute ADC0-2 and set the default input to mic-in
8736          */
8737         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8738         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8739         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8740         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8741
8742         /*
8743          * Set up output mixers (0x0c - 0x0f)
8744          */
8745         /* set vol=0 to output mixers */
8746         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8747         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8748         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8749         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8750         /* set up input amps for analog loopback */
8751         /* Amp Indices: DAC = 0, mixer = 1 */
8752         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8753         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8754         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8755         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8756         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8757         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8758         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8759         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8760         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8761         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8762
8763         /* FIXME: use matrix-type input source selection */
8764         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8765         /* Input mixer2 */
8766         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8767         /* Input mixer3 */
8768         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8769         { }
8770 };
8771
8772 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8773 static struct hda_verb alc889A_mb31_ch2_init[] = {
8774         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8775         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8776         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8777         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8778         { } /* end */
8779 };
8780
8781 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8782 static struct hda_verb alc889A_mb31_ch4_init[] = {
8783         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8784         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8785         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8786         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8787         { } /* end */
8788 };
8789
8790 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8791 static struct hda_verb alc889A_mb31_ch5_init[] = {
8792         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8793         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8794         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8795         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8796         { } /* end */
8797 };
8798
8799 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8800 static struct hda_verb alc889A_mb31_ch6_init[] = {
8801         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8802         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8803         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8804         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8805         { } /* end */
8806 };
8807
8808 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8809         { 2, alc889A_mb31_ch2_init },
8810         { 4, alc889A_mb31_ch4_init },
8811         { 5, alc889A_mb31_ch5_init },
8812         { 6, alc889A_mb31_ch6_init },
8813 };
8814
8815 static struct hda_verb alc883_medion_eapd_verbs[] = {
8816         /* eanable EAPD on medion laptop */
8817         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8818         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8819         { }
8820 };
8821
8822 #define alc883_base_mixer       alc882_base_mixer
8823
8824 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8825         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8826         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8827         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8828         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8829         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8830         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8831         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8832         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8833         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8834         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8835         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8836         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8837         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8838         { } /* end */
8839 };
8840
8841 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8842         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8843         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8844         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8845         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8846         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8847         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8848         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8849         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8850         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8851         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8852         { } /* end */
8853 };
8854
8855 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8856         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8857         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8858         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8859         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8860         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8861         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8862         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8863         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8864         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8865         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8866         { } /* end */
8867 };
8868
8869 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8870         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8871         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8872         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8873         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8874         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8875         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8876         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8877         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8878         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8879         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8880         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8881         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8882         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8883         { } /* end */
8884 };
8885
8886 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8887         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8888         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8889         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8890         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8891         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8892         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8893         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8894         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8895         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8896         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8897         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8898         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8899         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8900         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8901         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8902         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8903         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8904         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8905         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8906         { } /* end */
8907 };
8908
8909 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8910         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8911         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8912         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8913         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8914         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8915                               HDA_OUTPUT),
8916         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8917         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8918         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8919         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8920         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8921         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8922         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8923         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8924         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8925         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
8926         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8927         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8928         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
8929         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8930         { } /* end */
8931 };
8932
8933 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8934         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8935         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8936         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8937         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8938         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8939                               HDA_OUTPUT),
8940         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8941         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8942         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8943         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8944         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8945         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8946         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8947         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8948         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8949         HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
8950         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8951         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8952         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
8953         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8954         { } /* end */
8955 };
8956
8957 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8958         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8959         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8960         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8961         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8962         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8963         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8964         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8965         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8966         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8967         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8968         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8969         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8970         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8971         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8972         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8973         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8974         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8975         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8976         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8977         { } /* end */
8978 };
8979
8980 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8981         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8982         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8983         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8984         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8985         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8986         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8987         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8988         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8989         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8990         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8991         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8992         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8993         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8994         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8995         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8996         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8997         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8998         { } /* end */
8999 };
9000
9001 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9002         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9003         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9004         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9005         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9006         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9007         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9008         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9009         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9010         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9011         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9012         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9013         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9014         { } /* end */
9015 };
9016
9017 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9018         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9019         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9020         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9021         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9022         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9023         { } /* end */
9024 };
9025
9026 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9027         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9028         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9029         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9030         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9031         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9032         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9033         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9034         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9035         { } /* end */
9036 };
9037
9038 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9039         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9040         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9041         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9042         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9043         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9044         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9045         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9046         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9047         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9048         { } /* end */
9049 };
9050
9051 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9052         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9053         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9054         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9055         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9056         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9057         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9058         { } /* end */
9059 };
9060
9061 static struct hda_verb alc883_medion_wim2160_verbs[] = {
9062         /* Unmute front mixer */
9063         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9064         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9065
9066         /* Set speaker pin to front mixer */
9067         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9068
9069         /* Init headphone pin */
9070         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9071         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9072         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9073         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9074
9075         { } /* end */
9076 };
9077
9078 /* toggle speaker-output according to the hp-jack state */
9079 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9080 {
9081         struct alc_spec *spec = codec->spec;
9082
9083         spec->autocfg.hp_pins[0] = 0x1a;
9084         spec->autocfg.speaker_pins[0] = 0x15;
9085 }
9086
9087 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9088         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9089         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9090         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9091         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9092         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9093         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9094         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9095         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9096         { } /* end */
9097 };
9098
9099 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9100         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9101         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9102         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9103         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9104         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9105         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9106         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9107         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9109         { } /* end */
9110 };
9111
9112 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9113         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9114         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9115         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9116         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9117         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9118                                                 0x0d, 1, 0x0, HDA_OUTPUT),
9119         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9120         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9121         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9122         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9123         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9124         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9125         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9126         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9127         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9128         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9129         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9130         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9131         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9132         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9133         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9134         { } /* end */
9135 };
9136
9137 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9138         /* Output mixers */
9139         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9140         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9141         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9142         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9143         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9144                 HDA_OUTPUT),
9145         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9146         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9147         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9148         /* Output switches */
9149         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9150         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9151         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9152         /* Boost mixers */
9153         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9154         HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9155         /* Input mixers */
9156         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9157         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9158         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9159         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9160         { } /* end */
9161 };
9162
9163 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9164         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9165         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9166         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9167         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9168         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9169         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9170         { } /* end */
9171 };
9172
9173 static struct hda_bind_ctls alc883_bind_cap_vol = {
9174         .ops = &snd_hda_bind_vol,
9175         .values = {
9176                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9177                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9178                 0
9179         },
9180 };
9181
9182 static struct hda_bind_ctls alc883_bind_cap_switch = {
9183         .ops = &snd_hda_bind_sw,
9184         .values = {
9185                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9186                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9187                 0
9188         },
9189 };
9190
9191 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9192         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9193         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9194         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9195         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9196         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9197         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9198         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9199         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9200         { } /* end */
9201 };
9202
9203 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9204         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9205         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9206         {
9207                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9208                 /* .name = "Capture Source", */
9209                 .name = "Input Source",
9210                 .count = 1,
9211                 .info = alc_mux_enum_info,
9212                 .get = alc_mux_enum_get,
9213                 .put = alc_mux_enum_put,
9214         },
9215         { } /* end */
9216 };
9217
9218 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9219         {
9220                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9221                 .name = "Channel Mode",
9222                 .info = alc_ch_mode_info,
9223                 .get = alc_ch_mode_get,
9224                 .put = alc_ch_mode_put,
9225         },
9226         { } /* end */
9227 };
9228
9229 /* toggle speaker-output according to the hp-jack state */
9230 static void alc883_mitac_setup(struct hda_codec *codec)
9231 {
9232         struct alc_spec *spec = codec->spec;
9233
9234         spec->autocfg.hp_pins[0] = 0x15;
9235         spec->autocfg.speaker_pins[0] = 0x14;
9236         spec->autocfg.speaker_pins[1] = 0x17;
9237 }
9238
9239 static struct hda_verb alc883_mitac_verbs[] = {
9240         /* HP */
9241         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9242         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9243         /* Subwoofer */
9244         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9245         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9246
9247         /* enable unsolicited event */
9248         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9249         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9250
9251         { } /* end */
9252 };
9253
9254 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9255         /* HP */
9256         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9257         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9258         /* Int speaker */
9259         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9260
9261         /* enable unsolicited event */
9262         /*
9263         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9264         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9265         */
9266
9267         { } /* end */
9268 };
9269
9270 static struct hda_verb alc883_clevo_m720_verbs[] = {
9271         /* HP */
9272         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9273         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9274         /* Int speaker */
9275         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9276         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9277
9278         /* enable unsolicited event */
9279         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9280         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9281
9282         { } /* end */
9283 };
9284
9285 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9286         /* HP */
9287         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9288         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9289         /* Subwoofer */
9290         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9291         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9292
9293         /* enable unsolicited event */
9294         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9295
9296         { } /* end */
9297 };
9298
9299 static struct hda_verb alc883_targa_verbs[] = {
9300         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9301         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9302
9303         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9304         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9305
9306 /* Connect Line-Out side jack (SPDIF) to Side */
9307         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9308         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9309         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9310 /* Connect Mic jack to CLFE */
9311         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9312         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9313         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9314 /* Connect Line-in jack to Surround */
9315         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9316         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9317         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9318 /* Connect HP out jack to Front */
9319         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9320         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9321         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9322
9323         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9324
9325         { } /* end */
9326 };
9327
9328 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9329         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9330         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9331         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9332         { } /* end */
9333 };
9334
9335 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9336         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9337         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9338         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9339         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9340         { } /* end */
9341 };
9342
9343 static struct hda_verb alc888_lenovo_ms7195_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         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9347         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9348         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9349         { } /* end */
9350 };
9351
9352 static struct hda_verb alc883_haier_w66_verbs[] = {
9353         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9354         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9355
9356         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9357
9358         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9359         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9360         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9361         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9362         { } /* end */
9363 };
9364
9365 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9366         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9367         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9368         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9369         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9370         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9371         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9372         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9373         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9374         { } /* end */
9375 };
9376
9377 static struct hda_verb alc888_6st_dell_verbs[] = {
9378         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9379         { }
9380 };
9381
9382 static struct hda_verb alc883_vaiott_verbs[] = {
9383         /* HP */
9384         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9385         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9386
9387         /* enable unsolicited event */
9388         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9389
9390         { } /* end */
9391 };
9392
9393 static void alc888_3st_hp_setup(struct hda_codec *codec)
9394 {
9395         struct alc_spec *spec = codec->spec;
9396
9397         spec->autocfg.hp_pins[0] = 0x1b;
9398         spec->autocfg.speaker_pins[0] = 0x14;
9399         spec->autocfg.speaker_pins[1] = 0x16;
9400         spec->autocfg.speaker_pins[2] = 0x18;
9401 }
9402
9403 static struct hda_verb alc888_3st_hp_verbs[] = {
9404         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9405         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9406         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9407         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9408         { } /* end */
9409 };
9410
9411 /*
9412  * 2ch mode
9413  */
9414 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9415         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9416         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9417         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9418         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9419         { } /* end */
9420 };
9421
9422 /*
9423  * 4ch mode
9424  */
9425 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9426         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9427         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9428         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9429         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9430         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9431         { } /* end */
9432 };
9433
9434 /*
9435  * 6ch mode
9436  */
9437 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9438         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9439         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9440         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9441         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9442         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9443         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9444         { } /* end */
9445 };
9446
9447 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9448         { 2, alc888_3st_hp_2ch_init },
9449         { 4, alc888_3st_hp_4ch_init },
9450         { 6, alc888_3st_hp_6ch_init },
9451 };
9452
9453 /* toggle front-jack and RCA according to the hp-jack state */
9454 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9455 {
9456         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9457
9458         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9459                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9460         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9461                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9462 }
9463
9464 /* toggle RCA according to the front-jack state */
9465 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9466 {
9467         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9468
9469         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9470                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9471 }
9472
9473 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9474                                              unsigned int res)
9475 {
9476         if ((res >> 26) == ALC880_HP_EVENT)
9477                 alc888_lenovo_ms7195_front_automute(codec);
9478         if ((res >> 26) == ALC880_FRONT_EVENT)
9479                 alc888_lenovo_ms7195_rca_automute(codec);
9480 }
9481
9482 /* toggle speaker-output according to the hp-jack state */
9483 static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9484 {
9485         struct alc_spec *spec = codec->spec;
9486
9487         spec->autocfg.hp_pins[0] = 0x14;
9488         spec->autocfg.speaker_pins[0] = 0x15;
9489 }
9490
9491 /* toggle speaker-output according to the hp-jack state */
9492 #define alc883_targa_init_hook          alc882_targa_init_hook
9493 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9494
9495 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9496 {
9497         struct alc_spec *spec = codec->spec;
9498
9499         spec->autocfg.hp_pins[0] = 0x15;
9500         spec->autocfg.speaker_pins[0] = 0x14;
9501 }
9502
9503 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9504 {
9505         alc_automute_amp(codec);
9506         alc88x_simple_mic_automute(codec);
9507 }
9508
9509 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9510                                            unsigned int res)
9511 {
9512         switch (res >> 26) {
9513         case ALC880_MIC_EVENT:
9514                 alc88x_simple_mic_automute(codec);
9515                 break;
9516         default:
9517                 alc_automute_amp_unsol_event(codec, res);
9518                 break;
9519         }
9520 }
9521
9522 /* toggle speaker-output according to the hp-jack state */
9523 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9524 {
9525         struct alc_spec *spec = codec->spec;
9526
9527         spec->autocfg.hp_pins[0] = 0x14;
9528         spec->autocfg.speaker_pins[0] = 0x15;
9529 }
9530
9531 static void alc883_haier_w66_setup(struct hda_codec *codec)
9532 {
9533         struct alc_spec *spec = codec->spec;
9534
9535         spec->autocfg.hp_pins[0] = 0x1b;
9536         spec->autocfg.speaker_pins[0] = 0x14;
9537 }
9538
9539 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9540 {
9541         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9542
9543         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9544                                  HDA_AMP_MUTE, bits);
9545 }
9546
9547 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9548 {
9549         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9550
9551         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9552                                  HDA_AMP_MUTE, bits);
9553         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9554                                  HDA_AMP_MUTE, bits);
9555 }
9556
9557 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9558                                            unsigned int res)
9559 {
9560         if ((res >> 26) == ALC880_HP_EVENT)
9561                 alc883_lenovo_101e_all_automute(codec);
9562         if ((res >> 26) == ALC880_FRONT_EVENT)
9563                 alc883_lenovo_101e_ispeaker_automute(codec);
9564 }
9565
9566 /* toggle speaker-output according to the hp-jack state */
9567 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9568 {
9569         struct alc_spec *spec = codec->spec;
9570
9571         spec->autocfg.hp_pins[0] = 0x14;
9572         spec->autocfg.speaker_pins[0] = 0x15;
9573         spec->autocfg.speaker_pins[1] = 0x16;
9574 }
9575
9576 static struct hda_verb alc883_acer_eapd_verbs[] = {
9577         /* HP Pin: output 0 (0x0c) */
9578         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9579         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9580         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9581         /* Front Pin: output 0 (0x0c) */
9582         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9583         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9584         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9585         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9586         /* eanable EAPD on medion laptop */
9587         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9588         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9589         /* enable unsolicited event */
9590         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9591         { }
9592 };
9593
9594 static void alc888_6st_dell_setup(struct hda_codec *codec)
9595 {
9596         struct alc_spec *spec = codec->spec;
9597
9598         spec->autocfg.hp_pins[0] = 0x1b;
9599         spec->autocfg.speaker_pins[0] = 0x14;
9600         spec->autocfg.speaker_pins[1] = 0x15;
9601         spec->autocfg.speaker_pins[2] = 0x16;
9602         spec->autocfg.speaker_pins[3] = 0x17;
9603 }
9604
9605 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9606 {
9607         struct alc_spec *spec = codec->spec;
9608
9609         spec->autocfg.hp_pins[0] = 0x1b;
9610         spec->autocfg.speaker_pins[0] = 0x14;
9611         spec->autocfg.speaker_pins[1] = 0x15;
9612         spec->autocfg.speaker_pins[2] = 0x16;
9613         spec->autocfg.speaker_pins[3] = 0x17;
9614         spec->autocfg.speaker_pins[4] = 0x1a;
9615 }
9616
9617 static void alc883_vaiott_setup(struct hda_codec *codec)
9618 {
9619         struct alc_spec *spec = codec->spec;
9620
9621         spec->autocfg.hp_pins[0] = 0x15;
9622         spec->autocfg.speaker_pins[0] = 0x14;
9623         spec->autocfg.speaker_pins[1] = 0x17;
9624 }
9625
9626 static struct hda_verb alc888_asus_m90v_verbs[] = {
9627         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9628         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9629         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9630         /* enable unsolicited event */
9631         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9632         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9633         { } /* end */
9634 };
9635
9636 static void alc883_mode2_setup(struct hda_codec *codec)
9637 {
9638         struct alc_spec *spec = codec->spec;
9639
9640         spec->autocfg.hp_pins[0] = 0x1b;
9641         spec->autocfg.speaker_pins[0] = 0x14;
9642         spec->autocfg.speaker_pins[1] = 0x15;
9643         spec->autocfg.speaker_pins[2] = 0x16;
9644         spec->ext_mic.pin = 0x18;
9645         spec->int_mic.pin = 0x19;
9646         spec->ext_mic.mux_idx = 0;
9647         spec->int_mic.mux_idx = 1;
9648         spec->auto_mic = 1;
9649 }
9650
9651 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9652         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9653         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9654         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9655         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9656         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9657         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9658         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9659         /* enable unsolicited event */
9660         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9661         { } /* end */
9662 };
9663
9664 static void alc883_eee1601_inithook(struct hda_codec *codec)
9665 {
9666         struct alc_spec *spec = codec->spec;
9667
9668         spec->autocfg.hp_pins[0] = 0x14;
9669         spec->autocfg.speaker_pins[0] = 0x1b;
9670         alc_automute_pin(codec);
9671 }
9672
9673 static struct hda_verb alc889A_mb31_verbs[] = {
9674         /* Init rear pin (used as headphone output) */
9675         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9676         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9677         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9678         /* Init line pin (used as output in 4ch and 6ch mode) */
9679         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9680         /* Init line 2 pin (used as headphone out by default) */
9681         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9682         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9683         { } /* end */
9684 };
9685
9686 /* Mute speakers according to the headphone jack state */
9687 static void alc889A_mb31_automute(struct hda_codec *codec)
9688 {
9689         unsigned int present;
9690
9691         /* Mute only in 2ch or 4ch mode */
9692         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9693             == 0x00) {
9694                 present = snd_hda_jack_detect(codec, 0x15);
9695                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9696                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9697                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9698                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9699         }
9700 }
9701
9702 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9703 {
9704         if ((res >> 26) == ALC880_HP_EVENT)
9705                 alc889A_mb31_automute(codec);
9706 }
9707
9708
9709 #ifdef CONFIG_SND_HDA_POWER_SAVE
9710 #define alc882_loopbacks        alc880_loopbacks
9711 #endif
9712
9713 /* pcm configuration: identical with ALC880 */
9714 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9715 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9716 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9717 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9718
9719 static hda_nid_t alc883_slave_dig_outs[] = {
9720         ALC1200_DIGOUT_NID, 0,
9721 };
9722
9723 static hda_nid_t alc1200_slave_dig_outs[] = {
9724         ALC883_DIGOUT_NID, 0,
9725 };
9726
9727 /*
9728  * configuration and preset
9729  */
9730 static const char *alc882_models[ALC882_MODEL_LAST] = {
9731         [ALC882_3ST_DIG]        = "3stack-dig",
9732         [ALC882_6ST_DIG]        = "6stack-dig",
9733         [ALC882_ARIMA]          = "arima",
9734         [ALC882_W2JC]           = "w2jc",
9735         [ALC882_TARGA]          = "targa",
9736         [ALC882_ASUS_A7J]       = "asus-a7j",
9737         [ALC882_ASUS_A7M]       = "asus-a7m",
9738         [ALC885_MACPRO]         = "macpro",
9739         [ALC885_MB5]            = "mb5",
9740         [ALC885_MACMINI3]       = "macmini3",
9741         [ALC885_MBA21]          = "mba21",
9742         [ALC885_MBP3]           = "mbp3",
9743         [ALC885_IMAC24]         = "imac24",
9744         [ALC885_IMAC91]         = "imac91",
9745         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9746         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9747         [ALC883_3ST_6ch]        = "3stack-6ch",
9748         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9749         [ALC883_TARGA_DIG]      = "targa-dig",
9750         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9751         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9752         [ALC883_ACER]           = "acer",
9753         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9754         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9755         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9756         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9757         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9758         [ALC883_MEDION]         = "medion",
9759         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9760         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9761         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9762         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9763         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9764         [ALC888_LENOVO_SKY] = "lenovo-sky",
9765         [ALC883_HAIER_W66]      = "haier-w66",
9766         [ALC888_3ST_HP]         = "3stack-hp",
9767         [ALC888_6ST_DELL]       = "6stack-dell",
9768         [ALC883_MITAC]          = "mitac",
9769         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9770         [ALC883_CLEVO_M720]     = "clevo-m720",
9771         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9772         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9773         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9774         [ALC889A_INTEL]         = "intel-alc889a",
9775         [ALC889_INTEL]          = "intel-x58",
9776         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9777         [ALC889A_MB31]          = "mb31",
9778         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9779         [ALC882_AUTO]           = "auto",
9780 };
9781
9782 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9783         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9784
9785         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9786         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9787         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9788         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9789         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9790         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9791         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9792                 ALC888_ACER_ASPIRE_4930G),
9793         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9794                 ALC888_ACER_ASPIRE_4930G),
9795         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9796                 ALC888_ACER_ASPIRE_8930G),
9797         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9798                 ALC888_ACER_ASPIRE_8930G),
9799         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9800         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9801         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9802                 ALC888_ACER_ASPIRE_6530G),
9803         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9804                 ALC888_ACER_ASPIRE_6530G),
9805         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9806                 ALC888_ACER_ASPIRE_7730G),
9807         /* default Acer -- disabled as it causes more problems.
9808          *    model=auto should work fine now
9809          */
9810         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9811
9812         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9813
9814         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9815         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9816         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9817         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9818         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9819         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9820
9821         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9822         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9823         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9824         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9825         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9826         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9827         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9828         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9829         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9830         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9831         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9832
9833         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9834         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9835         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9836         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9837         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9838         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9839         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9840         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9841         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9842
9843         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9844         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9845         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9846         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9847         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9848         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9849         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9850         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9851         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9852         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9853         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9854         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9855         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9856         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9857         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9858         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9859         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9860         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9861         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9862         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9863         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9864         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9865         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9866         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9867         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9868         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9869         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9870         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9871         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9872         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9873         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9874
9875         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9876         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9877         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9878         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9879         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9880         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9881         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9882         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9883         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9884         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9885                       ALC883_FUJITSU_PI2515),
9886         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9887                 ALC888_FUJITSU_XA3530),
9888         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9889         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9890         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9891         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9892         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9893         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9894         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9895         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9896
9897         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9898         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9899         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9900         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9901         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9902         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9903         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9904
9905         {}
9906 };
9907
9908 /* codec SSID table for Intel Mac */
9909 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9910         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9911         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9912         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9913         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9914         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9915         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9916         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9917         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9918         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9919         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9920         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9921         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9922         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9923         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9924         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9925         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9926         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9927         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9928          * so apparently no perfect solution yet
9929          */
9930         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9931         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9932         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9933         {} /* terminator */
9934 };
9935
9936 static struct alc_config_preset alc882_presets[] = {
9937         [ALC882_3ST_DIG] = {
9938                 .mixers = { alc882_base_mixer },
9939                 .init_verbs = { alc882_base_init_verbs,
9940                                 alc882_adc1_init_verbs },
9941                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9942                 .dac_nids = alc882_dac_nids,
9943                 .dig_out_nid = ALC882_DIGOUT_NID,
9944                 .dig_in_nid = ALC882_DIGIN_NID,
9945                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9946                 .channel_mode = alc882_ch_modes,
9947                 .need_dac_fix = 1,
9948                 .input_mux = &alc882_capture_source,
9949         },
9950         [ALC882_6ST_DIG] = {
9951                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9952                 .init_verbs = { alc882_base_init_verbs,
9953                                 alc882_adc1_init_verbs },
9954                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9955                 .dac_nids = alc882_dac_nids,
9956                 .dig_out_nid = ALC882_DIGOUT_NID,
9957                 .dig_in_nid = ALC882_DIGIN_NID,
9958                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9959                 .channel_mode = alc882_sixstack_modes,
9960                 .input_mux = &alc882_capture_source,
9961         },
9962         [ALC882_ARIMA] = {
9963                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9964                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9965                                 alc882_eapd_verbs },
9966                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9967                 .dac_nids = alc882_dac_nids,
9968                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9969                 .channel_mode = alc882_sixstack_modes,
9970                 .input_mux = &alc882_capture_source,
9971         },
9972         [ALC882_W2JC] = {
9973                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9974                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9975                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9976                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9977                 .dac_nids = alc882_dac_nids,
9978                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9979                 .channel_mode = alc880_threestack_modes,
9980                 .need_dac_fix = 1,
9981                 .input_mux = &alc882_capture_source,
9982                 .dig_out_nid = ALC882_DIGOUT_NID,
9983         },
9984            [ALC885_MBA21] = {
9985                         .mixers = { alc885_mba21_mixer },
9986                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9987                         .num_dacs = 2,
9988                         .dac_nids = alc882_dac_nids,
9989                         .channel_mode = alc885_mba21_ch_modes,
9990                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9991                         .input_mux = &alc882_capture_source,
9992                         .unsol_event = alc_automute_amp_unsol_event,
9993                         .setup = alc885_mba21_setup,
9994                         .init_hook = alc_automute_amp,
9995        },
9996         [ALC885_MBP3] = {
9997                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9998                 .init_verbs = { alc885_mbp3_init_verbs,
9999                                 alc880_gpio1_init_verbs },
10000                 .num_dacs = 2,
10001                 .dac_nids = alc882_dac_nids,
10002                 .hp_nid = 0x04,
10003                 .channel_mode = alc885_mbp_4ch_modes,
10004                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10005                 .input_mux = &alc882_capture_source,
10006                 .dig_out_nid = ALC882_DIGOUT_NID,
10007                 .dig_in_nid = ALC882_DIGIN_NID,
10008                 .unsol_event = alc_automute_amp_unsol_event,
10009                 .setup = alc885_mbp3_setup,
10010                 .init_hook = alc_automute_amp,
10011         },
10012         [ALC885_MB5] = {
10013                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10014                 .init_verbs = { alc885_mb5_init_verbs,
10015                                 alc880_gpio1_init_verbs },
10016                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10017                 .dac_nids = alc882_dac_nids,
10018                 .channel_mode = alc885_mb5_6ch_modes,
10019                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10020                 .input_mux = &mb5_capture_source,
10021                 .dig_out_nid = ALC882_DIGOUT_NID,
10022                 .dig_in_nid = ALC882_DIGIN_NID,
10023                 .unsol_event = alc_automute_amp_unsol_event,
10024                 .setup = alc885_mb5_setup,
10025                 .init_hook = alc_automute_amp,
10026         },
10027         [ALC885_MACMINI3] = {
10028                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10029                 .init_verbs = { alc885_macmini3_init_verbs,
10030                                 alc880_gpio1_init_verbs },
10031                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10032                 .dac_nids = alc882_dac_nids,
10033                 .channel_mode = alc885_macmini3_6ch_modes,
10034                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10035                 .input_mux = &macmini3_capture_source,
10036                 .dig_out_nid = ALC882_DIGOUT_NID,
10037                 .dig_in_nid = ALC882_DIGIN_NID,
10038                 .unsol_event = alc_automute_amp_unsol_event,
10039                 .setup = alc885_macmini3_setup,
10040                 .init_hook = alc_automute_amp,
10041         },
10042         [ALC885_MACPRO] = {
10043                 .mixers = { alc882_macpro_mixer },
10044                 .init_verbs = { alc882_macpro_init_verbs },
10045                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10046                 .dac_nids = alc882_dac_nids,
10047                 .dig_out_nid = ALC882_DIGOUT_NID,
10048                 .dig_in_nid = ALC882_DIGIN_NID,
10049                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10050                 .channel_mode = alc882_ch_modes,
10051                 .input_mux = &alc882_capture_source,
10052                 .init_hook = alc885_macpro_init_hook,
10053         },
10054         [ALC885_IMAC24] = {
10055                 .mixers = { alc885_imac24_mixer },
10056                 .init_verbs = { alc885_imac24_init_verbs },
10057                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10058                 .dac_nids = alc882_dac_nids,
10059                 .dig_out_nid = ALC882_DIGOUT_NID,
10060                 .dig_in_nid = ALC882_DIGIN_NID,
10061                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10062                 .channel_mode = alc882_ch_modes,
10063                 .input_mux = &alc882_capture_source,
10064                 .unsol_event = alc_automute_amp_unsol_event,
10065                 .setup = alc885_imac24_setup,
10066                 .init_hook = alc885_imac24_init_hook,
10067         },
10068         [ALC885_IMAC91] = {
10069                 .mixers = {alc885_imac91_mixer},
10070                 .init_verbs = { alc885_imac91_init_verbs,
10071                                 alc880_gpio1_init_verbs },
10072                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10073                 .dac_nids = alc882_dac_nids,
10074                 .channel_mode = alc885_mba21_ch_modes,
10075                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10076                 .input_mux = &alc889A_imac91_capture_source,
10077                 .dig_out_nid = ALC882_DIGOUT_NID,
10078                 .dig_in_nid = ALC882_DIGIN_NID,
10079                 .unsol_event = alc_automute_amp_unsol_event,
10080                 .setup = alc885_imac91_setup,
10081                 .init_hook = alc_automute_amp,
10082         },
10083         [ALC882_TARGA] = {
10084                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10085                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10086                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
10087                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10088                 .dac_nids = alc882_dac_nids,
10089                 .dig_out_nid = ALC882_DIGOUT_NID,
10090                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10091                 .adc_nids = alc882_adc_nids,
10092                 .capsrc_nids = alc882_capsrc_nids,
10093                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10094                 .channel_mode = alc882_3ST_6ch_modes,
10095                 .need_dac_fix = 1,
10096                 .input_mux = &alc882_capture_source,
10097                 .unsol_event = alc882_targa_unsol_event,
10098                 .setup = alc882_targa_setup,
10099                 .init_hook = alc882_targa_automute,
10100         },
10101         [ALC882_ASUS_A7J] = {
10102                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10103                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10104                                 alc882_asus_a7j_verbs},
10105                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10106                 .dac_nids = alc882_dac_nids,
10107                 .dig_out_nid = ALC882_DIGOUT_NID,
10108                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10109                 .adc_nids = alc882_adc_nids,
10110                 .capsrc_nids = alc882_capsrc_nids,
10111                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10112                 .channel_mode = alc882_3ST_6ch_modes,
10113                 .need_dac_fix = 1,
10114                 .input_mux = &alc882_capture_source,
10115         },
10116         [ALC882_ASUS_A7M] = {
10117                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10118                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10119                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
10120                                 alc882_asus_a7m_verbs },
10121                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
10122                 .dac_nids = alc882_dac_nids,
10123                 .dig_out_nid = ALC882_DIGOUT_NID,
10124                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10125                 .channel_mode = alc880_threestack_modes,
10126                 .need_dac_fix = 1,
10127                 .input_mux = &alc882_capture_source,
10128         },
10129         [ALC883_3ST_2ch_DIG] = {
10130                 .mixers = { alc883_3ST_2ch_mixer },
10131                 .init_verbs = { alc883_init_verbs },
10132                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10133                 .dac_nids = alc883_dac_nids,
10134                 .dig_out_nid = ALC883_DIGOUT_NID,
10135                 .dig_in_nid = ALC883_DIGIN_NID,
10136                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10137                 .channel_mode = alc883_3ST_2ch_modes,
10138                 .input_mux = &alc883_capture_source,
10139         },
10140         [ALC883_3ST_6ch_DIG] = {
10141                 .mixers = { alc883_3ST_6ch_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                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10148                 .channel_mode = alc883_3ST_6ch_modes,
10149                 .need_dac_fix = 1,
10150                 .input_mux = &alc883_capture_source,
10151         },
10152         [ALC883_3ST_6ch] = {
10153                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10154                 .init_verbs = { alc883_init_verbs },
10155                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10156                 .dac_nids = alc883_dac_nids,
10157                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10158                 .channel_mode = alc883_3ST_6ch_modes,
10159                 .need_dac_fix = 1,
10160                 .input_mux = &alc883_capture_source,
10161         },
10162         [ALC883_3ST_6ch_INTEL] = {
10163                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10164                 .init_verbs = { alc883_init_verbs },
10165                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10166                 .dac_nids = alc883_dac_nids,
10167                 .dig_out_nid = ALC883_DIGOUT_NID,
10168                 .dig_in_nid = ALC883_DIGIN_NID,
10169                 .slave_dig_outs = alc883_slave_dig_outs,
10170                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10171                 .channel_mode = alc883_3ST_6ch_intel_modes,
10172                 .need_dac_fix = 1,
10173                 .input_mux = &alc883_3stack_6ch_intel,
10174         },
10175         [ALC889A_INTEL] = {
10176                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10177                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10178                                 alc_hp15_unsol_verbs },
10179                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10180                 .dac_nids = alc883_dac_nids,
10181                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10182                 .adc_nids = alc889_adc_nids,
10183                 .dig_out_nid = ALC883_DIGOUT_NID,
10184                 .dig_in_nid = ALC883_DIGIN_NID,
10185                 .slave_dig_outs = alc883_slave_dig_outs,
10186                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10187                 .channel_mode = alc889_8ch_intel_modes,
10188                 .capsrc_nids = alc889_capsrc_nids,
10189                 .input_mux = &alc889_capture_source,
10190                 .setup = alc889_automute_setup,
10191                 .init_hook = alc_automute_amp,
10192                 .unsol_event = alc_automute_amp_unsol_event,
10193                 .need_dac_fix = 1,
10194         },
10195         [ALC889_INTEL] = {
10196                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10197                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10198                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
10199                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10200                 .dac_nids = alc883_dac_nids,
10201                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10202                 .adc_nids = alc889_adc_nids,
10203                 .dig_out_nid = ALC883_DIGOUT_NID,
10204                 .dig_in_nid = ALC883_DIGIN_NID,
10205                 .slave_dig_outs = alc883_slave_dig_outs,
10206                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10207                 .channel_mode = alc889_8ch_intel_modes,
10208                 .capsrc_nids = alc889_capsrc_nids,
10209                 .input_mux = &alc889_capture_source,
10210                 .setup = alc889_automute_setup,
10211                 .init_hook = alc889_intel_init_hook,
10212                 .unsol_event = alc_automute_amp_unsol_event,
10213                 .need_dac_fix = 1,
10214         },
10215         [ALC883_6ST_DIG] = {
10216                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10217                 .init_verbs = { alc883_init_verbs },
10218                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10219                 .dac_nids = alc883_dac_nids,
10220                 .dig_out_nid = ALC883_DIGOUT_NID,
10221                 .dig_in_nid = ALC883_DIGIN_NID,
10222                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10223                 .channel_mode = alc883_sixstack_modes,
10224                 .input_mux = &alc883_capture_source,
10225         },
10226         [ALC883_TARGA_DIG] = {
10227                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10228                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10229                                 alc883_targa_verbs},
10230                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10231                 .dac_nids = alc883_dac_nids,
10232                 .dig_out_nid = ALC883_DIGOUT_NID,
10233                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10234                 .channel_mode = alc883_3ST_6ch_modes,
10235                 .need_dac_fix = 1,
10236                 .input_mux = &alc883_capture_source,
10237                 .unsol_event = alc883_targa_unsol_event,
10238                 .setup = alc882_targa_setup,
10239                 .init_hook = alc882_targa_automute,
10240         },
10241         [ALC883_TARGA_2ch_DIG] = {
10242                 .mixers = { alc883_targa_2ch_mixer},
10243                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10244                                 alc883_targa_verbs},
10245                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10246                 .dac_nids = alc883_dac_nids,
10247                 .adc_nids = alc883_adc_nids_alt,
10248                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10249                 .capsrc_nids = alc883_capsrc_nids,
10250                 .dig_out_nid = ALC883_DIGOUT_NID,
10251                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10252                 .channel_mode = alc883_3ST_2ch_modes,
10253                 .input_mux = &alc883_capture_source,
10254                 .unsol_event = alc883_targa_unsol_event,
10255                 .setup = alc882_targa_setup,
10256                 .init_hook = alc882_targa_automute,
10257         },
10258         [ALC883_TARGA_8ch_DIG] = {
10259                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10260                             alc883_chmode_mixer },
10261                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10262                                 alc883_targa_verbs },
10263                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10264                 .dac_nids = alc883_dac_nids,
10265                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10266                 .adc_nids = alc883_adc_nids_rev,
10267                 .capsrc_nids = alc883_capsrc_nids_rev,
10268                 .dig_out_nid = ALC883_DIGOUT_NID,
10269                 .dig_in_nid = ALC883_DIGIN_NID,
10270                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10271                 .channel_mode = alc883_4ST_8ch_modes,
10272                 .need_dac_fix = 1,
10273                 .input_mux = &alc883_capture_source,
10274                 .unsol_event = alc883_targa_unsol_event,
10275                 .setup = alc882_targa_setup,
10276                 .init_hook = alc882_targa_automute,
10277         },
10278         [ALC883_ACER] = {
10279                 .mixers = { alc883_base_mixer },
10280                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10281                  * and the headphone jack.  Turn this on and rely on the
10282                  * standard mute methods whenever the user wants to turn
10283                  * these outputs off.
10284                  */
10285                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10286                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10287                 .dac_nids = alc883_dac_nids,
10288                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10289                 .channel_mode = alc883_3ST_2ch_modes,
10290                 .input_mux = &alc883_capture_source,
10291         },
10292         [ALC883_ACER_ASPIRE] = {
10293                 .mixers = { alc883_acer_aspire_mixer },
10294                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10295                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10296                 .dac_nids = alc883_dac_nids,
10297                 .dig_out_nid = ALC883_DIGOUT_NID,
10298                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10299                 .channel_mode = alc883_3ST_2ch_modes,
10300                 .input_mux = &alc883_capture_source,
10301                 .unsol_event = alc_automute_amp_unsol_event,
10302                 .setup = alc883_acer_aspire_setup,
10303                 .init_hook = alc_automute_amp,
10304         },
10305         [ALC888_ACER_ASPIRE_4930G] = {
10306                 .mixers = { alc888_base_mixer,
10307                                 alc883_chmode_mixer },
10308                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10309                                 alc888_acer_aspire_4930g_verbs },
10310                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10311                 .dac_nids = alc883_dac_nids,
10312                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10313                 .adc_nids = alc883_adc_nids_rev,
10314                 .capsrc_nids = alc883_capsrc_nids_rev,
10315                 .dig_out_nid = ALC883_DIGOUT_NID,
10316                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10317                 .channel_mode = alc883_3ST_6ch_modes,
10318                 .need_dac_fix = 1,
10319                 .const_channel_count = 6,
10320                 .num_mux_defs =
10321                         ARRAY_SIZE(alc888_2_capture_sources),
10322                 .input_mux = alc888_2_capture_sources,
10323                 .unsol_event = alc_automute_amp_unsol_event,
10324                 .setup = alc888_acer_aspire_4930g_setup,
10325                 .init_hook = alc_automute_amp,
10326         },
10327         [ALC888_ACER_ASPIRE_6530G] = {
10328                 .mixers = { alc888_acer_aspire_6530_mixer },
10329                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10330                                 alc888_acer_aspire_6530g_verbs },
10331                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10332                 .dac_nids = alc883_dac_nids,
10333                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10334                 .adc_nids = alc883_adc_nids_rev,
10335                 .capsrc_nids = alc883_capsrc_nids_rev,
10336                 .dig_out_nid = ALC883_DIGOUT_NID,
10337                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10338                 .channel_mode = alc883_3ST_2ch_modes,
10339                 .num_mux_defs =
10340                         ARRAY_SIZE(alc888_2_capture_sources),
10341                 .input_mux = alc888_acer_aspire_6530_sources,
10342                 .unsol_event = alc_automute_amp_unsol_event,
10343                 .setup = alc888_acer_aspire_6530g_setup,
10344                 .init_hook = alc_automute_amp,
10345         },
10346         [ALC888_ACER_ASPIRE_8930G] = {
10347                 .mixers = { alc889_acer_aspire_8930g_mixer,
10348                                 alc883_chmode_mixer },
10349                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10350                                 alc889_acer_aspire_8930g_verbs,
10351                                 alc889_eapd_verbs},
10352                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10353                 .dac_nids = alc883_dac_nids,
10354                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10355                 .adc_nids = alc889_adc_nids,
10356                 .capsrc_nids = alc889_capsrc_nids,
10357                 .dig_out_nid = ALC883_DIGOUT_NID,
10358                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10359                 .channel_mode = alc883_3ST_6ch_modes,
10360                 .need_dac_fix = 1,
10361                 .const_channel_count = 6,
10362                 .num_mux_defs =
10363                         ARRAY_SIZE(alc889_capture_sources),
10364                 .input_mux = alc889_capture_sources,
10365                 .unsol_event = alc_automute_amp_unsol_event,
10366                 .setup = alc889_acer_aspire_8930g_setup,
10367                 .init_hook = alc_automute_amp,
10368 #ifdef CONFIG_SND_HDA_POWER_SAVE
10369                 .power_hook = alc_power_eapd,
10370 #endif
10371         },
10372         [ALC888_ACER_ASPIRE_7730G] = {
10373                 .mixers = { alc883_3ST_6ch_mixer,
10374                                 alc883_chmode_mixer },
10375                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10376                                 alc888_acer_aspire_7730G_verbs },
10377                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10378                 .dac_nids = alc883_dac_nids,
10379                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10380                 .adc_nids = alc883_adc_nids_rev,
10381                 .capsrc_nids = alc883_capsrc_nids_rev,
10382                 .dig_out_nid = ALC883_DIGOUT_NID,
10383                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10384                 .channel_mode = alc883_3ST_6ch_modes,
10385                 .need_dac_fix = 1,
10386                 .const_channel_count = 6,
10387                 .input_mux = &alc883_capture_source,
10388                 .unsol_event = alc_automute_amp_unsol_event,
10389                 .setup = alc888_acer_aspire_7730g_setup,
10390                 .init_hook = alc_automute_amp,
10391         },
10392         [ALC883_MEDION] = {
10393                 .mixers = { alc883_fivestack_mixer,
10394                             alc883_chmode_mixer },
10395                 .init_verbs = { alc883_init_verbs,
10396                                 alc883_medion_eapd_verbs },
10397                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10398                 .dac_nids = alc883_dac_nids,
10399                 .adc_nids = alc883_adc_nids_alt,
10400                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10401                 .capsrc_nids = alc883_capsrc_nids,
10402                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10403                 .channel_mode = alc883_sixstack_modes,
10404                 .input_mux = &alc883_capture_source,
10405         },
10406         [ALC883_MEDION_WIM2160] = {
10407                 .mixers = { alc883_medion_wim2160_mixer },
10408                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10409                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10410                 .dac_nids = alc883_dac_nids,
10411                 .dig_out_nid = ALC883_DIGOUT_NID,
10412                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10413                 .adc_nids = alc883_adc_nids,
10414                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10415                 .channel_mode = alc883_3ST_2ch_modes,
10416                 .input_mux = &alc883_capture_source,
10417                 .unsol_event = alc_automute_amp_unsol_event,
10418                 .setup = alc883_medion_wim2160_setup,
10419                 .init_hook = alc_automute_amp,
10420         },
10421         [ALC883_LAPTOP_EAPD] = {
10422                 .mixers = { alc883_base_mixer },
10423                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10424                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10425                 .dac_nids = alc883_dac_nids,
10426                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10427                 .channel_mode = alc883_3ST_2ch_modes,
10428                 .input_mux = &alc883_capture_source,
10429         },
10430         [ALC883_CLEVO_M540R] = {
10431                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10432                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10433                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10434                 .dac_nids = alc883_dac_nids,
10435                 .dig_out_nid = ALC883_DIGOUT_NID,
10436                 .dig_in_nid = ALC883_DIGIN_NID,
10437                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10438                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10439                 .need_dac_fix = 1,
10440                 .input_mux = &alc883_capture_source,
10441                 /* This machine has the hardware HP auto-muting, thus
10442                  * we need no software mute via unsol event
10443                  */
10444         },
10445         [ALC883_CLEVO_M720] = {
10446                 .mixers = { alc883_clevo_m720_mixer },
10447                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10448                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10449                 .dac_nids = alc883_dac_nids,
10450                 .dig_out_nid = ALC883_DIGOUT_NID,
10451                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10452                 .channel_mode = alc883_3ST_2ch_modes,
10453                 .input_mux = &alc883_capture_source,
10454                 .unsol_event = alc883_clevo_m720_unsol_event,
10455                 .setup = alc883_clevo_m720_setup,
10456                 .init_hook = alc883_clevo_m720_init_hook,
10457         },
10458         [ALC883_LENOVO_101E_2ch] = {
10459                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10460                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10461                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10462                 .dac_nids = alc883_dac_nids,
10463                 .adc_nids = alc883_adc_nids_alt,
10464                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10465                 .capsrc_nids = alc883_capsrc_nids,
10466                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10467                 .channel_mode = alc883_3ST_2ch_modes,
10468                 .input_mux = &alc883_lenovo_101e_capture_source,
10469                 .unsol_event = alc883_lenovo_101e_unsol_event,
10470                 .init_hook = alc883_lenovo_101e_all_automute,
10471         },
10472         [ALC883_LENOVO_NB0763] = {
10473                 .mixers = { alc883_lenovo_nb0763_mixer },
10474                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10475                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10476                 .dac_nids = alc883_dac_nids,
10477                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10478                 .channel_mode = alc883_3ST_2ch_modes,
10479                 .need_dac_fix = 1,
10480                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10481                 .unsol_event = alc_automute_amp_unsol_event,
10482                 .setup = alc883_lenovo_nb0763_setup,
10483                 .init_hook = alc_automute_amp,
10484         },
10485         [ALC888_LENOVO_MS7195_DIG] = {
10486                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10487                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10488                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10489                 .dac_nids = alc883_dac_nids,
10490                 .dig_out_nid = ALC883_DIGOUT_NID,
10491                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10492                 .channel_mode = alc883_3ST_6ch_modes,
10493                 .need_dac_fix = 1,
10494                 .input_mux = &alc883_capture_source,
10495                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10496                 .init_hook = alc888_lenovo_ms7195_front_automute,
10497         },
10498         [ALC883_HAIER_W66] = {
10499                 .mixers = { alc883_targa_2ch_mixer},
10500                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10501                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10502                 .dac_nids = alc883_dac_nids,
10503                 .dig_out_nid = ALC883_DIGOUT_NID,
10504                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10505                 .channel_mode = alc883_3ST_2ch_modes,
10506                 .input_mux = &alc883_capture_source,
10507                 .unsol_event = alc_automute_amp_unsol_event,
10508                 .setup = alc883_haier_w66_setup,
10509                 .init_hook = alc_automute_amp,
10510         },
10511         [ALC888_3ST_HP] = {
10512                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10513                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10514                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10515                 .dac_nids = alc883_dac_nids,
10516                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10517                 .channel_mode = alc888_3st_hp_modes,
10518                 .need_dac_fix = 1,
10519                 .input_mux = &alc883_capture_source,
10520                 .unsol_event = alc_automute_amp_unsol_event,
10521                 .setup = alc888_3st_hp_setup,
10522                 .init_hook = alc_automute_amp,
10523         },
10524         [ALC888_6ST_DELL] = {
10525                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10526                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10527                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10528                 .dac_nids = alc883_dac_nids,
10529                 .dig_out_nid = ALC883_DIGOUT_NID,
10530                 .dig_in_nid = ALC883_DIGIN_NID,
10531                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10532                 .channel_mode = alc883_sixstack_modes,
10533                 .input_mux = &alc883_capture_source,
10534                 .unsol_event = alc_automute_amp_unsol_event,
10535                 .setup = alc888_6st_dell_setup,
10536                 .init_hook = alc_automute_amp,
10537         },
10538         [ALC883_MITAC] = {
10539                 .mixers = { alc883_mitac_mixer },
10540                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10541                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10542                 .dac_nids = alc883_dac_nids,
10543                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10544                 .channel_mode = alc883_3ST_2ch_modes,
10545                 .input_mux = &alc883_capture_source,
10546                 .unsol_event = alc_automute_amp_unsol_event,
10547                 .setup = alc883_mitac_setup,
10548                 .init_hook = alc_automute_amp,
10549         },
10550         [ALC883_FUJITSU_PI2515] = {
10551                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10552                 .init_verbs = { alc883_init_verbs,
10553                                 alc883_2ch_fujitsu_pi2515_verbs},
10554                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10555                 .dac_nids = alc883_dac_nids,
10556                 .dig_out_nid = ALC883_DIGOUT_NID,
10557                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10558                 .channel_mode = alc883_3ST_2ch_modes,
10559                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10560                 .unsol_event = alc_automute_amp_unsol_event,
10561                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10562                 .init_hook = alc_automute_amp,
10563         },
10564         [ALC888_FUJITSU_XA3530] = {
10565                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10566                 .init_verbs = { alc883_init_verbs,
10567                         alc888_fujitsu_xa3530_verbs },
10568                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10569                 .dac_nids = alc883_dac_nids,
10570                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10571                 .adc_nids = alc883_adc_nids_rev,
10572                 .capsrc_nids = alc883_capsrc_nids_rev,
10573                 .dig_out_nid = ALC883_DIGOUT_NID,
10574                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10575                 .channel_mode = alc888_4ST_8ch_intel_modes,
10576                 .num_mux_defs =
10577                         ARRAY_SIZE(alc888_2_capture_sources),
10578                 .input_mux = alc888_2_capture_sources,
10579                 .unsol_event = alc_automute_amp_unsol_event,
10580                 .setup = alc888_fujitsu_xa3530_setup,
10581                 .init_hook = alc_automute_amp,
10582         },
10583         [ALC888_LENOVO_SKY] = {
10584                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10585                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10586                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10587                 .dac_nids = alc883_dac_nids,
10588                 .dig_out_nid = ALC883_DIGOUT_NID,
10589                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10590                 .channel_mode = alc883_sixstack_modes,
10591                 .need_dac_fix = 1,
10592                 .input_mux = &alc883_lenovo_sky_capture_source,
10593                 .unsol_event = alc_automute_amp_unsol_event,
10594                 .setup = alc888_lenovo_sky_setup,
10595                 .init_hook = alc_automute_amp,
10596         },
10597         [ALC888_ASUS_M90V] = {
10598                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10599                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10600                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10601                 .dac_nids = alc883_dac_nids,
10602                 .dig_out_nid = ALC883_DIGOUT_NID,
10603                 .dig_in_nid = ALC883_DIGIN_NID,
10604                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10605                 .channel_mode = alc883_3ST_6ch_modes,
10606                 .need_dac_fix = 1,
10607                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10608                 .unsol_event = alc_sku_unsol_event,
10609                 .setup = alc883_mode2_setup,
10610                 .init_hook = alc_inithook,
10611         },
10612         [ALC888_ASUS_EEE1601] = {
10613                 .mixers = { alc883_asus_eee1601_mixer },
10614                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10615                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10616                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10617                 .dac_nids = alc883_dac_nids,
10618                 .dig_out_nid = ALC883_DIGOUT_NID,
10619                 .dig_in_nid = ALC883_DIGIN_NID,
10620                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10621                 .channel_mode = alc883_3ST_2ch_modes,
10622                 .need_dac_fix = 1,
10623                 .input_mux = &alc883_asus_eee1601_capture_source,
10624                 .unsol_event = alc_sku_unsol_event,
10625                 .init_hook = alc883_eee1601_inithook,
10626         },
10627         [ALC1200_ASUS_P5Q] = {
10628                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10629                 .init_verbs = { alc883_init_verbs },
10630                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10631                 .dac_nids = alc883_dac_nids,
10632                 .dig_out_nid = ALC1200_DIGOUT_NID,
10633                 .dig_in_nid = ALC883_DIGIN_NID,
10634                 .slave_dig_outs = alc1200_slave_dig_outs,
10635                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10636                 .channel_mode = alc883_sixstack_modes,
10637                 .input_mux = &alc883_capture_source,
10638         },
10639         [ALC889A_MB31] = {
10640                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10641                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10642                         alc880_gpio1_init_verbs },
10643                 .adc_nids = alc883_adc_nids,
10644                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10645                 .capsrc_nids = alc883_capsrc_nids,
10646                 .dac_nids = alc883_dac_nids,
10647                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10648                 .channel_mode = alc889A_mb31_6ch_modes,
10649                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10650                 .input_mux = &alc889A_mb31_capture_source,
10651                 .dig_out_nid = ALC883_DIGOUT_NID,
10652                 .unsol_event = alc889A_mb31_unsol_event,
10653                 .init_hook = alc889A_mb31_automute,
10654         },
10655         [ALC883_SONY_VAIO_TT] = {
10656                 .mixers = { alc883_vaiott_mixer },
10657                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10658                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10659                 .dac_nids = alc883_dac_nids,
10660                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10661                 .channel_mode = alc883_3ST_2ch_modes,
10662                 .input_mux = &alc883_capture_source,
10663                 .unsol_event = alc_automute_amp_unsol_event,
10664                 .setup = alc883_vaiott_setup,
10665                 .init_hook = alc_automute_amp,
10666         },
10667 };
10668
10669
10670 /*
10671  * Pin config fixes
10672  */
10673 enum {
10674         PINFIX_ABIT_AW9D_MAX,
10675         PINFIX_PB_M5210,
10676         PINFIX_ACER_ASPIRE_7736,
10677 };
10678
10679 static const struct alc_fixup alc882_fixups[] = {
10680         [PINFIX_ABIT_AW9D_MAX] = {
10681                 .pins = (const struct alc_pincfg[]) {
10682                         { 0x15, 0x01080104 }, /* side */
10683                         { 0x16, 0x01011012 }, /* rear */
10684                         { 0x17, 0x01016011 }, /* clfe */
10685                         { }
10686                 }
10687         },
10688         [PINFIX_PB_M5210] = {
10689                 .verbs = (const struct hda_verb[]) {
10690                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10691                         {}
10692                 }
10693         },
10694         [PINFIX_ACER_ASPIRE_7736] = {
10695                 .sku = ALC_FIXUP_SKU_IGNORE,
10696         },
10697 };
10698
10699 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10700         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10701         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10702         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10703         {}
10704 };
10705
10706 /*
10707  * BIOS auto configuration
10708  */
10709 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10710                                                 const struct auto_pin_cfg *cfg)
10711 {
10712         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10713 }
10714
10715 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10716                                               hda_nid_t nid, int pin_type,
10717                                               hda_nid_t dac)
10718 {
10719         int idx;
10720
10721         /* set as output */
10722         alc_set_pin_output(codec, nid, pin_type);
10723
10724         if (dac == 0x25)
10725                 idx = 4;
10726         else if (dac >= 0x02 && dac <= 0x05)
10727                 idx = dac - 2;
10728         else
10729                 return;
10730         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10731 }
10732
10733 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10734 {
10735         struct alc_spec *spec = codec->spec;
10736         int i;
10737
10738         for (i = 0; i <= HDA_SIDE; i++) {
10739                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10740                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10741                 if (nid)
10742                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10743                                         spec->multiout.dac_nids[i]);
10744         }
10745 }
10746
10747 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10748 {
10749         struct alc_spec *spec = codec->spec;
10750         hda_nid_t pin, dac;
10751         int i;
10752
10753         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10754                 pin = spec->autocfg.hp_pins[i];
10755                 if (!pin)
10756                         break;
10757                 dac = spec->multiout.hp_nid;
10758                 if (!dac)
10759                         dac = spec->multiout.dac_nids[0]; /* to front */
10760                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10761         }
10762         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10763                 pin = spec->autocfg.speaker_pins[i];
10764                 if (!pin)
10765                         break;
10766                 dac = spec->multiout.extra_out_nid[0];
10767                 if (!dac)
10768                         dac = spec->multiout.dac_nids[0]; /* to front */
10769                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10770         }
10771 }
10772
10773 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10774 {
10775         struct alc_spec *spec = codec->spec;
10776         struct auto_pin_cfg *cfg = &spec->autocfg;
10777         int i;
10778
10779         for (i = 0; i < cfg->num_inputs; i++) {
10780                 hda_nid_t nid = cfg->inputs[i].pin;
10781                 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10782                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10783                         snd_hda_codec_write(codec, nid, 0,
10784                                             AC_VERB_SET_AMP_GAIN_MUTE,
10785                                             AMP_OUT_MUTE);
10786         }
10787 }
10788
10789 static void alc882_auto_init_input_src(struct hda_codec *codec)
10790 {
10791         struct alc_spec *spec = codec->spec;
10792         int c;
10793
10794         for (c = 0; c < spec->num_adc_nids; c++) {
10795                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10796                 hda_nid_t nid = spec->capsrc_nids[c];
10797                 unsigned int mux_idx;
10798                 const struct hda_input_mux *imux;
10799                 int conns, mute, idx, item;
10800
10801                 conns = snd_hda_get_connections(codec, nid, conn_list,
10802                                                 ARRAY_SIZE(conn_list));
10803                 if (conns < 0)
10804                         continue;
10805                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10806                 imux = &spec->input_mux[mux_idx];
10807                 if (!imux->num_items && mux_idx > 0)
10808                         imux = &spec->input_mux[0];
10809                 for (idx = 0; idx < conns; idx++) {
10810                         /* if the current connection is the selected one,
10811                          * unmute it as default - otherwise mute it
10812                          */
10813                         mute = AMP_IN_MUTE(idx);
10814                         for (item = 0; item < imux->num_items; item++) {
10815                                 if (imux->items[item].index == idx) {
10816                                         if (spec->cur_mux[c] == item)
10817                                                 mute = AMP_IN_UNMUTE(idx);
10818                                         break;
10819                                 }
10820                         }
10821                         /* check if we have a selector or mixer
10822                          * we could check for the widget type instead, but
10823                          * just check for Amp-In presence (in case of mixer
10824                          * without amp-in there is something wrong, this
10825                          * function shouldn't be used or capsrc nid is wrong)
10826                          */
10827                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10828                                 snd_hda_codec_write(codec, nid, 0,
10829                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10830                                                     mute);
10831                         else if (mute != AMP_IN_MUTE(idx))
10832                                 snd_hda_codec_write(codec, nid, 0,
10833                                                     AC_VERB_SET_CONNECT_SEL,
10834                                                     idx);
10835                 }
10836         }
10837 }
10838
10839 /* add mic boosts if needed */
10840 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10841 {
10842         struct alc_spec *spec = codec->spec;
10843         struct auto_pin_cfg *cfg = &spec->autocfg;
10844         int i, err;
10845         int type_idx = 0;
10846         hda_nid_t nid;
10847         const char *prev_label = NULL;
10848
10849         for (i = 0; i < cfg->num_inputs; i++) {
10850                 if (cfg->inputs[i].type > AUTO_PIN_MIC)
10851                         break;
10852                 nid = cfg->inputs[i].pin;
10853                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10854                         const char *label;
10855                         char boost_label[32];
10856
10857                         label = hda_get_autocfg_input_label(codec, cfg, i);
10858                         if (prev_label && !strcmp(label, prev_label))
10859                                 type_idx++;
10860                         else
10861                                 type_idx = 0;
10862                         prev_label = label;
10863
10864                         snprintf(boost_label, sizeof(boost_label),
10865                                  "%s Boost Volume", label);
10866                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10867                                           boost_label, type_idx,
10868                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10869                         if (err < 0)
10870                                 return err;
10871                 }
10872         }
10873         return 0;
10874 }
10875
10876 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
10877                                              const struct auto_pin_cfg *cfg);
10878
10879 /* almost identical with ALC880 parser... */
10880 static int alc882_parse_auto_config(struct hda_codec *codec)
10881 {
10882         struct alc_spec *spec = codec->spec;
10883         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10884         int err;
10885
10886         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10887                                            alc882_ignore);
10888         if (err < 0)
10889                 return err;
10890         if (!spec->autocfg.line_outs)
10891                 return 0; /* can't find valid BIOS pin config */
10892
10893         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10894         if (err < 0)
10895                 return err;
10896         if (codec->vendor_id == 0x10ec0887)
10897                 err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
10898         else
10899                 err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10900         if (err < 0)
10901                 return err;
10902         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10903                                            "Headphone");
10904         if (err < 0)
10905                 return err;
10906         err = alc880_auto_create_extra_out(spec,
10907                                            spec->autocfg.speaker_pins[0],
10908                                            "Speaker");
10909         if (err < 0)
10910                 return err;
10911         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10912         if (err < 0)
10913                 return err;
10914
10915         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10916
10917         alc_auto_parse_digital(codec);
10918
10919         if (spec->kctls.list)
10920                 add_mixer(spec, spec->kctls.list);
10921
10922         add_verb(spec, alc883_auto_init_verbs);
10923         /* if ADC 0x07 is available, initialize it, too */
10924         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10925                 add_verb(spec, alc882_adc1_init_verbs);
10926
10927         spec->num_mux_defs = 1;
10928         spec->input_mux = &spec->private_imux[0];
10929
10930         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10931
10932         err = alc_auto_add_mic_boost(codec);
10933         if (err < 0)
10934                 return err;
10935
10936         return 1; /* config found */
10937 }
10938
10939 /* additional initialization for auto-configuration model */
10940 static void alc882_auto_init(struct hda_codec *codec)
10941 {
10942         struct alc_spec *spec = codec->spec;
10943         alc882_auto_init_multi_out(codec);
10944         alc882_auto_init_hp_out(codec);
10945         alc882_auto_init_analog_input(codec);
10946         alc882_auto_init_input_src(codec);
10947         alc_auto_init_digital(codec);
10948         if (spec->unsol_event)
10949                 alc_inithook(codec);
10950 }
10951
10952 static int patch_alc882(struct hda_codec *codec)
10953 {
10954         struct alc_spec *spec;
10955         int err, board_config;
10956
10957         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10958         if (spec == NULL)
10959                 return -ENOMEM;
10960
10961         codec->spec = spec;
10962
10963         switch (codec->vendor_id) {
10964         case 0x10ec0882:
10965         case 0x10ec0885:
10966                 break;
10967         default:
10968                 /* ALC883 and variants */
10969                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10970                 break;
10971         }
10972
10973         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10974                                                   alc882_models,
10975                                                   alc882_cfg_tbl);
10976
10977         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10978                 board_config = snd_hda_check_board_codec_sid_config(codec,
10979                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10980
10981         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10982                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10983                        codec->chip_name);
10984                 board_config = ALC882_AUTO;
10985         }
10986
10987         if (board_config == ALC882_AUTO)
10988                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10989
10990         alc_auto_parse_customize_define(codec);
10991
10992         if (board_config == ALC882_AUTO) {
10993                 /* automatic parse from the BIOS config */
10994                 err = alc882_parse_auto_config(codec);
10995                 if (err < 0) {
10996                         alc_free(codec);
10997                         return err;
10998                 } else if (!err) {
10999                         printk(KERN_INFO
11000                                "hda_codec: Cannot set up configuration "
11001                                "from BIOS.  Using base mode...\n");
11002                         board_config = ALC882_3ST_DIG;
11003                 }
11004         }
11005
11006         if (has_cdefine_beep(codec)) {
11007                 err = snd_hda_attach_beep_device(codec, 0x1);
11008                 if (err < 0) {
11009                         alc_free(codec);
11010                         return err;
11011                 }
11012         }
11013
11014         if (board_config != ALC882_AUTO)
11015                 setup_preset(codec, &alc882_presets[board_config]);
11016
11017         spec->stream_analog_playback = &alc882_pcm_analog_playback;
11018         spec->stream_analog_capture = &alc882_pcm_analog_capture;
11019         /* FIXME: setup DAC5 */
11020         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11021         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11022
11023         spec->stream_digital_playback = &alc882_pcm_digital_playback;
11024         spec->stream_digital_capture = &alc882_pcm_digital_capture;
11025
11026         if (!spec->adc_nids && spec->input_mux) {
11027                 int i, j;
11028                 spec->num_adc_nids = 0;
11029                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11030                         const struct hda_input_mux *imux = spec->input_mux;
11031                         hda_nid_t cap;
11032                         hda_nid_t items[16];
11033                         hda_nid_t nid = alc882_adc_nids[i];
11034                         unsigned int wcap = get_wcaps(codec, nid);
11035                         /* get type */
11036                         wcap = get_wcaps_type(wcap);
11037                         if (wcap != AC_WID_AUD_IN)
11038                                 continue;
11039                         spec->private_adc_nids[spec->num_adc_nids] = nid;
11040                         err = snd_hda_get_connections(codec, nid, &cap, 1);
11041                         if (err < 0)
11042                                 continue;
11043                         err = snd_hda_get_connections(codec, cap, items,
11044                                                       ARRAY_SIZE(items));
11045                         if (err < 0)
11046                                 continue;
11047                         for (j = 0; j < imux->num_items; j++)
11048                                 if (imux->items[j].index >= err)
11049                                         break;
11050                         if (j < imux->num_items)
11051                                 continue;
11052                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11053                         spec->num_adc_nids++;
11054                 }
11055                 spec->adc_nids = spec->private_adc_nids;
11056                 spec->capsrc_nids = spec->private_capsrc_nids;
11057         }
11058
11059         set_capture_mixer(codec);
11060
11061         if (has_cdefine_beep(codec))
11062                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11063
11064         if (board_config == ALC882_AUTO)
11065                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
11066
11067         spec->vmaster_nid = 0x0c;
11068
11069         codec->patch_ops = alc_patch_ops;
11070         if (board_config == ALC882_AUTO)
11071                 spec->init_hook = alc882_auto_init;
11072
11073         alc_init_jacks(codec);
11074 #ifdef CONFIG_SND_HDA_POWER_SAVE
11075         if (!spec->loopback.amplist)
11076                 spec->loopback.amplist = alc882_loopbacks;
11077 #endif
11078
11079         return 0;
11080 }
11081
11082
11083 /*
11084  * ALC262 support
11085  */
11086
11087 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
11088 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
11089
11090 #define alc262_dac_nids         alc260_dac_nids
11091 #define alc262_adc_nids         alc882_adc_nids
11092 #define alc262_adc_nids_alt     alc882_adc_nids_alt
11093 #define alc262_capsrc_nids      alc882_capsrc_nids
11094 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
11095
11096 #define alc262_modes            alc260_modes
11097 #define alc262_capture_source   alc882_capture_source
11098
11099 static hda_nid_t alc262_dmic_adc_nids[1] = {
11100         /* ADC0 */
11101         0x09
11102 };
11103
11104 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11105
11106 static struct snd_kcontrol_new alc262_base_mixer[] = {
11107         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11108         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11109         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11110         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11111         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11112         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11113         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11114         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11115         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11116         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11117         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11118         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11119         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11120         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11121         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11122         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11123         { } /* end */
11124 };
11125
11126 /* update HP, line and mono-out pins according to the master switch */
11127 static void alc262_hp_master_update(struct hda_codec *codec)
11128 {
11129         struct alc_spec *spec = codec->spec;
11130         int val = spec->master_sw;
11131
11132         /* HP & line-out */
11133         snd_hda_codec_write_cache(codec, 0x1b, 0,
11134                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11135                                   val ? PIN_HP : 0);
11136         snd_hda_codec_write_cache(codec, 0x15, 0,
11137                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11138                                   val ? PIN_HP : 0);
11139         /* mono (speaker) depending on the HP jack sense */
11140         val = val && !spec->jack_present;
11141         snd_hda_codec_write_cache(codec, 0x16, 0,
11142                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11143                                   val ? PIN_OUT : 0);
11144 }
11145
11146 static void alc262_hp_bpc_automute(struct hda_codec *codec)
11147 {
11148         struct alc_spec *spec = codec->spec;
11149
11150         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11151         alc262_hp_master_update(codec);
11152 }
11153
11154 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11155 {
11156         if ((res >> 26) != ALC880_HP_EVENT)
11157                 return;
11158         alc262_hp_bpc_automute(codec);
11159 }
11160
11161 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11162 {
11163         struct alc_spec *spec = codec->spec;
11164
11165         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11166         alc262_hp_master_update(codec);
11167 }
11168
11169 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11170                                            unsigned int res)
11171 {
11172         if ((res >> 26) != ALC880_HP_EVENT)
11173                 return;
11174         alc262_hp_wildwest_automute(codec);
11175 }
11176
11177 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
11178
11179 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11180                                    struct snd_ctl_elem_value *ucontrol)
11181 {
11182         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11183         struct alc_spec *spec = codec->spec;
11184         int val = !!*ucontrol->value.integer.value;
11185
11186         if (val == spec->master_sw)
11187                 return 0;
11188         spec->master_sw = val;
11189         alc262_hp_master_update(codec);
11190         return 1;
11191 }
11192
11193 #define ALC262_HP_MASTER_SWITCH                                 \
11194         {                                                       \
11195                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11196                 .name = "Master Playback Switch",               \
11197                 .info = snd_ctl_boolean_mono_info,              \
11198                 .get = alc262_hp_master_sw_get,                 \
11199                 .put = alc262_hp_master_sw_put,                 \
11200         }, \
11201         {                                                       \
11202                 .iface = NID_MAPPING,                           \
11203                 .name = "Master Playback Switch",               \
11204                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
11205         }
11206
11207
11208 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11209         ALC262_HP_MASTER_SWITCH,
11210         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11211         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11212         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11213         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11214                               HDA_OUTPUT),
11215         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11216                             HDA_OUTPUT),
11217         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11218         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11219         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11220         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11221         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11222         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11223         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11224         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11225         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11226         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11227         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11228         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11229         { } /* end */
11230 };
11231
11232 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11233         ALC262_HP_MASTER_SWITCH,
11234         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11235         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11236         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11237         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11238         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11239                               HDA_OUTPUT),
11240         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11241                             HDA_OUTPUT),
11242         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11243         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11244         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11245         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11246         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11247         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11248         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11249         { } /* end */
11250 };
11251
11252 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11253         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11254         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11255         HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11256         { } /* end */
11257 };
11258
11259 /* mute/unmute internal speaker according to the hp jack and mute state */
11260 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11261 {
11262         struct alc_spec *spec = codec->spec;
11263
11264         spec->autocfg.hp_pins[0] = 0x15;
11265         spec->autocfg.speaker_pins[0] = 0x14;
11266 }
11267
11268 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11269         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11270         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11271         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11272         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11273         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11274         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11275         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11276         { } /* end */
11277 };
11278
11279 static struct hda_verb alc262_hp_t5735_verbs[] = {
11280         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11281         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11282
11283         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11284         { }
11285 };
11286
11287 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11288         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11289         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11290         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11291         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11292         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11293         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11294         { } /* end */
11295 };
11296
11297 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11298         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11299         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11300         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11301         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11302         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11303         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11304         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11305         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11306         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11307         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11308         {}
11309 };
11310
11311 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11312         .num_items = 1,
11313         .items = {
11314                 { "Line", 0x1 },
11315         },
11316 };
11317
11318 /* bind hp and internal speaker mute (with plug check) as master switch */
11319 static void alc262_hippo_master_update(struct hda_codec *codec)
11320 {
11321         struct alc_spec *spec = codec->spec;
11322         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11323         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11324         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11325         unsigned int mute;
11326
11327         /* HP */
11328         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11329         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11330                                  HDA_AMP_MUTE, mute);
11331         /* mute internal speaker per jack sense */
11332         if (spec->jack_present)
11333                 mute = HDA_AMP_MUTE;
11334         if (line_nid)
11335                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11336                                          HDA_AMP_MUTE, mute);
11337         if (speaker_nid && speaker_nid != line_nid)
11338                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11339                                          HDA_AMP_MUTE, mute);
11340 }
11341
11342 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11343
11344 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11345                                       struct snd_ctl_elem_value *ucontrol)
11346 {
11347         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11348         struct alc_spec *spec = codec->spec;
11349         int val = !!*ucontrol->value.integer.value;
11350
11351         if (val == spec->master_sw)
11352                 return 0;
11353         spec->master_sw = val;
11354         alc262_hippo_master_update(codec);
11355         return 1;
11356 }
11357
11358 #define ALC262_HIPPO_MASTER_SWITCH                              \
11359         {                                                       \
11360                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11361                 .name = "Master Playback Switch",               \
11362                 .info = snd_ctl_boolean_mono_info,              \
11363                 .get = alc262_hippo_master_sw_get,              \
11364                 .put = alc262_hippo_master_sw_put,              \
11365         },                                                      \
11366         {                                                       \
11367                 .iface = NID_MAPPING,                           \
11368                 .name = "Master Playback Switch",               \
11369                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11370                              (SUBDEV_SPEAKER(0) << 16), \
11371         }
11372
11373 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11374         ALC262_HIPPO_MASTER_SWITCH,
11375         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11376         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11377         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11378         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11379         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11380         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11381         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11382         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11383         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11384         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11385         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11386         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11387         { } /* end */
11388 };
11389
11390 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11391         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11392         ALC262_HIPPO_MASTER_SWITCH,
11393         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11394         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11395         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11396         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11397         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11398         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11399         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11400         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11401         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11402         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11403         { } /* end */
11404 };
11405
11406 /* mute/unmute internal speaker according to the hp jack and mute state */
11407 static void alc262_hippo_automute(struct hda_codec *codec)
11408 {
11409         struct alc_spec *spec = codec->spec;
11410         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11411
11412         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11413         alc262_hippo_master_update(codec);
11414 }
11415
11416 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11417 {
11418         if ((res >> 26) != ALC880_HP_EVENT)
11419                 return;
11420         alc262_hippo_automute(codec);
11421 }
11422
11423 static void alc262_hippo_setup(struct hda_codec *codec)
11424 {
11425         struct alc_spec *spec = codec->spec;
11426
11427         spec->autocfg.hp_pins[0] = 0x15;
11428         spec->autocfg.speaker_pins[0] = 0x14;
11429 }
11430
11431 static void alc262_hippo1_setup(struct hda_codec *codec)
11432 {
11433         struct alc_spec *spec = codec->spec;
11434
11435         spec->autocfg.hp_pins[0] = 0x1b;
11436         spec->autocfg.speaker_pins[0] = 0x14;
11437 }
11438
11439
11440 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11441         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11442         ALC262_HIPPO_MASTER_SWITCH,
11443         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11444         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11445         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11446         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11447         { } /* end */
11448 };
11449
11450 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11451         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11452         ALC262_HIPPO_MASTER_SWITCH,
11453         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11454         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11455         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11456         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11457         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11458         { } /* end */
11459 };
11460
11461 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11462         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11463         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11464         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11465         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11466         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11467         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11468         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11469         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11470         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11471         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11472         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11473         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11474         { } /* end */
11475 };
11476
11477 static struct hda_verb alc262_tyan_verbs[] = {
11478         /* Headphone automute */
11479         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11480         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11481         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11482
11483         /* P11 AUX_IN, white 4-pin connector */
11484         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11485         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11486         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11487         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11488
11489         {}
11490 };
11491
11492 /* unsolicited event for HP jack sensing */
11493 static void alc262_tyan_setup(struct hda_codec *codec)
11494 {
11495         struct alc_spec *spec = codec->spec;
11496
11497         spec->autocfg.hp_pins[0] = 0x1b;
11498         spec->autocfg.speaker_pins[0] = 0x15;
11499 }
11500
11501
11502 #define alc262_capture_mixer            alc882_capture_mixer
11503 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11504
11505 /*
11506  * generic initialization of ADC, input mixers and output mixers
11507  */
11508 static struct hda_verb alc262_init_verbs[] = {
11509         /*
11510          * Unmute ADC0-2 and set the default input to mic-in
11511          */
11512         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11513         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11514         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11515         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11516         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11517         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11518
11519         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11520          * mixer widget
11521          * Note: PASD motherboards uses the Line In 2 as the input for
11522          * front panel mic (mic 2)
11523          */
11524         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11525         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11526         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11527         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11528         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11529         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11530
11531         /*
11532          * Set up output mixers (0x0c - 0x0e)
11533          */
11534         /* set vol=0 to output mixers */
11535         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11536         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11537         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11538         /* set up input amps for analog loopback */
11539         /* Amp Indices: DAC = 0, mixer = 1 */
11540         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11541         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11542         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11543         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11544         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11545         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11546
11547         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11548         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11549         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11550         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11551         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11552         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11553
11554         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11555         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11556         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11557         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11558         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11559
11560         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11561         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11562
11563         /* FIXME: use matrix-type input source selection */
11564         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11565         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11566         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11567         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11568         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11569         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11570         /* Input mixer2 */
11571         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11572         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11573         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11574         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11575         /* Input mixer3 */
11576         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11577         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11578         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11579         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11580
11581         { }
11582 };
11583
11584 static struct hda_verb alc262_eapd_verbs[] = {
11585         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11586         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11587         { }
11588 };
11589
11590 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11591         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11592         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11593         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11594
11595         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11596         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11597         {}
11598 };
11599
11600 static struct hda_verb alc262_sony_unsol_verbs[] = {
11601         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11602         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11603         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11604
11605         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11606         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11607         {}
11608 };
11609
11610 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11611         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11612         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11613         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11614         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11615         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11616         { } /* end */
11617 };
11618
11619 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11620         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11621         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11622         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11623         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11624         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11625         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11626         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11627         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11628         {}
11629 };
11630
11631 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11632 {
11633         struct alc_spec *spec = codec->spec;
11634
11635         spec->autocfg.hp_pins[0] = 0x15;
11636         spec->autocfg.speaker_pins[0] = 0x14;
11637         spec->ext_mic.pin = 0x18;
11638         spec->ext_mic.mux_idx = 0;
11639         spec->int_mic.pin = 0x12;
11640         spec->int_mic.mux_idx = 9;
11641         spec->auto_mic = 1;
11642 }
11643
11644 /*
11645  * nec model
11646  *  0x15 = headphone
11647  *  0x16 = internal speaker
11648  *  0x18 = external mic
11649  */
11650
11651 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11652         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11653         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11654
11655         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11656         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11657         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11658
11659         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11660         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11661         { } /* end */
11662 };
11663
11664 static struct hda_verb alc262_nec_verbs[] = {
11665         /* Unmute Speaker */
11666         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11667
11668         /* Headphone */
11669         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11670         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11671
11672         /* External mic to headphone */
11673         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11674         /* External mic to speaker */
11675         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11676         {}
11677 };
11678
11679 /*
11680  * fujitsu model
11681  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11682  *  0x1b = port replicator headphone out
11683  */
11684
11685 #define ALC_HP_EVENT    0x37
11686
11687 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11688         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11689         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11690         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11691         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11692         {}
11693 };
11694
11695 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11696         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11697         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11698         {}
11699 };
11700
11701 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11702         /* Front Mic pin: input vref at 50% */
11703         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11704         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11705         {}
11706 };
11707
11708 static struct hda_input_mux alc262_fujitsu_capture_source = {
11709         .num_items = 3,
11710         .items = {
11711                 { "Mic", 0x0 },
11712                 { "Internal Mic", 0x1 },
11713                 { "CD", 0x4 },
11714         },
11715 };
11716
11717 static struct hda_input_mux alc262_HP_capture_source = {
11718         .num_items = 5,
11719         .items = {
11720                 { "Mic", 0x0 },
11721                 { "Front Mic", 0x1 },
11722                 { "Line", 0x2 },
11723                 { "CD", 0x4 },
11724                 { "AUX IN", 0x6 },
11725         },
11726 };
11727
11728 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11729         .num_items = 4,
11730         .items = {
11731                 { "Mic", 0x0 },
11732                 { "Front Mic", 0x2 },
11733                 { "Line", 0x1 },
11734                 { "CD", 0x4 },
11735         },
11736 };
11737
11738 /* mute/unmute internal speaker according to the hp jacks and mute state */
11739 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11740 {
11741         struct alc_spec *spec = codec->spec;
11742         unsigned int mute;
11743
11744         if (force || !spec->sense_updated) {
11745                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11746                                      snd_hda_jack_detect(codec, 0x1b);
11747                 spec->sense_updated = 1;
11748         }
11749         /* unmute internal speaker only if both HPs are unplugged and
11750          * master switch is on
11751          */
11752         if (spec->jack_present)
11753                 mute = HDA_AMP_MUTE;
11754         else
11755                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11756         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11757                                  HDA_AMP_MUTE, mute);
11758 }
11759
11760 /* unsolicited event for HP jack sensing */
11761 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11762                                        unsigned int res)
11763 {
11764         if ((res >> 26) != ALC_HP_EVENT)
11765                 return;
11766         alc262_fujitsu_automute(codec, 1);
11767 }
11768
11769 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11770 {
11771         alc262_fujitsu_automute(codec, 1);
11772 }
11773
11774 /* bind volumes of both NID 0x0c and 0x0d */
11775 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11776         .ops = &snd_hda_bind_vol,
11777         .values = {
11778                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11779                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11780                 0
11781         },
11782 };
11783
11784 /* mute/unmute internal speaker according to the hp jack and mute state */
11785 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11786 {
11787         struct alc_spec *spec = codec->spec;
11788         unsigned int mute;
11789
11790         if (force || !spec->sense_updated) {
11791                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11792                 spec->sense_updated = 1;
11793         }
11794         if (spec->jack_present) {
11795                 /* mute internal speaker */
11796                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11797                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11798                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11799                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11800         } else {
11801                 /* unmute internal speaker if necessary */
11802                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11803                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11804                                          HDA_AMP_MUTE, mute);
11805                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11806                                          HDA_AMP_MUTE, mute);
11807         }
11808 }
11809
11810 /* unsolicited event for HP jack sensing */
11811 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11812                                        unsigned int res)
11813 {
11814         if ((res >> 26) != ALC_HP_EVENT)
11815                 return;
11816         alc262_lenovo_3000_automute(codec, 1);
11817 }
11818
11819 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11820                                   int dir, int idx, long *valp)
11821 {
11822         int i, change = 0;
11823
11824         for (i = 0; i < 2; i++, valp++)
11825                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11826                                                    HDA_AMP_MUTE,
11827                                                    *valp ? 0 : HDA_AMP_MUTE);
11828         return change;
11829 }
11830
11831 /* bind hp and internal speaker mute (with plug check) */
11832 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11833                                          struct snd_ctl_elem_value *ucontrol)
11834 {
11835         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11836         long *valp = ucontrol->value.integer.value;
11837         int change;
11838
11839         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11840         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11841         if (change)
11842                 alc262_fujitsu_automute(codec, 0);
11843         return change;
11844 }
11845
11846 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11847         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11848         {
11849                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11850                 .name = "Master Playback Switch",
11851                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11852                 .info = snd_hda_mixer_amp_switch_info,
11853                 .get = snd_hda_mixer_amp_switch_get,
11854                 .put = alc262_fujitsu_master_sw_put,
11855                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11856         },
11857         {
11858                 .iface = NID_MAPPING,
11859                 .name = "Master Playback Switch",
11860                 .private_value = 0x1b,
11861         },
11862         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11863         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11864         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11865         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11866         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11867         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11868         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11869         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11870         { } /* end */
11871 };
11872
11873 /* bind hp and internal speaker mute (with plug check) */
11874 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11875                                          struct snd_ctl_elem_value *ucontrol)
11876 {
11877         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11878         long *valp = ucontrol->value.integer.value;
11879         int change;
11880
11881         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11882         if (change)
11883                 alc262_lenovo_3000_automute(codec, 0);
11884         return change;
11885 }
11886
11887 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11888         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11889         {
11890                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11891                 .name = "Master Playback Switch",
11892                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11893                 .info = snd_hda_mixer_amp_switch_info,
11894                 .get = snd_hda_mixer_amp_switch_get,
11895                 .put = alc262_lenovo_3000_master_sw_put,
11896                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11897         },
11898         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11899         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11900         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11901         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11902         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11903         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11904         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11905         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11906         { } /* end */
11907 };
11908
11909 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11910         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11911         ALC262_HIPPO_MASTER_SWITCH,
11912         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11913         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11914         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11915         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11916         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11917         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11918         { } /* end */
11919 };
11920
11921 /* additional init verbs for Benq laptops */
11922 static struct hda_verb alc262_EAPD_verbs[] = {
11923         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11924         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11925         {}
11926 };
11927
11928 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11929         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11930         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11931
11932         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11933         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11934         {}
11935 };
11936
11937 /* Samsung Q1 Ultra Vista model setup */
11938 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11939         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11940         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11941         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11942         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11943         HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
11944         HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
11945         { } /* end */
11946 };
11947
11948 static struct hda_verb alc262_ultra_verbs[] = {
11949         /* output mixer */
11950         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11951         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11952         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11953         /* speaker */
11954         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11955         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11956         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11957         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11958         /* HP */
11959         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11960         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11961         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11962         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11963         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11964         /* internal mic */
11965         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11966         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11967         /* ADC, choose mic */
11968         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11969         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11970         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11971         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11972         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11973         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11974         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11975         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11976         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11977         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11978         {}
11979 };
11980
11981 /* mute/unmute internal speaker according to the hp jack and mute state */
11982 static void alc262_ultra_automute(struct hda_codec *codec)
11983 {
11984         struct alc_spec *spec = codec->spec;
11985         unsigned int mute;
11986
11987         mute = 0;
11988         /* auto-mute only when HP is used as HP */
11989         if (!spec->cur_mux[0]) {
11990                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11991                 if (spec->jack_present)
11992                         mute = HDA_AMP_MUTE;
11993         }
11994         /* mute/unmute internal speaker */
11995         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11996                                  HDA_AMP_MUTE, mute);
11997         /* mute/unmute HP */
11998         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11999                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12000 }
12001
12002 /* unsolicited event for HP jack sensing */
12003 static void alc262_ultra_unsol_event(struct hda_codec *codec,
12004                                        unsigned int res)
12005 {
12006         if ((res >> 26) != ALC880_HP_EVENT)
12007                 return;
12008         alc262_ultra_automute(codec);
12009 }
12010
12011 static struct hda_input_mux alc262_ultra_capture_source = {
12012         .num_items = 2,
12013         .items = {
12014                 { "Mic", 0x1 },
12015                 { "Headphone", 0x7 },
12016         },
12017 };
12018
12019 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12020                                      struct snd_ctl_elem_value *ucontrol)
12021 {
12022         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12023         struct alc_spec *spec = codec->spec;
12024         int ret;
12025
12026         ret = alc_mux_enum_put(kcontrol, ucontrol);
12027         if (!ret)
12028                 return 0;
12029         /* reprogram the HP pin as mic or HP according to the input source */
12030         snd_hda_codec_write_cache(codec, 0x15, 0,
12031                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
12032                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12033         alc262_ultra_automute(codec); /* mute/unmute HP */
12034         return ret;
12035 }
12036
12037 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12038         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12039         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12040         {
12041                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12042                 .name = "Capture Source",
12043                 .info = alc_mux_enum_info,
12044                 .get = alc_mux_enum_get,
12045                 .put = alc262_ultra_mux_enum_put,
12046         },
12047         {
12048                 .iface = NID_MAPPING,
12049                 .name = "Capture Source",
12050                 .private_value = 0x15,
12051         },
12052         { } /* end */
12053 };
12054
12055 /* We use two mixers depending on the output pin; 0x16 is a mono output
12056  * and thus it's bound with a different mixer.
12057  * This function returns which mixer amp should be used.
12058  */
12059 static int alc262_check_volbit(hda_nid_t nid)
12060 {
12061         if (!nid)
12062                 return 0;
12063         else if (nid == 0x16)
12064                 return 2;
12065         else
12066                 return 1;
12067 }
12068
12069 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12070                                   const char *pfx, int *vbits, int idx)
12071 {
12072         unsigned long val;
12073         int vbit;
12074
12075         vbit = alc262_check_volbit(nid);
12076         if (!vbit)
12077                 return 0;
12078         if (*vbits & vbit) /* a volume control for this mixer already there */
12079                 return 0;
12080         *vbits |= vbit;
12081         if (vbit == 2)
12082                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12083         else
12084                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12085         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12086 }
12087
12088 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12089                                  const char *pfx, int idx)
12090 {
12091         unsigned long val;
12092
12093         if (!nid)
12094                 return 0;
12095         if (nid == 0x16)
12096                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12097         else
12098                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12099         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12100 }
12101
12102 /* add playback controls from the parsed DAC table */
12103 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12104                                              const struct auto_pin_cfg *cfg)
12105 {
12106         const char *pfx;
12107         int vbits;
12108         int i, err;
12109
12110         spec->multiout.num_dacs = 1;    /* only use one dac */
12111         spec->multiout.dac_nids = spec->private_dac_nids;
12112         spec->multiout.dac_nids[0] = 2;
12113
12114         pfx = alc_get_line_out_pfx(cfg, true);
12115         if (!pfx)
12116                 pfx = "Front";
12117         for (i = 0; i < 2; i++) {
12118                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12119                 if (err < 0)
12120                         return err;
12121                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12122                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12123                                                     "Speaker", i);
12124                         if (err < 0)
12125                                 return err;
12126                 }
12127                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12128                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12129                                                     "Headphone", i);
12130                         if (err < 0)
12131                                 return err;
12132                 }
12133         }
12134
12135         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12136                 alc262_check_volbit(cfg->speaker_pins[0]) |
12137                 alc262_check_volbit(cfg->hp_pins[0]);
12138         if (vbits == 1 || vbits == 2)
12139                 pfx = "Master"; /* only one mixer is used */
12140         vbits = 0;
12141         for (i = 0; i < 2; i++) {
12142                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12143                                              &vbits, i);
12144                 if (err < 0)
12145                         return err;
12146                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12147                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12148                                                      "Speaker", &vbits, i);
12149                         if (err < 0)
12150                                 return err;
12151                 }
12152                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12153                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12154                                                      "Headphone", &vbits, i);
12155                         if (err < 0)
12156                                 return err;
12157                 }
12158         }
12159         return 0;
12160 }
12161
12162 #define alc262_auto_create_input_ctls \
12163         alc882_auto_create_input_ctls
12164
12165 /*
12166  * generic initialization of ADC, input mixers and output mixers
12167  */
12168 static struct hda_verb alc262_volume_init_verbs[] = {
12169         /*
12170          * Unmute ADC0-2 and set the default input to mic-in
12171          */
12172         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12173         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12174         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12175         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12176         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12177         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12178
12179         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12180          * mixer widget
12181          * Note: PASD motherboards uses the Line In 2 as the input for
12182          * front panel mic (mic 2)
12183          */
12184         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12185         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12186         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12187         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12188         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12189         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12190
12191         /*
12192          * Set up output mixers (0x0c - 0x0f)
12193          */
12194         /* set vol=0 to output mixers */
12195         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12196         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12197         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12198
12199         /* set up input amps for analog loopback */
12200         /* Amp Indices: DAC = 0, mixer = 1 */
12201         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12202         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12203         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12204         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12205         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12206         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12207
12208         /* FIXME: use matrix-type input source selection */
12209         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12210         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12212         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12213         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12214         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12215         /* Input mixer2 */
12216         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12217         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12218         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12219         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12220         /* Input mixer3 */
12221         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12222         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12223         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12224         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12225
12226         { }
12227 };
12228
12229 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12230         /*
12231          * Unmute ADC0-2 and set the default input to mic-in
12232          */
12233         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12234         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12235         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12236         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12237         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12238         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12239
12240         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12241          * mixer widget
12242          * Note: PASD motherboards uses the Line In 2 as the input for
12243          * front panel mic (mic 2)
12244          */
12245         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12246         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12247         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12248         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12249         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12250         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12251         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12252         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12253
12254         /*
12255          * Set up output mixers (0x0c - 0x0e)
12256          */
12257         /* set vol=0 to output mixers */
12258         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12259         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12260         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12261
12262         /* set up input amps for analog loopback */
12263         /* Amp Indices: DAC = 0, mixer = 1 */
12264         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12265         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12266         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12267         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12268         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12269         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12270
12271         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12272         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12273         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12274
12275         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12276         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12277
12278         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12279         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12280
12281         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12282         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12283         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12284         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12285         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12286
12287         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12288         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12289         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12290         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12291         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12292         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12293
12294
12295         /* FIXME: use matrix-type input source selection */
12296         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12297         /* Input mixer1: only unmute Mic */
12298         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12299         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12300         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12301         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12302         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12303         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12304         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12305         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12306         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12307         /* Input mixer2 */
12308         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12309         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12310         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12311         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12312         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12313         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12314         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12315         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12316         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12317         /* Input mixer3 */
12318         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12319         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12320         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12321         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12322         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12323         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12324         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12325         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12326         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12327
12328         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12329
12330         { }
12331 };
12332
12333 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12334         /*
12335          * Unmute ADC0-2 and set the default input to mic-in
12336          */
12337         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12338         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12339         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12340         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12341         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12342         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12343
12344         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12345          * mixer widget
12346          * Note: PASD motherboards uses the Line In 2 as the input for front
12347          * panel mic (mic 2)
12348          */
12349         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12350         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12351         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12352         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12353         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12354         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12355         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12356         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12357         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12358         /*
12359          * Set up output mixers (0x0c - 0x0e)
12360          */
12361         /* set vol=0 to output mixers */
12362         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12363         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12364         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12365
12366         /* set up input amps for analog loopback */
12367         /* Amp Indices: DAC = 0, mixer = 1 */
12368         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12369         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12370         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12371         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12372         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12373         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12374
12375
12376         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12377         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12378         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12379         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12380         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12381         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12382         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12383
12384         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12385         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12386
12387         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12388         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12389
12390         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12391         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12392         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12393         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12394         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12395         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12396
12397         /* FIXME: use matrix-type input source selection */
12398         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12399         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12400         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12401         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12402         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12403         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12404         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12405         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12406         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12407         /* Input mixer2 */
12408         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12409         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12410         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12411         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12412         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12413         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12414         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12415         /* Input mixer3 */
12416         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12417         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12418         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12419         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12420         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12421         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12422         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12423
12424         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12425
12426         { }
12427 };
12428
12429 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12430
12431         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12432         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12433         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12434
12435         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12436         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12437         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12438         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12439
12440         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12441         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12442         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12443         {}
12444 };
12445
12446 /*
12447  * Pin config fixes
12448  */
12449 enum {
12450         PINFIX_FSC_H270,
12451 };
12452
12453 static const struct alc_fixup alc262_fixups[] = {
12454         [PINFIX_FSC_H270] = {
12455                 .pins = (const struct alc_pincfg[]) {
12456                         { 0x14, 0x99130110 }, /* speaker */
12457                         { 0x15, 0x0221142f }, /* front HP */
12458                         { 0x1b, 0x0121141f }, /* rear HP */
12459                         { }
12460                 }
12461         },
12462         [PINFIX_PB_M5210] = {
12463                 .verbs = (const struct hda_verb[]) {
12464                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
12465                         {}
12466                 }
12467         },
12468 };
12469
12470 static struct snd_pci_quirk alc262_fixup_tbl[] = {
12471         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12472         {}
12473 };
12474
12475
12476 #ifdef CONFIG_SND_HDA_POWER_SAVE
12477 #define alc262_loopbacks        alc880_loopbacks
12478 #endif
12479
12480 /* pcm configuration: identical with ALC880 */
12481 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12482 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12483 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12484 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12485
12486 /*
12487  * BIOS auto configuration
12488  */
12489 static int alc262_parse_auto_config(struct hda_codec *codec)
12490 {
12491         struct alc_spec *spec = codec->spec;
12492         int err;
12493         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12494
12495         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12496                                            alc262_ignore);
12497         if (err < 0)
12498                 return err;
12499         if (!spec->autocfg.line_outs) {
12500                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12501                         spec->multiout.max_channels = 2;
12502                         spec->no_analog = 1;
12503                         goto dig_only;
12504                 }
12505                 return 0; /* can't find valid BIOS pin config */
12506         }
12507         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12508         if (err < 0)
12509                 return err;
12510         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12511         if (err < 0)
12512                 return err;
12513
12514         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12515
12516  dig_only:
12517         alc_auto_parse_digital(codec);
12518
12519         if (spec->kctls.list)
12520                 add_mixer(spec, spec->kctls.list);
12521
12522         add_verb(spec, alc262_volume_init_verbs);
12523         spec->num_mux_defs = 1;
12524         spec->input_mux = &spec->private_imux[0];
12525
12526         err = alc_auto_add_mic_boost(codec);
12527         if (err < 0)
12528                 return err;
12529
12530         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12531
12532         return 1;
12533 }
12534
12535 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12536 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12537 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12538 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12539
12540
12541 /* init callback for auto-configuration model -- overriding the default init */
12542 static void alc262_auto_init(struct hda_codec *codec)
12543 {
12544         struct alc_spec *spec = codec->spec;
12545         alc262_auto_init_multi_out(codec);
12546         alc262_auto_init_hp_out(codec);
12547         alc262_auto_init_analog_input(codec);
12548         alc262_auto_init_input_src(codec);
12549         alc_auto_init_digital(codec);
12550         if (spec->unsol_event)
12551                 alc_inithook(codec);
12552 }
12553
12554 /*
12555  * configuration and preset
12556  */
12557 static const char *alc262_models[ALC262_MODEL_LAST] = {
12558         [ALC262_BASIC]          = "basic",
12559         [ALC262_HIPPO]          = "hippo",
12560         [ALC262_HIPPO_1]        = "hippo_1",
12561         [ALC262_FUJITSU]        = "fujitsu",
12562         [ALC262_HP_BPC]         = "hp-bpc",
12563         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12564         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12565         [ALC262_HP_RP5700]      = "hp-rp5700",
12566         [ALC262_BENQ_ED8]       = "benq",
12567         [ALC262_BENQ_T31]       = "benq-t31",
12568         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12569         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12570         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12571         [ALC262_ULTRA]          = "ultra",
12572         [ALC262_LENOVO_3000]    = "lenovo-3000",
12573         [ALC262_NEC]            = "nec",
12574         [ALC262_TYAN]           = "tyan",
12575         [ALC262_AUTO]           = "auto",
12576 };
12577
12578 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12579         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12580         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12581         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12582                            ALC262_HP_BPC),
12583         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12584                            ALC262_HP_BPC),
12585         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12586                            ALC262_HP_BPC),
12587         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12588         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12589         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12590         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12591         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12592         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12593         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12594         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12595         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12596         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12597         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12598         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12599                       ALC262_HP_TC_T5735),
12600         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12601         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12602         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12603         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12604         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12605         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12606         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12607         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12608 #if 0 /* disable the quirk since model=auto works better in recent versions */
12609         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12610                            ALC262_SONY_ASSAMD),
12611 #endif
12612         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12613                       ALC262_TOSHIBA_RX1),
12614         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12615         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12616         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12617         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12618         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12619                            ALC262_ULTRA),
12620         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12621         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12622         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12623         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12624         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12625         {}
12626 };
12627
12628 static struct alc_config_preset alc262_presets[] = {
12629         [ALC262_BASIC] = {
12630                 .mixers = { alc262_base_mixer },
12631                 .init_verbs = { alc262_init_verbs },
12632                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12633                 .dac_nids = alc262_dac_nids,
12634                 .hp_nid = 0x03,
12635                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12636                 .channel_mode = alc262_modes,
12637                 .input_mux = &alc262_capture_source,
12638         },
12639         [ALC262_HIPPO] = {
12640                 .mixers = { alc262_hippo_mixer },
12641                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12642                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12643                 .dac_nids = alc262_dac_nids,
12644                 .hp_nid = 0x03,
12645                 .dig_out_nid = ALC262_DIGOUT_NID,
12646                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12647                 .channel_mode = alc262_modes,
12648                 .input_mux = &alc262_capture_source,
12649                 .unsol_event = alc262_hippo_unsol_event,
12650                 .setup = alc262_hippo_setup,
12651                 .init_hook = alc262_hippo_automute,
12652         },
12653         [ALC262_HIPPO_1] = {
12654                 .mixers = { alc262_hippo1_mixer },
12655                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12656                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12657                 .dac_nids = alc262_dac_nids,
12658                 .hp_nid = 0x02,
12659                 .dig_out_nid = ALC262_DIGOUT_NID,
12660                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12661                 .channel_mode = alc262_modes,
12662                 .input_mux = &alc262_capture_source,
12663                 .unsol_event = alc262_hippo_unsol_event,
12664                 .setup = alc262_hippo1_setup,
12665                 .init_hook = alc262_hippo_automute,
12666         },
12667         [ALC262_FUJITSU] = {
12668                 .mixers = { alc262_fujitsu_mixer },
12669                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12670                                 alc262_fujitsu_unsol_verbs },
12671                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12672                 .dac_nids = alc262_dac_nids,
12673                 .hp_nid = 0x03,
12674                 .dig_out_nid = ALC262_DIGOUT_NID,
12675                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12676                 .channel_mode = alc262_modes,
12677                 .input_mux = &alc262_fujitsu_capture_source,
12678                 .unsol_event = alc262_fujitsu_unsol_event,
12679                 .init_hook = alc262_fujitsu_init_hook,
12680         },
12681         [ALC262_HP_BPC] = {
12682                 .mixers = { alc262_HP_BPC_mixer },
12683                 .init_verbs = { alc262_HP_BPC_init_verbs },
12684                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12685                 .dac_nids = alc262_dac_nids,
12686                 .hp_nid = 0x03,
12687                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12688                 .channel_mode = alc262_modes,
12689                 .input_mux = &alc262_HP_capture_source,
12690                 .unsol_event = alc262_hp_bpc_unsol_event,
12691                 .init_hook = alc262_hp_bpc_automute,
12692         },
12693         [ALC262_HP_BPC_D7000_WF] = {
12694                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12695                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12696                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12697                 .dac_nids = alc262_dac_nids,
12698                 .hp_nid = 0x03,
12699                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12700                 .channel_mode = alc262_modes,
12701                 .input_mux = &alc262_HP_D7000_capture_source,
12702                 .unsol_event = alc262_hp_wildwest_unsol_event,
12703                 .init_hook = alc262_hp_wildwest_automute,
12704         },
12705         [ALC262_HP_BPC_D7000_WL] = {
12706                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12707                             alc262_HP_BPC_WildWest_option_mixer },
12708                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12709                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12710                 .dac_nids = alc262_dac_nids,
12711                 .hp_nid = 0x03,
12712                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12713                 .channel_mode = alc262_modes,
12714                 .input_mux = &alc262_HP_D7000_capture_source,
12715                 .unsol_event = alc262_hp_wildwest_unsol_event,
12716                 .init_hook = alc262_hp_wildwest_automute,
12717         },
12718         [ALC262_HP_TC_T5735] = {
12719                 .mixers = { alc262_hp_t5735_mixer },
12720                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12721                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12722                 .dac_nids = alc262_dac_nids,
12723                 .hp_nid = 0x03,
12724                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12725                 .channel_mode = alc262_modes,
12726                 .input_mux = &alc262_capture_source,
12727                 .unsol_event = alc_sku_unsol_event,
12728                 .setup = alc262_hp_t5735_setup,
12729                 .init_hook = alc_inithook,
12730         },
12731         [ALC262_HP_RP5700] = {
12732                 .mixers = { alc262_hp_rp5700_mixer },
12733                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12734                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12735                 .dac_nids = alc262_dac_nids,
12736                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12737                 .channel_mode = alc262_modes,
12738                 .input_mux = &alc262_hp_rp5700_capture_source,
12739         },
12740         [ALC262_BENQ_ED8] = {
12741                 .mixers = { alc262_base_mixer },
12742                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12743                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12744                 .dac_nids = alc262_dac_nids,
12745                 .hp_nid = 0x03,
12746                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12747                 .channel_mode = alc262_modes,
12748                 .input_mux = &alc262_capture_source,
12749         },
12750         [ALC262_SONY_ASSAMD] = {
12751                 .mixers = { alc262_sony_mixer },
12752                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12753                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12754                 .dac_nids = alc262_dac_nids,
12755                 .hp_nid = 0x02,
12756                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12757                 .channel_mode = alc262_modes,
12758                 .input_mux = &alc262_capture_source,
12759                 .unsol_event = alc262_hippo_unsol_event,
12760                 .setup = alc262_hippo_setup,
12761                 .init_hook = alc262_hippo_automute,
12762         },
12763         [ALC262_BENQ_T31] = {
12764                 .mixers = { alc262_benq_t31_mixer },
12765                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12766                                 alc_hp15_unsol_verbs },
12767                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12768                 .dac_nids = alc262_dac_nids,
12769                 .hp_nid = 0x03,
12770                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12771                 .channel_mode = alc262_modes,
12772                 .input_mux = &alc262_capture_source,
12773                 .unsol_event = alc262_hippo_unsol_event,
12774                 .setup = alc262_hippo_setup,
12775                 .init_hook = alc262_hippo_automute,
12776         },
12777         [ALC262_ULTRA] = {
12778                 .mixers = { alc262_ultra_mixer },
12779                 .cap_mixer = alc262_ultra_capture_mixer,
12780                 .init_verbs = { alc262_ultra_verbs },
12781                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12782                 .dac_nids = alc262_dac_nids,
12783                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12784                 .channel_mode = alc262_modes,
12785                 .input_mux = &alc262_ultra_capture_source,
12786                 .adc_nids = alc262_adc_nids, /* ADC0 */
12787                 .capsrc_nids = alc262_capsrc_nids,
12788                 .num_adc_nids = 1, /* single ADC */
12789                 .unsol_event = alc262_ultra_unsol_event,
12790                 .init_hook = alc262_ultra_automute,
12791         },
12792         [ALC262_LENOVO_3000] = {
12793                 .mixers = { alc262_lenovo_3000_mixer },
12794                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12795                                 alc262_lenovo_3000_unsol_verbs,
12796                                 alc262_lenovo_3000_init_verbs },
12797                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12798                 .dac_nids = alc262_dac_nids,
12799                 .hp_nid = 0x03,
12800                 .dig_out_nid = ALC262_DIGOUT_NID,
12801                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12802                 .channel_mode = alc262_modes,
12803                 .input_mux = &alc262_fujitsu_capture_source,
12804                 .unsol_event = alc262_lenovo_3000_unsol_event,
12805         },
12806         [ALC262_NEC] = {
12807                 .mixers = { alc262_nec_mixer },
12808                 .init_verbs = { alc262_nec_verbs },
12809                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12810                 .dac_nids = alc262_dac_nids,
12811                 .hp_nid = 0x03,
12812                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12813                 .channel_mode = alc262_modes,
12814                 .input_mux = &alc262_capture_source,
12815         },
12816         [ALC262_TOSHIBA_S06] = {
12817                 .mixers = { alc262_toshiba_s06_mixer },
12818                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12819                                                         alc262_eapd_verbs },
12820                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12821                 .capsrc_nids = alc262_dmic_capsrc_nids,
12822                 .dac_nids = alc262_dac_nids,
12823                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12824                 .num_adc_nids = 1, /* single ADC */
12825                 .dig_out_nid = ALC262_DIGOUT_NID,
12826                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12827                 .channel_mode = alc262_modes,
12828                 .unsol_event = alc_sku_unsol_event,
12829                 .setup = alc262_toshiba_s06_setup,
12830                 .init_hook = alc_inithook,
12831         },
12832         [ALC262_TOSHIBA_RX1] = {
12833                 .mixers = { alc262_toshiba_rx1_mixer },
12834                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12835                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12836                 .dac_nids = alc262_dac_nids,
12837                 .hp_nid = 0x03,
12838                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12839                 .channel_mode = alc262_modes,
12840                 .input_mux = &alc262_capture_source,
12841                 .unsol_event = alc262_hippo_unsol_event,
12842                 .setup = alc262_hippo_setup,
12843                 .init_hook = alc262_hippo_automute,
12844         },
12845         [ALC262_TYAN] = {
12846                 .mixers = { alc262_tyan_mixer },
12847                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12848                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12849                 .dac_nids = alc262_dac_nids,
12850                 .hp_nid = 0x02,
12851                 .dig_out_nid = ALC262_DIGOUT_NID,
12852                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12853                 .channel_mode = alc262_modes,
12854                 .input_mux = &alc262_capture_source,
12855                 .unsol_event = alc_automute_amp_unsol_event,
12856                 .setup = alc262_tyan_setup,
12857                 .init_hook = alc_automute_amp,
12858         },
12859 };
12860
12861 static int patch_alc262(struct hda_codec *codec)
12862 {
12863         struct alc_spec *spec;
12864         int board_config;
12865         int err;
12866
12867         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12868         if (spec == NULL)
12869                 return -ENOMEM;
12870
12871         codec->spec = spec;
12872 #if 0
12873         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12874          * under-run
12875          */
12876         {
12877         int tmp;
12878         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12879         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12880         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12881         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12882         }
12883 #endif
12884         alc_auto_parse_customize_define(codec);
12885
12886         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12887
12888         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12889                                                   alc262_models,
12890                                                   alc262_cfg_tbl);
12891
12892         if (board_config < 0) {
12893                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12894                        codec->chip_name);
12895                 board_config = ALC262_AUTO;
12896         }
12897
12898         if (board_config == ALC262_AUTO)
12899                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1);
12900
12901         if (board_config == ALC262_AUTO) {
12902                 /* automatic parse from the BIOS config */
12903                 err = alc262_parse_auto_config(codec);
12904                 if (err < 0) {
12905                         alc_free(codec);
12906                         return err;
12907                 } else if (!err) {
12908                         printk(KERN_INFO
12909                                "hda_codec: Cannot set up configuration "
12910                                "from BIOS.  Using base mode...\n");
12911                         board_config = ALC262_BASIC;
12912                 }
12913         }
12914
12915         if (!spec->no_analog && has_cdefine_beep(codec)) {
12916                 err = snd_hda_attach_beep_device(codec, 0x1);
12917                 if (err < 0) {
12918                         alc_free(codec);
12919                         return err;
12920                 }
12921         }
12922
12923         if (board_config != ALC262_AUTO)
12924                 setup_preset(codec, &alc262_presets[board_config]);
12925
12926         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12927         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12928
12929         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12930         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12931
12932         if (!spec->adc_nids && spec->input_mux) {
12933                 int i;
12934                 /* check whether the digital-mic has to be supported */
12935                 for (i = 0; i < spec->input_mux->num_items; i++) {
12936                         if (spec->input_mux->items[i].index >= 9)
12937                                 break;
12938                 }
12939                 if (i < spec->input_mux->num_items) {
12940                         /* use only ADC0 */
12941                         spec->adc_nids = alc262_dmic_adc_nids;
12942                         spec->num_adc_nids = 1;
12943                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12944                 } else {
12945                         /* all analog inputs */
12946                         /* check whether NID 0x07 is valid */
12947                         unsigned int wcap = get_wcaps(codec, 0x07);
12948
12949                         /* get type */
12950                         wcap = get_wcaps_type(wcap);
12951                         if (wcap != AC_WID_AUD_IN) {
12952                                 spec->adc_nids = alc262_adc_nids_alt;
12953                                 spec->num_adc_nids =
12954                                         ARRAY_SIZE(alc262_adc_nids_alt);
12955                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12956                         } else {
12957                                 spec->adc_nids = alc262_adc_nids;
12958                                 spec->num_adc_nids =
12959                                         ARRAY_SIZE(alc262_adc_nids);
12960                                 spec->capsrc_nids = alc262_capsrc_nids;
12961                         }
12962                 }
12963         }
12964         if (!spec->cap_mixer && !spec->no_analog)
12965                 set_capture_mixer(codec);
12966         if (!spec->no_analog && has_cdefine_beep(codec))
12967                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12968
12969         if (board_config == ALC262_AUTO)
12970                 alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0);
12971
12972         spec->vmaster_nid = 0x0c;
12973
12974         codec->patch_ops = alc_patch_ops;
12975         if (board_config == ALC262_AUTO)
12976                 spec->init_hook = alc262_auto_init;
12977
12978         alc_init_jacks(codec);
12979 #ifdef CONFIG_SND_HDA_POWER_SAVE
12980         if (!spec->loopback.amplist)
12981                 spec->loopback.amplist = alc262_loopbacks;
12982 #endif
12983
12984         return 0;
12985 }
12986
12987 /*
12988  *  ALC268 channel source setting (2 channel)
12989  */
12990 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12991 #define alc268_modes            alc260_modes
12992
12993 static hda_nid_t alc268_dac_nids[2] = {
12994         /* front, hp */
12995         0x02, 0x03
12996 };
12997
12998 static hda_nid_t alc268_adc_nids[2] = {
12999         /* ADC0-1 */
13000         0x08, 0x07
13001 };
13002
13003 static hda_nid_t alc268_adc_nids_alt[1] = {
13004         /* ADC0 */
13005         0x08
13006 };
13007
13008 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13009
13010 static struct snd_kcontrol_new alc268_base_mixer[] = {
13011         /* output mixer control */
13012         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13013         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13014         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13015         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13016         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13017         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13018         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13019         { }
13020 };
13021
13022 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13023         /* output mixer control */
13024         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13025         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13026         ALC262_HIPPO_MASTER_SWITCH,
13027         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13028         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13029         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13030         { }
13031 };
13032
13033 /* bind Beep switches of both NID 0x0f and 0x10 */
13034 static struct hda_bind_ctls alc268_bind_beep_sw = {
13035         .ops = &snd_hda_bind_sw,
13036         .values = {
13037                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13038                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13039                 0
13040         },
13041 };
13042
13043 static struct snd_kcontrol_new alc268_beep_mixer[] = {
13044         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13045         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13046         { }
13047 };
13048
13049 static struct hda_verb alc268_eapd_verbs[] = {
13050         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13051         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13052         { }
13053 };
13054
13055 /* Toshiba specific */
13056 static struct hda_verb alc268_toshiba_verbs[] = {
13057         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13058         { } /* end */
13059 };
13060
13061 /* Acer specific */
13062 /* bind volumes of both NID 0x02 and 0x03 */
13063 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13064         .ops = &snd_hda_bind_vol,
13065         .values = {
13066                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13067                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13068                 0
13069         },
13070 };
13071
13072 /* mute/unmute internal speaker according to the hp jack and mute state */
13073 static void alc268_acer_automute(struct hda_codec *codec, int force)
13074 {
13075         struct alc_spec *spec = codec->spec;
13076         unsigned int mute;
13077
13078         if (force || !spec->sense_updated) {
13079                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13080                 spec->sense_updated = 1;
13081         }
13082         if (spec->jack_present)
13083                 mute = HDA_AMP_MUTE; /* mute internal speaker */
13084         else /* unmute internal speaker if necessary */
13085                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13086         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13087                                  HDA_AMP_MUTE, mute);
13088 }
13089
13090
13091 /* bind hp and internal speaker mute (with plug check) */
13092 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13093                                      struct snd_ctl_elem_value *ucontrol)
13094 {
13095         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13096         long *valp = ucontrol->value.integer.value;
13097         int change;
13098
13099         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13100         if (change)
13101                 alc268_acer_automute(codec, 0);
13102         return change;
13103 }
13104
13105 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13106         /* output mixer control */
13107         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13108         {
13109                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13110                 .name = "Master Playback Switch",
13111                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13112                 .info = snd_hda_mixer_amp_switch_info,
13113                 .get = snd_hda_mixer_amp_switch_get,
13114                 .put = alc268_acer_master_sw_put,
13115                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13116         },
13117         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13118         { }
13119 };
13120
13121 static struct snd_kcontrol_new alc268_acer_mixer[] = {
13122         /* output mixer control */
13123         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13124         {
13125                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13126                 .name = "Master Playback Switch",
13127                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13128                 .info = snd_hda_mixer_amp_switch_info,
13129                 .get = snd_hda_mixer_amp_switch_get,
13130                 .put = alc268_acer_master_sw_put,
13131                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13132         },
13133         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13134         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13135         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13136         { }
13137 };
13138
13139 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13140         /* output mixer control */
13141         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13142         {
13143                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13144                 .name = "Master Playback Switch",
13145                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13146                 .info = snd_hda_mixer_amp_switch_info,
13147                 .get = snd_hda_mixer_amp_switch_get,
13148                 .put = alc268_acer_master_sw_put,
13149                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13150         },
13151         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13152         HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13153         { }
13154 };
13155
13156 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13157         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13158         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13159         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13160         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13161         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13162         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13163         { }
13164 };
13165
13166 static struct hda_verb alc268_acer_verbs[] = {
13167         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13168         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13169         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13170         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13171         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13172         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13173         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13174         { }
13175 };
13176
13177 /* unsolicited event for HP jack sensing */
13178 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
13179 #define alc268_toshiba_setup            alc262_hippo_setup
13180 #define alc268_toshiba_automute         alc262_hippo_automute
13181
13182 static void alc268_acer_unsol_event(struct hda_codec *codec,
13183                                        unsigned int res)
13184 {
13185         if ((res >> 26) != ALC880_HP_EVENT)
13186                 return;
13187         alc268_acer_automute(codec, 1);
13188 }
13189
13190 static void alc268_acer_init_hook(struct hda_codec *codec)
13191 {
13192         alc268_acer_automute(codec, 1);
13193 }
13194
13195 /* toggle speaker-output according to the hp-jack state */
13196 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13197 {
13198         unsigned int present;
13199         unsigned char bits;
13200
13201         present = snd_hda_jack_detect(codec, 0x15);
13202         bits = present ? HDA_AMP_MUTE : 0;
13203         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13204                                  HDA_AMP_MUTE, bits);
13205         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13206                                  HDA_AMP_MUTE, bits);
13207 }
13208
13209 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13210                                     unsigned int res)
13211 {
13212         switch (res >> 26) {
13213         case ALC880_HP_EVENT:
13214                 alc268_aspire_one_speaker_automute(codec);
13215                 break;
13216         case ALC880_MIC_EVENT:
13217                 alc_mic_automute(codec);
13218                 break;
13219         }
13220 }
13221
13222 static void alc268_acer_lc_setup(struct hda_codec *codec)
13223 {
13224         struct alc_spec *spec = codec->spec;
13225         spec->ext_mic.pin = 0x18;
13226         spec->ext_mic.mux_idx = 0;
13227         spec->int_mic.pin = 0x12;
13228         spec->int_mic.mux_idx = 6;
13229         spec->auto_mic = 1;
13230 }
13231
13232 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13233 {
13234         alc268_aspire_one_speaker_automute(codec);
13235         alc_mic_automute(codec);
13236 }
13237
13238 static struct snd_kcontrol_new alc268_dell_mixer[] = {
13239         /* output mixer control */
13240         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13241         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13242         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13243         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13244         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13245         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13246         { }
13247 };
13248
13249 static struct hda_verb alc268_dell_verbs[] = {
13250         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13251         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13252         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13253         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13254         { }
13255 };
13256
13257 /* mute/unmute internal speaker according to the hp jack and mute state */
13258 static void alc268_dell_setup(struct hda_codec *codec)
13259 {
13260         struct alc_spec *spec = codec->spec;
13261
13262         spec->autocfg.hp_pins[0] = 0x15;
13263         spec->autocfg.speaker_pins[0] = 0x14;
13264         spec->ext_mic.pin = 0x18;
13265         spec->ext_mic.mux_idx = 0;
13266         spec->int_mic.pin = 0x19;
13267         spec->int_mic.mux_idx = 1;
13268         spec->auto_mic = 1;
13269 }
13270
13271 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13272         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13273         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13274         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13275         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13276         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13277         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13278         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13279         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13280         { }
13281 };
13282
13283 static struct hda_verb alc267_quanta_il1_verbs[] = {
13284         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13285         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13286         { }
13287 };
13288
13289 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13290 {
13291         struct alc_spec *spec = codec->spec;
13292         spec->autocfg.hp_pins[0] = 0x15;
13293         spec->autocfg.speaker_pins[0] = 0x14;
13294         spec->ext_mic.pin = 0x18;
13295         spec->ext_mic.mux_idx = 0;
13296         spec->int_mic.pin = 0x19;
13297         spec->int_mic.mux_idx = 1;
13298         spec->auto_mic = 1;
13299 }
13300
13301 /*
13302  * generic initialization of ADC, input mixers and output mixers
13303  */
13304 static struct hda_verb alc268_base_init_verbs[] = {
13305         /* Unmute DAC0-1 and set vol = 0 */
13306         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13307         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13308
13309         /*
13310          * Set up output mixers (0x0c - 0x0e)
13311          */
13312         /* set vol=0 to output mixers */
13313         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13314         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13315
13316         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13317         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13318
13319         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13320         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13321         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13322         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13323         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13324         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13325         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13326         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13327
13328         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13329         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13330         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13331         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13332         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13333
13334         /* set PCBEEP vol = 0, mute connections */
13335         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13336         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13337         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13338
13339         /* Unmute Selector 23h,24h and set the default input to mic-in */
13340
13341         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13342         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13343         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13344         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13345
13346         { }
13347 };
13348
13349 /*
13350  * generic initialization of ADC, input mixers and output mixers
13351  */
13352 static struct hda_verb alc268_volume_init_verbs[] = {
13353         /* set output DAC */
13354         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13355         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13356
13357         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13358         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13359         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13360         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13361         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13362
13363         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13364         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13365         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13366
13367         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13368         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13369
13370         /* set PCBEEP vol = 0, mute connections */
13371         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13372         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13373         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13374
13375         { }
13376 };
13377
13378 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13379         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13380         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13381         { } /* end */
13382 };
13383
13384 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13385         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13386         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13387         _DEFINE_CAPSRC(1),
13388         { } /* end */
13389 };
13390
13391 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13392         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13393         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13394         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13395         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13396         _DEFINE_CAPSRC(2),
13397         { } /* end */
13398 };
13399
13400 static struct hda_input_mux alc268_capture_source = {
13401         .num_items = 4,
13402         .items = {
13403                 { "Mic", 0x0 },
13404                 { "Front Mic", 0x1 },
13405                 { "Line", 0x2 },
13406                 { "CD", 0x3 },
13407         },
13408 };
13409
13410 static struct hda_input_mux alc268_acer_capture_source = {
13411         .num_items = 3,
13412         .items = {
13413                 { "Mic", 0x0 },
13414                 { "Internal Mic", 0x1 },
13415                 { "Line", 0x2 },
13416         },
13417 };
13418
13419 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13420         .num_items = 3,
13421         .items = {
13422                 { "Mic", 0x0 },
13423                 { "Internal Mic", 0x6 },
13424                 { "Line", 0x2 },
13425         },
13426 };
13427
13428 #ifdef CONFIG_SND_DEBUG
13429 static struct snd_kcontrol_new alc268_test_mixer[] = {
13430         /* Volume widgets */
13431         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13432         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13433         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13434         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13435         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13436         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13437         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13438         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13439         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13440         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13441         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13442         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13443         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13444         /* The below appears problematic on some hardwares */
13445         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13446         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13447         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13448         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13449         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13450
13451         /* Modes for retasking pin widgets */
13452         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13453         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13454         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13455         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13456
13457         /* Controls for GPIO pins, assuming they are configured as outputs */
13458         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13459         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13460         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13461         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13462
13463         /* Switches to allow the digital SPDIF output pin to be enabled.
13464          * The ALC268 does not have an SPDIF input.
13465          */
13466         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13467
13468         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13469          * this output to turn on an external amplifier.
13470          */
13471         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13472         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13473
13474         { } /* end */
13475 };
13476 #endif
13477
13478 /* create input playback/capture controls for the given pin */
13479 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13480                                     const char *ctlname, int idx)
13481 {
13482         hda_nid_t dac;
13483         int err;
13484
13485         switch (nid) {
13486         case 0x14:
13487         case 0x16:
13488                 dac = 0x02;
13489                 break;
13490         case 0x15:
13491         case 0x1a: /* ALC259/269 only */
13492         case 0x1b: /* ALC259/269 only */
13493         case 0x21: /* ALC269vb has this pin, too */
13494                 dac = 0x03;
13495                 break;
13496         default:
13497                 snd_printd(KERN_WARNING "hda_codec: "
13498                            "ignoring pin 0x%x as unknown\n", nid);
13499                 return 0;
13500         }
13501         if (spec->multiout.dac_nids[0] != dac &&
13502             spec->multiout.dac_nids[1] != dac) {
13503                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13504                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13505                                                       HDA_OUTPUT));
13506                 if (err < 0)
13507                         return err;
13508                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13509         }
13510
13511         if (nid != 0x16)
13512                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13513                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13514         else /* mono */
13515                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13516                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13517         if (err < 0)
13518                 return err;
13519         return 0;
13520 }
13521
13522 /* add playback controls from the parsed DAC table */
13523 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13524                                              const struct auto_pin_cfg *cfg)
13525 {
13526         hda_nid_t nid;
13527         int err;
13528
13529         spec->multiout.dac_nids = spec->private_dac_nids;
13530
13531         nid = cfg->line_out_pins[0];
13532         if (nid) {
13533                 const char *name;
13534                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13535                         name = "Speaker";
13536                 else
13537                         name = "Front";
13538                 err = alc268_new_analog_output(spec, nid, name, 0);
13539                 if (err < 0)
13540                         return err;
13541         }
13542
13543         nid = cfg->speaker_pins[0];
13544         if (nid == 0x1d) {
13545                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13546                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13547                 if (err < 0)
13548                         return err;
13549         } else if (nid) {
13550                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13551                 if (err < 0)
13552                         return err;
13553         }
13554         nid = cfg->hp_pins[0];
13555         if (nid) {
13556                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13557                 if (err < 0)
13558                         return err;
13559         }
13560
13561         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13562         if (nid == 0x16) {
13563                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13564                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13565                 if (err < 0)
13566                         return err;
13567         }
13568         return 0;
13569 }
13570
13571 /* create playback/capture controls for input pins */
13572 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13573                                                 const struct auto_pin_cfg *cfg)
13574 {
13575         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13576 }
13577
13578 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13579                                               hda_nid_t nid, int pin_type)
13580 {
13581         int idx;
13582
13583         alc_set_pin_output(codec, nid, pin_type);
13584         if (nid == 0x14 || nid == 0x16)
13585                 idx = 0;
13586         else
13587                 idx = 1;
13588         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13589 }
13590
13591 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13592 {
13593         struct alc_spec *spec = codec->spec;
13594         int i;
13595
13596         for (i = 0; i < spec->autocfg.line_outs; i++) {
13597                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13598                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13599                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13600         }
13601 }
13602
13603 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13604 {
13605         struct alc_spec *spec = codec->spec;
13606         hda_nid_t pin;
13607         int i;
13608
13609         for (i = 0; i < spec->autocfg.hp_outs; i++) {
13610                 pin = spec->autocfg.hp_pins[i];
13611                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13612         }
13613         for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13614                 pin = spec->autocfg.speaker_pins[i];
13615                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13616         }
13617         if (spec->autocfg.mono_out_pin)
13618                 snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13619                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13620 }
13621
13622 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13623 {
13624         struct alc_spec *spec = codec->spec;
13625         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13626         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13627         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13628         unsigned int    dac_vol1, dac_vol2;
13629
13630         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13631                 snd_hda_codec_write(codec, speaker_nid, 0,
13632                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13633                 /* mute mixer inputs from 0x1d */
13634                 snd_hda_codec_write(codec, 0x0f, 0,
13635                                     AC_VERB_SET_AMP_GAIN_MUTE,
13636                                     AMP_IN_UNMUTE(1));
13637                 snd_hda_codec_write(codec, 0x10, 0,
13638                                     AC_VERB_SET_AMP_GAIN_MUTE,
13639                                     AMP_IN_UNMUTE(1));
13640         } else {
13641                 /* unmute mixer inputs from 0x1d */
13642                 snd_hda_codec_write(codec, 0x0f, 0,
13643                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13644                 snd_hda_codec_write(codec, 0x10, 0,
13645                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13646         }
13647
13648         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13649         if (line_nid == 0x14)
13650                 dac_vol2 = AMP_OUT_ZERO;
13651         else if (line_nid == 0x15)
13652                 dac_vol1 = AMP_OUT_ZERO;
13653         if (hp_nid == 0x14)
13654                 dac_vol2 = AMP_OUT_ZERO;
13655         else if (hp_nid == 0x15)
13656                 dac_vol1 = AMP_OUT_ZERO;
13657         if (line_nid != 0x16 || hp_nid != 0x16 ||
13658             spec->autocfg.line_out_pins[1] != 0x16 ||
13659             spec->autocfg.line_out_pins[2] != 0x16)
13660                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13661
13662         snd_hda_codec_write(codec, 0x02, 0,
13663                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13664         snd_hda_codec_write(codec, 0x03, 0,
13665                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13666 }
13667
13668 /* pcm configuration: identical with ALC880 */
13669 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13670 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13671 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13672 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13673
13674 /*
13675  * BIOS auto configuration
13676  */
13677 static int alc268_parse_auto_config(struct hda_codec *codec)
13678 {
13679         struct alc_spec *spec = codec->spec;
13680         int err;
13681         static hda_nid_t alc268_ignore[] = { 0 };
13682
13683         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13684                                            alc268_ignore);
13685         if (err < 0)
13686                 return err;
13687         if (!spec->autocfg.line_outs) {
13688                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13689                         spec->multiout.max_channels = 2;
13690                         spec->no_analog = 1;
13691                         goto dig_only;
13692                 }
13693                 return 0; /* can't find valid BIOS pin config */
13694         }
13695         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13696         if (err < 0)
13697                 return err;
13698         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13699         if (err < 0)
13700                 return err;
13701
13702         spec->multiout.max_channels = 2;
13703
13704  dig_only:
13705         /* digital only support output */
13706         alc_auto_parse_digital(codec);
13707         if (spec->kctls.list)
13708                 add_mixer(spec, spec->kctls.list);
13709
13710         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13711                 add_mixer(spec, alc268_beep_mixer);
13712
13713         add_verb(spec, alc268_volume_init_verbs);
13714         spec->num_mux_defs = 2;
13715         spec->input_mux = &spec->private_imux[0];
13716
13717         err = alc_auto_add_mic_boost(codec);
13718         if (err < 0)
13719                 return err;
13720
13721         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13722
13723         return 1;
13724 }
13725
13726 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13727
13728 /* init callback for auto-configuration model -- overriding the default init */
13729 static void alc268_auto_init(struct hda_codec *codec)
13730 {
13731         struct alc_spec *spec = codec->spec;
13732         alc268_auto_init_multi_out(codec);
13733         alc268_auto_init_hp_out(codec);
13734         alc268_auto_init_mono_speaker_out(codec);
13735         alc268_auto_init_analog_input(codec);
13736         alc_auto_init_digital(codec);
13737         if (spec->unsol_event)
13738                 alc_inithook(codec);
13739 }
13740
13741 /*
13742  * configuration and preset
13743  */
13744 static const char *alc268_models[ALC268_MODEL_LAST] = {
13745         [ALC267_QUANTA_IL1]     = "quanta-il1",
13746         [ALC268_3ST]            = "3stack",
13747         [ALC268_TOSHIBA]        = "toshiba",
13748         [ALC268_ACER]           = "acer",
13749         [ALC268_ACER_DMIC]      = "acer-dmic",
13750         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13751         [ALC268_DELL]           = "dell",
13752         [ALC268_ZEPTO]          = "zepto",
13753 #ifdef CONFIG_SND_DEBUG
13754         [ALC268_TEST]           = "test",
13755 #endif
13756         [ALC268_AUTO]           = "auto",
13757 };
13758
13759 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13760         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13761         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13762         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13763         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13764         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13765         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13766                                                 ALC268_ACER_ASPIRE_ONE),
13767         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13768         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13769                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13770         /* almost compatible with toshiba but with optional digital outs;
13771          * auto-probing seems working fine
13772          */
13773         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13774                            ALC268_AUTO),
13775         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13776         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13777         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13778         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13779         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13780         {}
13781 };
13782
13783 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13784 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13785         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13786         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13787         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13788                            ALC268_TOSHIBA),
13789         {}
13790 };
13791
13792 static struct alc_config_preset alc268_presets[] = {
13793         [ALC267_QUANTA_IL1] = {
13794                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13795                             alc268_capture_nosrc_mixer },
13796                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13797                                 alc267_quanta_il1_verbs },
13798                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13799                 .dac_nids = alc268_dac_nids,
13800                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13801                 .adc_nids = alc268_adc_nids_alt,
13802                 .hp_nid = 0x03,
13803                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13804                 .channel_mode = alc268_modes,
13805                 .unsol_event = alc_sku_unsol_event,
13806                 .setup = alc267_quanta_il1_setup,
13807                 .init_hook = alc_inithook,
13808         },
13809         [ALC268_3ST] = {
13810                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13811                             alc268_beep_mixer },
13812                 .init_verbs = { alc268_base_init_verbs },
13813                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13814                 .dac_nids = alc268_dac_nids,
13815                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13816                 .adc_nids = alc268_adc_nids_alt,
13817                 .capsrc_nids = alc268_capsrc_nids,
13818                 .hp_nid = 0x03,
13819                 .dig_out_nid = ALC268_DIGOUT_NID,
13820                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13821                 .channel_mode = alc268_modes,
13822                 .input_mux = &alc268_capture_source,
13823         },
13824         [ALC268_TOSHIBA] = {
13825                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13826                             alc268_beep_mixer },
13827                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13828                                 alc268_toshiba_verbs },
13829                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13830                 .dac_nids = alc268_dac_nids,
13831                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13832                 .adc_nids = alc268_adc_nids_alt,
13833                 .capsrc_nids = alc268_capsrc_nids,
13834                 .hp_nid = 0x03,
13835                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13836                 .channel_mode = alc268_modes,
13837                 .input_mux = &alc268_capture_source,
13838                 .unsol_event = alc268_toshiba_unsol_event,
13839                 .setup = alc268_toshiba_setup,
13840                 .init_hook = alc268_toshiba_automute,
13841         },
13842         [ALC268_ACER] = {
13843                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13844                             alc268_beep_mixer },
13845                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13846                                 alc268_acer_verbs },
13847                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13848                 .dac_nids = alc268_dac_nids,
13849                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13850                 .adc_nids = alc268_adc_nids_alt,
13851                 .capsrc_nids = alc268_capsrc_nids,
13852                 .hp_nid = 0x02,
13853                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13854                 .channel_mode = alc268_modes,
13855                 .input_mux = &alc268_acer_capture_source,
13856                 .unsol_event = alc268_acer_unsol_event,
13857                 .init_hook = alc268_acer_init_hook,
13858         },
13859         [ALC268_ACER_DMIC] = {
13860                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13861                             alc268_beep_mixer },
13862                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13863                                 alc268_acer_verbs },
13864                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13865                 .dac_nids = alc268_dac_nids,
13866                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13867                 .adc_nids = alc268_adc_nids_alt,
13868                 .capsrc_nids = alc268_capsrc_nids,
13869                 .hp_nid = 0x02,
13870                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13871                 .channel_mode = alc268_modes,
13872                 .input_mux = &alc268_acer_dmic_capture_source,
13873                 .unsol_event = alc268_acer_unsol_event,
13874                 .init_hook = alc268_acer_init_hook,
13875         },
13876         [ALC268_ACER_ASPIRE_ONE] = {
13877                 .mixers = { alc268_acer_aspire_one_mixer,
13878                             alc268_beep_mixer,
13879                             alc268_capture_nosrc_mixer },
13880                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13881                                 alc268_acer_aspire_one_verbs },
13882                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13883                 .dac_nids = alc268_dac_nids,
13884                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13885                 .adc_nids = alc268_adc_nids_alt,
13886                 .capsrc_nids = alc268_capsrc_nids,
13887                 .hp_nid = 0x03,
13888                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13889                 .channel_mode = alc268_modes,
13890                 .unsol_event = alc268_acer_lc_unsol_event,
13891                 .setup = alc268_acer_lc_setup,
13892                 .init_hook = alc268_acer_lc_init_hook,
13893         },
13894         [ALC268_DELL] = {
13895                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13896                             alc268_capture_nosrc_mixer },
13897                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13898                                 alc268_dell_verbs },
13899                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13900                 .dac_nids = alc268_dac_nids,
13901                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13902                 .adc_nids = alc268_adc_nids_alt,
13903                 .capsrc_nids = alc268_capsrc_nids,
13904                 .hp_nid = 0x02,
13905                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13906                 .channel_mode = alc268_modes,
13907                 .unsol_event = alc_sku_unsol_event,
13908                 .setup = alc268_dell_setup,
13909                 .init_hook = alc_inithook,
13910         },
13911         [ALC268_ZEPTO] = {
13912                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13913                             alc268_beep_mixer },
13914                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13915                                 alc268_toshiba_verbs },
13916                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13917                 .dac_nids = alc268_dac_nids,
13918                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13919                 .adc_nids = alc268_adc_nids_alt,
13920                 .capsrc_nids = alc268_capsrc_nids,
13921                 .hp_nid = 0x03,
13922                 .dig_out_nid = ALC268_DIGOUT_NID,
13923                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13924                 .channel_mode = alc268_modes,
13925                 .input_mux = &alc268_capture_source,
13926                 .setup = alc268_toshiba_setup,
13927                 .init_hook = alc268_toshiba_automute,
13928         },
13929 #ifdef CONFIG_SND_DEBUG
13930         [ALC268_TEST] = {
13931                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13932                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13933                                 alc268_volume_init_verbs },
13934                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13935                 .dac_nids = alc268_dac_nids,
13936                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13937                 .adc_nids = alc268_adc_nids_alt,
13938                 .capsrc_nids = alc268_capsrc_nids,
13939                 .hp_nid = 0x03,
13940                 .dig_out_nid = ALC268_DIGOUT_NID,
13941                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13942                 .channel_mode = alc268_modes,
13943                 .input_mux = &alc268_capture_source,
13944         },
13945 #endif
13946 };
13947
13948 static int patch_alc268(struct hda_codec *codec)
13949 {
13950         struct alc_spec *spec;
13951         int board_config;
13952         int i, has_beep, err;
13953
13954         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13955         if (spec == NULL)
13956                 return -ENOMEM;
13957
13958         codec->spec = spec;
13959
13960         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13961                                                   alc268_models,
13962                                                   alc268_cfg_tbl);
13963
13964         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13965                 board_config = snd_hda_check_board_codec_sid_config(codec,
13966                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13967
13968         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13969                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13970                        codec->chip_name);
13971                 board_config = ALC268_AUTO;
13972         }
13973
13974         if (board_config == ALC268_AUTO) {
13975                 /* automatic parse from the BIOS config */
13976                 err = alc268_parse_auto_config(codec);
13977                 if (err < 0) {
13978                         alc_free(codec);
13979                         return err;
13980                 } else if (!err) {
13981                         printk(KERN_INFO
13982                                "hda_codec: Cannot set up configuration "
13983                                "from BIOS.  Using base mode...\n");
13984                         board_config = ALC268_3ST;
13985                 }
13986         }
13987
13988         if (board_config != ALC268_AUTO)
13989                 setup_preset(codec, &alc268_presets[board_config]);
13990
13991         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13992         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13993         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13994
13995         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13996
13997         has_beep = 0;
13998         for (i = 0; i < spec->num_mixers; i++) {
13999                 if (spec->mixers[i] == alc268_beep_mixer) {
14000                         has_beep = 1;
14001                         break;
14002                 }
14003         }
14004
14005         if (has_beep) {
14006                 err = snd_hda_attach_beep_device(codec, 0x1);
14007                 if (err < 0) {
14008                         alc_free(codec);
14009                         return err;
14010                 }
14011                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14012                         /* override the amp caps for beep generator */
14013                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14014                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14015                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14016                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14017                                           (0 << AC_AMPCAP_MUTE_SHIFT));
14018         }
14019
14020         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14021                 /* check whether NID 0x07 is valid */
14022                 unsigned int wcap = get_wcaps(codec, 0x07);
14023                 int i;
14024
14025                 spec->capsrc_nids = alc268_capsrc_nids;
14026                 /* get type */
14027                 wcap = get_wcaps_type(wcap);
14028                 if (spec->auto_mic ||
14029                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14030                         spec->adc_nids = alc268_adc_nids_alt;
14031                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14032                         if (spec->auto_mic)
14033                                 fixup_automic_adc(codec);
14034                         if (spec->auto_mic || spec->input_mux->num_items == 1)
14035                                 add_mixer(spec, alc268_capture_nosrc_mixer);
14036                         else
14037                                 add_mixer(spec, alc268_capture_alt_mixer);
14038                 } else {
14039                         spec->adc_nids = alc268_adc_nids;
14040                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14041                         add_mixer(spec, alc268_capture_mixer);
14042                 }
14043                 /* set default input source */
14044                 for (i = 0; i < spec->num_adc_nids; i++)
14045                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
14046                                 0, AC_VERB_SET_CONNECT_SEL,
14047                                 i < spec->num_mux_defs ?
14048                                 spec->input_mux[i].items[0].index :
14049                                 spec->input_mux->items[0].index);
14050         }
14051
14052         spec->vmaster_nid = 0x02;
14053
14054         codec->patch_ops = alc_patch_ops;
14055         if (board_config == ALC268_AUTO)
14056                 spec->init_hook = alc268_auto_init;
14057
14058         alc_init_jacks(codec);
14059
14060         return 0;
14061 }
14062
14063 /*
14064  *  ALC269 channel source setting (2 channel)
14065  */
14066 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
14067
14068 #define alc269_dac_nids         alc260_dac_nids
14069
14070 static hda_nid_t alc269_adc_nids[1] = {
14071         /* ADC1 */
14072         0x08,
14073 };
14074
14075 static hda_nid_t alc269_capsrc_nids[1] = {
14076         0x23,
14077 };
14078
14079 static hda_nid_t alc269vb_adc_nids[1] = {
14080         /* ADC1 */
14081         0x09,
14082 };
14083
14084 static hda_nid_t alc269vb_capsrc_nids[1] = {
14085         0x22,
14086 };
14087
14088 static hda_nid_t alc269_adc_candidates[] = {
14089         0x08, 0x09, 0x07,
14090 };
14091
14092 #define alc269_modes            alc260_modes
14093 #define alc269_capture_source   alc880_lg_lw_capture_source
14094
14095 static struct snd_kcontrol_new alc269_base_mixer[] = {
14096         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14097         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14098         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14099         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14100         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14101         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14102         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14103         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14104         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14105         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14106         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14107         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14108         { } /* end */
14109 };
14110
14111 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14112         /* output mixer control */
14113         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14114         {
14115                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14116                 .name = "Master Playback Switch",
14117                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14118                 .info = snd_hda_mixer_amp_switch_info,
14119                 .get = snd_hda_mixer_amp_switch_get,
14120                 .put = alc268_acer_master_sw_put,
14121                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14122         },
14123         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14124         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14125         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14126         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14127         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14128         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14129         { }
14130 };
14131
14132 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14133         /* output mixer control */
14134         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14135         {
14136                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14137                 .name = "Master Playback Switch",
14138                 .subdevice = HDA_SUBDEV_AMP_FLAG,
14139                 .info = snd_hda_mixer_amp_switch_info,
14140                 .get = snd_hda_mixer_amp_switch_get,
14141                 .put = alc268_acer_master_sw_put,
14142                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14143         },
14144         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14145         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14146         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14147         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14148         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14149         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14150         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14151         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14152         HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14153         { }
14154 };
14155
14156 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14157         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14158         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14159         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14160         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14161         { } /* end */
14162 };
14163
14164 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14165         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14166         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14167         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14168         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14169         { } /* end */
14170 };
14171
14172 static struct snd_kcontrol_new alc269_asus_mixer[] = {
14173         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14174         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14175         { } /* end */
14176 };
14177
14178 /* capture mixer elements */
14179 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14180         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14181         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14182         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14183         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14184         { } /* end */
14185 };
14186
14187 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14188         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14189         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14190         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14191         { } /* end */
14192 };
14193
14194 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14195         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14196         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14197         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14198         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14199         { } /* end */
14200 };
14201
14202 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14203         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14204         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14205         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14206         { } /* end */
14207 };
14208
14209 /* FSC amilo */
14210 #define alc269_fujitsu_mixer    alc269_laptop_mixer
14211
14212 static struct hda_verb alc269_quanta_fl1_verbs[] = {
14213         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14214         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14215         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14216         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14217         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14218         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14219         { }
14220 };
14221
14222 static struct hda_verb alc269_lifebook_verbs[] = {
14223         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14224         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14225         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14226         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14227         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14228         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14229         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14230         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14231         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14232         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14233         { }
14234 };
14235
14236 /* toggle speaker-output according to the hp-jack state */
14237 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14238 {
14239         unsigned int present;
14240         unsigned char bits;
14241
14242         present = snd_hda_jack_detect(codec, 0x15);
14243         bits = present ? HDA_AMP_MUTE : 0;
14244         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14245                                  HDA_AMP_MUTE, bits);
14246         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14247                                  HDA_AMP_MUTE, bits);
14248
14249         snd_hda_codec_write(codec, 0x20, 0,
14250                         AC_VERB_SET_COEF_INDEX, 0x0c);
14251         snd_hda_codec_write(codec, 0x20, 0,
14252                         AC_VERB_SET_PROC_COEF, 0x680);
14253
14254         snd_hda_codec_write(codec, 0x20, 0,
14255                         AC_VERB_SET_COEF_INDEX, 0x0c);
14256         snd_hda_codec_write(codec, 0x20, 0,
14257                         AC_VERB_SET_PROC_COEF, 0x480);
14258 }
14259
14260 /* toggle speaker-output according to the hp-jacks state */
14261 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14262 {
14263         unsigned int present;
14264         unsigned char bits;
14265
14266         /* Check laptop headphone socket */
14267         present = snd_hda_jack_detect(codec, 0x15);
14268
14269         /* Check port replicator headphone socket */
14270         present |= snd_hda_jack_detect(codec, 0x1a);
14271
14272         bits = present ? HDA_AMP_MUTE : 0;
14273         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14274                                  HDA_AMP_MUTE, bits);
14275         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14276                                  HDA_AMP_MUTE, bits);
14277
14278         snd_hda_codec_write(codec, 0x20, 0,
14279                         AC_VERB_SET_COEF_INDEX, 0x0c);
14280         snd_hda_codec_write(codec, 0x20, 0,
14281                         AC_VERB_SET_PROC_COEF, 0x680);
14282
14283         snd_hda_codec_write(codec, 0x20, 0,
14284                         AC_VERB_SET_COEF_INDEX, 0x0c);
14285         snd_hda_codec_write(codec, 0x20, 0,
14286                         AC_VERB_SET_PROC_COEF, 0x480);
14287 }
14288
14289 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14290 {
14291         unsigned int present_laptop;
14292         unsigned int present_dock;
14293
14294         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14295         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14296
14297         /* Laptop mic port overrides dock mic port, design decision */
14298         if (present_dock)
14299                 snd_hda_codec_write(codec, 0x23, 0,
14300                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14301         if (present_laptop)
14302                 snd_hda_codec_write(codec, 0x23, 0,
14303                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14304         if (!present_dock && !present_laptop)
14305                 snd_hda_codec_write(codec, 0x23, 0,
14306                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14307 }
14308
14309 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14310                                     unsigned int res)
14311 {
14312         switch (res >> 26) {
14313         case ALC880_HP_EVENT:
14314                 alc269_quanta_fl1_speaker_automute(codec);
14315                 break;
14316         case ALC880_MIC_EVENT:
14317                 alc_mic_automute(codec);
14318                 break;
14319         }
14320 }
14321
14322 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14323                                         unsigned int res)
14324 {
14325         if ((res >> 26) == ALC880_HP_EVENT)
14326                 alc269_lifebook_speaker_automute(codec);
14327         if ((res >> 26) == ALC880_MIC_EVENT)
14328                 alc269_lifebook_mic_autoswitch(codec);
14329 }
14330
14331 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14332 {
14333         struct alc_spec *spec = codec->spec;
14334         spec->autocfg.hp_pins[0] = 0x15;
14335         spec->autocfg.speaker_pins[0] = 0x14;
14336         spec->ext_mic.pin = 0x18;
14337         spec->ext_mic.mux_idx = 0;
14338         spec->int_mic.pin = 0x19;
14339         spec->int_mic.mux_idx = 1;
14340         spec->auto_mic = 1;
14341 }
14342
14343 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14344 {
14345         alc269_quanta_fl1_speaker_automute(codec);
14346         alc_mic_automute(codec);
14347 }
14348
14349 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14350 {
14351         alc269_lifebook_speaker_automute(codec);
14352         alc269_lifebook_mic_autoswitch(codec);
14353 }
14354
14355 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14356         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14357         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14358         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14359         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14360         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14361         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14362         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14363         {}
14364 };
14365
14366 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14367         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14368         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14369         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14370         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14371         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14372         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14373         {}
14374 };
14375
14376 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14377         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14378         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14379         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14380         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14381         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14382         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14383         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14384         {}
14385 };
14386
14387 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14388         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14389         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14390         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14391         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14392         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14393         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14394         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14395         {}
14396 };
14397
14398 static struct hda_verb alc271_acer_dmic_verbs[] = {
14399         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14400         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14401         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14402         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14403         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14404         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14405         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14406         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14407         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14408         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14409         { }
14410 };
14411
14412 /* toggle speaker-output according to the hp-jack state */
14413 static void alc269_speaker_automute(struct hda_codec *codec)
14414 {
14415         struct alc_spec *spec = codec->spec;
14416         unsigned int nid = spec->autocfg.hp_pins[0];
14417         unsigned int present;
14418         unsigned char bits;
14419
14420         present = snd_hda_jack_detect(codec, nid);
14421         bits = present ? HDA_AMP_MUTE : 0;
14422         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14423                                  HDA_AMP_MUTE, bits);
14424         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14425                                  HDA_AMP_MUTE, bits);
14426         alc_report_jack(codec, nid);
14427 }
14428
14429 /* unsolicited event for HP jack sensing */
14430 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14431                                      unsigned int res)
14432 {
14433         switch (res >> 26) {
14434         case ALC880_HP_EVENT:
14435                 alc269_speaker_automute(codec);
14436                 break;
14437         case ALC880_MIC_EVENT:
14438                 alc_mic_automute(codec);
14439                 break;
14440         }
14441 }
14442
14443 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14444 {
14445         struct alc_spec *spec = codec->spec;
14446         spec->autocfg.hp_pins[0] = 0x15;
14447         spec->autocfg.speaker_pins[0] = 0x14;
14448         spec->ext_mic.pin = 0x18;
14449         spec->ext_mic.mux_idx = 0;
14450         spec->int_mic.pin = 0x19;
14451         spec->int_mic.mux_idx = 1;
14452         spec->auto_mic = 1;
14453 }
14454
14455 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14456 {
14457         struct alc_spec *spec = codec->spec;
14458         spec->autocfg.hp_pins[0] = 0x15;
14459         spec->autocfg.speaker_pins[0] = 0x14;
14460         spec->ext_mic.pin = 0x18;
14461         spec->ext_mic.mux_idx = 0;
14462         spec->int_mic.pin = 0x12;
14463         spec->int_mic.mux_idx = 5;
14464         spec->auto_mic = 1;
14465 }
14466
14467 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14468 {
14469         struct alc_spec *spec = codec->spec;
14470         spec->autocfg.hp_pins[0] = 0x21;
14471         spec->autocfg.speaker_pins[0] = 0x14;
14472         spec->ext_mic.pin = 0x18;
14473         spec->ext_mic.mux_idx = 0;
14474         spec->int_mic.pin = 0x19;
14475         spec->int_mic.mux_idx = 1;
14476         spec->auto_mic = 1;
14477 }
14478
14479 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14480 {
14481         struct alc_spec *spec = codec->spec;
14482         spec->autocfg.hp_pins[0] = 0x21;
14483         spec->autocfg.speaker_pins[0] = 0x14;
14484         spec->ext_mic.pin = 0x18;
14485         spec->ext_mic.mux_idx = 0;
14486         spec->int_mic.pin = 0x12;
14487         spec->int_mic.mux_idx = 6;
14488         spec->auto_mic = 1;
14489 }
14490
14491 static void alc269_laptop_inithook(struct hda_codec *codec)
14492 {
14493         alc269_speaker_automute(codec);
14494         alc_mic_automute(codec);
14495 }
14496
14497 /*
14498  * generic initialization of ADC, input mixers and output mixers
14499  */
14500 static struct hda_verb alc269_init_verbs[] = {
14501         /*
14502          * Unmute ADC0 and set the default input to mic-in
14503          */
14504         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14505
14506         /*
14507          * Set up output mixers (0x02 - 0x03)
14508          */
14509         /* set vol=0 to output mixers */
14510         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14511         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14512
14513         /* set up input amps for analog loopback */
14514         /* Amp Indices: DAC = 0, mixer = 1 */
14515         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14516         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14517         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14518         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14519         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14520         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14521
14522         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14523         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14524         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14525         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14526         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14527         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14528         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14529
14530         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14531         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14532
14533         /* FIXME: use Mux-type input source selection */
14534         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14535         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14536         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14537
14538         /* set EAPD */
14539         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14540         { }
14541 };
14542
14543 static struct hda_verb alc269vb_init_verbs[] = {
14544         /*
14545          * Unmute ADC0 and set the default input to mic-in
14546          */
14547         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14548
14549         /*
14550          * Set up output mixers (0x02 - 0x03)
14551          */
14552         /* set vol=0 to output mixers */
14553         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14554         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14555
14556         /* set up input amps for analog loopback */
14557         /* Amp Indices: DAC = 0, mixer = 1 */
14558         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14559         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14560         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14561         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14562         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14563         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14564
14565         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14566         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14567         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14568         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14569         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14570         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14571         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14572
14573         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14574         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14575
14576         /* FIXME: use Mux-type input source selection */
14577         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14578         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14579         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14580
14581         /* set EAPD */
14582         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14583         { }
14584 };
14585
14586 #define alc269_auto_create_multi_out_ctls \
14587         alc268_auto_create_multi_out_ctls
14588 #define alc269_auto_create_input_ctls \
14589         alc268_auto_create_input_ctls
14590
14591 #ifdef CONFIG_SND_HDA_POWER_SAVE
14592 #define alc269_loopbacks        alc880_loopbacks
14593 #endif
14594
14595 /* pcm configuration: identical with ALC880 */
14596 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14597 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14598 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14599 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14600
14601 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14602         .substreams = 1,
14603         .channels_min = 2,
14604         .channels_max = 8,
14605         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14606         /* NID is set in alc_build_pcms */
14607         .ops = {
14608                 .open = alc880_playback_pcm_open,
14609                 .prepare = alc880_playback_pcm_prepare,
14610                 .cleanup = alc880_playback_pcm_cleanup
14611         },
14612 };
14613
14614 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14615         .substreams = 1,
14616         .channels_min = 2,
14617         .channels_max = 2,
14618         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14619         /* NID is set in alc_build_pcms */
14620 };
14621
14622 #ifdef CONFIG_SND_HDA_POWER_SAVE
14623 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14624 {
14625         switch (codec->subsystem_id) {
14626         case 0x103c1586:
14627                 return 1;
14628         }
14629         return 0;
14630 }
14631
14632 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14633 {
14634         /* update mute-LED according to the speaker mute state */
14635         if (nid == 0x01 || nid == 0x14) {
14636                 int pinval;
14637                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14638                     HDA_AMP_MUTE)
14639                         pinval = 0x24;
14640                 else
14641                         pinval = 0x20;
14642                 /* mic2 vref pin is used for mute LED control */
14643                 snd_hda_codec_update_cache(codec, 0x19, 0,
14644                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14645                                            pinval);
14646         }
14647         return alc_check_power_status(codec, nid);
14648 }
14649 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14650
14651 static int alc275_setup_dual_adc(struct hda_codec *codec)
14652 {
14653         struct alc_spec *spec = codec->spec;
14654
14655         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14656                 return 0;
14657         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14658             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14659                 if (spec->ext_mic.pin <= 0x12) {
14660                         spec->private_adc_nids[0] = 0x08;
14661                         spec->private_adc_nids[1] = 0x11;
14662                         spec->private_capsrc_nids[0] = 0x23;
14663                         spec->private_capsrc_nids[1] = 0x22;
14664                 } else {
14665                         spec->private_adc_nids[0] = 0x11;
14666                         spec->private_adc_nids[1] = 0x08;
14667                         spec->private_capsrc_nids[0] = 0x22;
14668                         spec->private_capsrc_nids[1] = 0x23;
14669                 }
14670                 spec->adc_nids = spec->private_adc_nids;
14671                 spec->capsrc_nids = spec->private_capsrc_nids;
14672                 spec->num_adc_nids = 2;
14673                 spec->dual_adc_switch = 1;
14674                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14675                             spec->adc_nids[0], spec->adc_nids[1]);
14676                 return 1;
14677         }
14678         return 0;
14679 }
14680
14681 /* different alc269-variants */
14682 enum {
14683         ALC269_TYPE_NORMAL,
14684         ALC269_TYPE_ALC258,
14685         ALC269_TYPE_ALC259,
14686         ALC269_TYPE_ALC269VB,
14687         ALC269_TYPE_ALC270,
14688         ALC269_TYPE_ALC271X,
14689 };
14690
14691 /*
14692  * BIOS auto configuration
14693  */
14694 static int alc269_parse_auto_config(struct hda_codec *codec)
14695 {
14696         struct alc_spec *spec = codec->spec;
14697         int err;
14698         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14699
14700         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14701                                            alc269_ignore);
14702         if (err < 0)
14703                 return err;
14704
14705         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14706         if (err < 0)
14707                 return err;
14708         if (spec->codec_variant == ALC269_TYPE_NORMAL)
14709                 err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14710         else
14711                 err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14712                                                  0x22, 0);
14713         if (err < 0)
14714                 return err;
14715
14716         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14717
14718         alc_auto_parse_digital(codec);
14719
14720         if (spec->kctls.list)
14721                 add_mixer(spec, spec->kctls.list);
14722
14723         if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14724                 add_verb(spec, alc269vb_init_verbs);
14725                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14726         } else {
14727                 add_verb(spec, alc269_init_verbs);
14728                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14729         }
14730
14731         spec->num_mux_defs = 1;
14732         spec->input_mux = &spec->private_imux[0];
14733
14734         if (!alc275_setup_dual_adc(codec))
14735                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14736                                      sizeof(alc269_adc_candidates));
14737
14738         /* set default input source */
14739         if (!spec->dual_adc_switch)
14740                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14741                                         spec->input_mux->items[0].index);
14742
14743         err = alc_auto_add_mic_boost(codec);
14744         if (err < 0)
14745                 return err;
14746
14747         if (!spec->cap_mixer && !spec->no_analog)
14748                 set_capture_mixer(codec);
14749
14750         return 1;
14751 }
14752
14753 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14754 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14755 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14756
14757
14758 /* init callback for auto-configuration model -- overriding the default init */
14759 static void alc269_auto_init(struct hda_codec *codec)
14760 {
14761         struct alc_spec *spec = codec->spec;
14762         alc269_auto_init_multi_out(codec);
14763         alc269_auto_init_hp_out(codec);
14764         alc269_auto_init_analog_input(codec);
14765         alc_auto_init_digital(codec);
14766         if (spec->unsol_event)
14767                 alc_inithook(codec);
14768 }
14769
14770 #ifdef SND_HDA_NEEDS_RESUME
14771 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14772 {
14773         int val = alc_read_coef_idx(codec, 0x04);
14774         if (power_up)
14775                 val |= 1 << 11;
14776         else
14777                 val &= ~(1 << 11);
14778         alc_write_coef_idx(codec, 0x04, val);
14779 }
14780
14781 #ifdef CONFIG_SND_HDA_POWER_SAVE
14782 static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14783 {
14784         struct alc_spec *spec = codec->spec;
14785
14786         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14787                 alc269_toggle_power_output(codec, 0);
14788         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14789                 alc269_toggle_power_output(codec, 0);
14790                 msleep(150);
14791         }
14792
14793         alc_shutup(codec);
14794         if (spec && spec->power_hook)
14795                 spec->power_hook(codec);
14796         return 0;
14797 }
14798 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14799
14800 static int alc269_resume(struct hda_codec *codec)
14801 {
14802         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14803                 alc269_toggle_power_output(codec, 0);
14804                 msleep(150);
14805         }
14806
14807         codec->patch_ops.init(codec);
14808
14809         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14810                 alc269_toggle_power_output(codec, 1);
14811                 msleep(200);
14812         }
14813
14814         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14815                 alc269_toggle_power_output(codec, 1);
14816
14817         snd_hda_codec_resume_amp(codec);
14818         snd_hda_codec_resume_cache(codec);
14819         hda_call_check_power_status(codec, 0x01);
14820         return 0;
14821 }
14822 #endif /* SND_HDA_NEEDS_RESUME */
14823
14824 static void alc269_fixup_hweq(struct hda_codec *codec,
14825                                const struct alc_fixup *fix, int pre_init)
14826 {
14827         int coef;
14828
14829         coef = alc_read_coef_idx(codec, 0x1e);
14830         alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14831 }
14832
14833 enum {
14834         ALC269_FIXUP_SONY_VAIO,
14835         ALC275_FIX_SONY_VAIO_GPIO2,
14836         ALC269_FIXUP_DELL_M101Z,
14837         ALC269_FIXUP_SKU_IGNORE,
14838         ALC269_FIXUP_ASUS_G73JW,
14839         ALC269_FIXUP_LENOVO_EAPD,
14840         ALC275_FIXUP_SONY_HWEQ,
14841 };
14842
14843 static const struct alc_fixup alc269_fixups[] = {
14844         [ALC269_FIXUP_SONY_VAIO] = {
14845                 .verbs = (const struct hda_verb[]) {
14846                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14847                         {}
14848                 }
14849         },
14850         [ALC275_FIX_SONY_VAIO_GPIO2] = {
14851                 .verbs = (const struct hda_verb[]) {
14852                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14853                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14854                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14855                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14856                         { }
14857                 }
14858         },
14859         [ALC269_FIXUP_DELL_M101Z] = {
14860                 .verbs = (const struct hda_verb[]) {
14861                         /* Enables internal speaker */
14862                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
14863                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14864                         {}
14865                 }
14866         },
14867         [ALC269_FIXUP_SKU_IGNORE] = {
14868                 .sku = ALC_FIXUP_SKU_IGNORE,
14869         },
14870         [ALC269_FIXUP_ASUS_G73JW] = {
14871                 .pins = (const struct alc_pincfg[]) {
14872                         { 0x17, 0x99130111 }, /* subwoofer */
14873                         { }
14874                 }
14875         },
14876         [ALC269_FIXUP_LENOVO_EAPD] = {
14877                 .verbs = (const struct hda_verb[]) {
14878                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14879                         {}
14880                 }
14881         },
14882         [ALC275_FIXUP_SONY_HWEQ] = {
14883                 .func = alc269_fixup_hweq,
14884                 .verbs = (const struct hda_verb[]) {
14885                         {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14886                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14887                         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14888                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14889                         { }
14890                 }
14891         }
14892 };
14893
14894 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14895         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIX_SONY_VAIO_GPIO2),
14896         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14897         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14898         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14899         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14900         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14901         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14902         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14903         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14904         {}
14905 };
14906
14907
14908 /*
14909  * configuration and preset
14910  */
14911 static const char *alc269_models[ALC269_MODEL_LAST] = {
14912         [ALC269_BASIC]                  = "basic",
14913         [ALC269_QUANTA_FL1]             = "quanta",
14914         [ALC269_AMIC]                   = "laptop-amic",
14915         [ALC269_DMIC]                   = "laptop-dmic",
14916         [ALC269_FUJITSU]                = "fujitsu",
14917         [ALC269_LIFEBOOK]               = "lifebook",
14918         [ALC269_AUTO]                   = "auto",
14919 };
14920
14921 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14922         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14923         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14924         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14925                       ALC269_AMIC),
14926         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14927         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14928         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14929         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14930         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14931         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14932         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14933         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14934         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14935         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14936         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14937         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14938         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14939         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14940         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14941         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14942         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14943         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14944         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14945         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14946         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14947         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14948         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14949         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14950         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14951         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14952         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14953         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14954         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14955         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14956         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14957         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14958         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14959         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14960         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14961         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14962         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14963                       ALC269_DMIC),
14964         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14965                       ALC269_DMIC),
14966         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14967         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14968         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14969         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14970         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14971         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14972         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14973         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14974         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14975         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14976         {}
14977 };
14978
14979 static struct alc_config_preset alc269_presets[] = {
14980         [ALC269_BASIC] = {
14981                 .mixers = { alc269_base_mixer },
14982                 .init_verbs = { alc269_init_verbs },
14983                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14984                 .dac_nids = alc269_dac_nids,
14985                 .hp_nid = 0x03,
14986                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14987                 .channel_mode = alc269_modes,
14988                 .input_mux = &alc269_capture_source,
14989         },
14990         [ALC269_QUANTA_FL1] = {
14991                 .mixers = { alc269_quanta_fl1_mixer },
14992                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14993                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14994                 .dac_nids = alc269_dac_nids,
14995                 .hp_nid = 0x03,
14996                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14997                 .channel_mode = alc269_modes,
14998                 .input_mux = &alc269_capture_source,
14999                 .unsol_event = alc269_quanta_fl1_unsol_event,
15000                 .setup = alc269_quanta_fl1_setup,
15001                 .init_hook = alc269_quanta_fl1_init_hook,
15002         },
15003         [ALC269_AMIC] = {
15004                 .mixers = { alc269_laptop_mixer },
15005                 .cap_mixer = alc269_laptop_analog_capture_mixer,
15006                 .init_verbs = { alc269_init_verbs,
15007                                 alc269_laptop_amic_init_verbs },
15008                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15009                 .dac_nids = alc269_dac_nids,
15010                 .hp_nid = 0x03,
15011                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15012                 .channel_mode = alc269_modes,
15013                 .unsol_event = alc269_laptop_unsol_event,
15014                 .setup = alc269_laptop_amic_setup,
15015                 .init_hook = alc269_laptop_inithook,
15016         },
15017         [ALC269_DMIC] = {
15018                 .mixers = { alc269_laptop_mixer },
15019                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15020                 .init_verbs = { alc269_init_verbs,
15021                                 alc269_laptop_dmic_init_verbs },
15022                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15023                 .dac_nids = alc269_dac_nids,
15024                 .hp_nid = 0x03,
15025                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15026                 .channel_mode = alc269_modes,
15027                 .unsol_event = alc269_laptop_unsol_event,
15028                 .setup = alc269_laptop_dmic_setup,
15029                 .init_hook = alc269_laptop_inithook,
15030         },
15031         [ALC269VB_AMIC] = {
15032                 .mixers = { alc269vb_laptop_mixer },
15033                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
15034                 .init_verbs = { alc269vb_init_verbs,
15035                                 alc269vb_laptop_amic_init_verbs },
15036                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15037                 .dac_nids = alc269_dac_nids,
15038                 .hp_nid = 0x03,
15039                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15040                 .channel_mode = alc269_modes,
15041                 .unsol_event = alc269_laptop_unsol_event,
15042                 .setup = alc269vb_laptop_amic_setup,
15043                 .init_hook = alc269_laptop_inithook,
15044         },
15045         [ALC269VB_DMIC] = {
15046                 .mixers = { alc269vb_laptop_mixer },
15047                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15048                 .init_verbs = { alc269vb_init_verbs,
15049                                 alc269vb_laptop_dmic_init_verbs },
15050                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15051                 .dac_nids = alc269_dac_nids,
15052                 .hp_nid = 0x03,
15053                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15054                 .channel_mode = alc269_modes,
15055                 .unsol_event = alc269_laptop_unsol_event,
15056                 .setup = alc269vb_laptop_dmic_setup,
15057                 .init_hook = alc269_laptop_inithook,
15058         },
15059         [ALC269_FUJITSU] = {
15060                 .mixers = { alc269_fujitsu_mixer },
15061                 .cap_mixer = alc269_laptop_digital_capture_mixer,
15062                 .init_verbs = { alc269_init_verbs,
15063                                 alc269_laptop_dmic_init_verbs },
15064                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15065                 .dac_nids = alc269_dac_nids,
15066                 .hp_nid = 0x03,
15067                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15068                 .channel_mode = alc269_modes,
15069                 .unsol_event = alc269_laptop_unsol_event,
15070                 .setup = alc269_laptop_dmic_setup,
15071                 .init_hook = alc269_laptop_inithook,
15072         },
15073         [ALC269_LIFEBOOK] = {
15074                 .mixers = { alc269_lifebook_mixer },
15075                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15076                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15077                 .dac_nids = alc269_dac_nids,
15078                 .hp_nid = 0x03,
15079                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15080                 .channel_mode = alc269_modes,
15081                 .input_mux = &alc269_capture_source,
15082                 .unsol_event = alc269_lifebook_unsol_event,
15083                 .init_hook = alc269_lifebook_init_hook,
15084         },
15085         [ALC271_ACER] = {
15086                 .mixers = { alc269_asus_mixer },
15087                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
15088                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15089                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
15090                 .dac_nids = alc269_dac_nids,
15091                 .adc_nids = alc262_dmic_adc_nids,
15092                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15093                 .capsrc_nids = alc262_dmic_capsrc_nids,
15094                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
15095                 .channel_mode = alc269_modes,
15096                 .input_mux = &alc269_capture_source,
15097                 .dig_out_nid = ALC880_DIGOUT_NID,
15098                 .unsol_event = alc_sku_unsol_event,
15099                 .setup = alc269vb_laptop_dmic_setup,
15100                 .init_hook = alc_inithook,
15101         },
15102 };
15103
15104 static int alc269_fill_coef(struct hda_codec *codec)
15105 {
15106         int val;
15107
15108         if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15109                 alc_write_coef_idx(codec, 0xf, 0x960b);
15110                 alc_write_coef_idx(codec, 0xe, 0x8817);
15111         }
15112
15113         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15114                 alc_write_coef_idx(codec, 0xf, 0x960b);
15115                 alc_write_coef_idx(codec, 0xe, 0x8814);
15116         }
15117
15118         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15119                 val = alc_read_coef_idx(codec, 0x04);
15120                 /* Power up output pin */
15121                 alc_write_coef_idx(codec, 0x04, val | (1<<11));
15122         }
15123
15124         if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15125                 val = alc_read_coef_idx(codec, 0xd);
15126                 if ((val & 0x0c00) >> 10 != 0x1) {
15127                         /* Capless ramp up clock control */
15128                         alc_write_coef_idx(codec, 0xd, val | 1<<10);
15129                 }
15130                 val = alc_read_coef_idx(codec, 0x17);
15131                 if ((val & 0x01c0) >> 6 != 0x4) {
15132                         /* Class D power on reset */
15133                         alc_write_coef_idx(codec, 0x17, val | 1<<7);
15134                 }
15135         }
15136         return 0;
15137 }
15138
15139 static int patch_alc269(struct hda_codec *codec)
15140 {
15141         struct alc_spec *spec;
15142         int board_config, coef;
15143         int err;
15144
15145         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15146         if (spec == NULL)
15147                 return -ENOMEM;
15148
15149         codec->spec = spec;
15150
15151         alc_auto_parse_customize_define(codec);
15152
15153         if (codec->vendor_id == 0x10ec0269) {
15154                 coef = alc_read_coef_idx(codec, 0);
15155                 if ((coef & 0x00f0) == 0x0010) {
15156                         if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15157                             spec->cdefine.platform_type == 1) {
15158                                 alc_codec_rename(codec, "ALC271X");
15159                                 spec->codec_variant = ALC269_TYPE_ALC271X;
15160                         } else if ((coef & 0xf000) == 0x1000) {
15161                                 spec->codec_variant = ALC269_TYPE_ALC270;
15162                         } else if ((coef & 0xf000) == 0x2000) {
15163                                 alc_codec_rename(codec, "ALC259");
15164                                 spec->codec_variant = ALC269_TYPE_ALC259;
15165                         } else if ((coef & 0xf000) == 0x3000) {
15166                                 alc_codec_rename(codec, "ALC258");
15167                                 spec->codec_variant = ALC269_TYPE_ALC258;
15168                         } else {
15169                                 alc_codec_rename(codec, "ALC269VB");
15170                                 spec->codec_variant = ALC269_TYPE_ALC269VB;
15171                         }
15172                 } else
15173                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
15174                 alc269_fill_coef(codec);
15175         }
15176
15177         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15178                                                   alc269_models,
15179                                                   alc269_cfg_tbl);
15180
15181         if (board_config < 0) {
15182                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15183                        codec->chip_name);
15184                 board_config = ALC269_AUTO;
15185         }
15186
15187         if (board_config == ALC269_AUTO)
15188                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
15189
15190         if (board_config == ALC269_AUTO) {
15191                 /* automatic parse from the BIOS config */
15192                 err = alc269_parse_auto_config(codec);
15193                 if (err < 0) {
15194                         alc_free(codec);
15195                         return err;
15196                 } else if (!err) {
15197                         printk(KERN_INFO
15198                                "hda_codec: Cannot set up configuration "
15199                                "from BIOS.  Using base mode...\n");
15200                         board_config = ALC269_BASIC;
15201                 }
15202         }
15203
15204         if (has_cdefine_beep(codec)) {
15205                 err = snd_hda_attach_beep_device(codec, 0x1);
15206                 if (err < 0) {
15207                         alc_free(codec);
15208                         return err;
15209                 }
15210         }
15211
15212         if (board_config != ALC269_AUTO)
15213                 setup_preset(codec, &alc269_presets[board_config]);
15214
15215         if (board_config == ALC269_QUANTA_FL1) {
15216                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
15217                  * fix the sample rate of analog I/O to 44.1kHz
15218                  */
15219                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15220                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15221         } else if (spec->dual_adc_switch) {
15222                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15223                 /* switch ADC dynamically */
15224                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15225         } else {
15226                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
15227                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
15228         }
15229         spec->stream_digital_playback = &alc269_pcm_digital_playback;
15230         spec->stream_digital_capture = &alc269_pcm_digital_capture;
15231
15232         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15233                 if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15234                         spec->adc_nids = alc269_adc_nids;
15235                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15236                         spec->capsrc_nids = alc269_capsrc_nids;
15237                 } else {
15238                         spec->adc_nids = alc269vb_adc_nids;
15239                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15240                         spec->capsrc_nids = alc269vb_capsrc_nids;
15241                 }
15242         }
15243
15244         if (!spec->cap_mixer)
15245                 set_capture_mixer(codec);
15246         if (has_cdefine_beep(codec))
15247                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15248
15249         if (board_config == ALC269_AUTO)
15250                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
15251
15252         spec->vmaster_nid = 0x02;
15253
15254         codec->patch_ops = alc_patch_ops;
15255 #ifdef CONFIG_SND_HDA_POWER_SAVE
15256         codec->patch_ops.suspend = alc269_suspend;
15257 #endif
15258 #ifdef SND_HDA_NEEDS_RESUME
15259         codec->patch_ops.resume = alc269_resume;
15260 #endif
15261         if (board_config == ALC269_AUTO)
15262                 spec->init_hook = alc269_auto_init;
15263
15264         alc_init_jacks(codec);
15265 #ifdef CONFIG_SND_HDA_POWER_SAVE
15266         if (!spec->loopback.amplist)
15267                 spec->loopback.amplist = alc269_loopbacks;
15268         if (alc269_mic2_for_mute_led(codec))
15269                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15270 #endif
15271
15272         return 0;
15273 }
15274
15275 /*
15276  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15277  */
15278
15279 /*
15280  * set the path ways for 2 channel output
15281  * need to set the codec line out and mic 1 pin widgets to inputs
15282  */
15283 static struct hda_verb alc861_threestack_ch2_init[] = {
15284         /* set pin widget 1Ah (line in) for input */
15285         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15286         /* set pin widget 18h (mic1/2) for input, for mic also enable
15287          * the vref
15288          */
15289         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15290
15291         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15292 #if 0
15293         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15294         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15295 #endif
15296         { } /* end */
15297 };
15298 /*
15299  * 6ch mode
15300  * need to set the codec line out and mic 1 pin widgets to outputs
15301  */
15302 static struct hda_verb alc861_threestack_ch6_init[] = {
15303         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15304         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15305         /* set pin widget 18h (mic1) for output (CLFE)*/
15306         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15307
15308         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15309         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15310
15311         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15312 #if 0
15313         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15314         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15315 #endif
15316         { } /* end */
15317 };
15318
15319 static struct hda_channel_mode alc861_threestack_modes[2] = {
15320         { 2, alc861_threestack_ch2_init },
15321         { 6, alc861_threestack_ch6_init },
15322 };
15323 /* Set mic1 as input and unmute the mixer */
15324 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15325         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15326         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15327         { } /* end */
15328 };
15329 /* Set mic1 as output and mute mixer */
15330 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15331         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15332         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15333         { } /* end */
15334 };
15335
15336 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15337         { 2, alc861_uniwill_m31_ch2_init },
15338         { 4, alc861_uniwill_m31_ch4_init },
15339 };
15340
15341 /* Set mic1 and line-in as input and unmute the mixer */
15342 static struct hda_verb alc861_asus_ch2_init[] = {
15343         /* set pin widget 1Ah (line in) for input */
15344         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15345         /* set pin widget 18h (mic1/2) for input, for mic also enable
15346          * the vref
15347          */
15348         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15349
15350         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15351 #if 0
15352         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15353         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15354 #endif
15355         { } /* end */
15356 };
15357 /* Set mic1 nad line-in as output and mute mixer */
15358 static struct hda_verb alc861_asus_ch6_init[] = {
15359         /* set pin widget 1Ah (line in) for output (Back Surround)*/
15360         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15361         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15362         /* set pin widget 18h (mic1) for output (CLFE)*/
15363         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15364         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15365         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15366         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15367
15368         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15369 #if 0
15370         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15371         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15372 #endif
15373         { } /* end */
15374 };
15375
15376 static struct hda_channel_mode alc861_asus_modes[2] = {
15377         { 2, alc861_asus_ch2_init },
15378         { 6, alc861_asus_ch6_init },
15379 };
15380
15381 /* patch-ALC861 */
15382
15383 static struct snd_kcontrol_new alc861_base_mixer[] = {
15384         /* output mixer control */
15385         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15386         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15387         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15388         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15389         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15390
15391         /*Input mixer control */
15392         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15393            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15394         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15395         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15396         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15397         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15399         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15400         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15401         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15402
15403         { } /* end */
15404 };
15405
15406 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15407         /* output mixer control */
15408         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15409         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15410         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15411         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15412         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15413
15414         /* Input mixer control */
15415         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15416            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15417         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15418         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15419         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15420         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15421         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15422         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15423         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15424         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15425
15426         {
15427                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15428                 .name = "Channel Mode",
15429                 .info = alc_ch_mode_info,
15430                 .get = alc_ch_mode_get,
15431                 .put = alc_ch_mode_put,
15432                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
15433         },
15434         { } /* end */
15435 };
15436
15437 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15438         /* output mixer control */
15439         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15440         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15441         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15442
15443         { } /* end */
15444 };
15445
15446 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15447         /* output mixer control */
15448         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15449         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15450         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15451         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15452         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15453
15454         /* Input mixer control */
15455         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15456            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15457         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15458         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15459         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15460         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15461         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15462         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15463         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15464         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15465
15466         {
15467                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15468                 .name = "Channel Mode",
15469                 .info = alc_ch_mode_info,
15470                 .get = alc_ch_mode_get,
15471                 .put = alc_ch_mode_put,
15472                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15473         },
15474         { } /* end */
15475 };
15476
15477 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15478         /* output mixer control */
15479         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15480         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15481         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15482         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15483         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15484
15485         /* Input mixer control */
15486         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15487         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15488         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15489         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15490         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15491         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15492         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15493         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15494         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15495         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15496
15497         {
15498                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15499                 .name = "Channel Mode",
15500                 .info = alc_ch_mode_info,
15501                 .get = alc_ch_mode_get,
15502                 .put = alc_ch_mode_put,
15503                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15504         },
15505         { }
15506 };
15507
15508 /* additional mixer */
15509 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15510         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15511         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15512         { }
15513 };
15514
15515 /*
15516  * generic initialization of ADC, input mixers and output mixers
15517  */
15518 static struct hda_verb alc861_base_init_verbs[] = {
15519         /*
15520          * Unmute ADC0 and set the default input to mic-in
15521          */
15522         /* port-A for surround (rear panel) */
15523         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15524         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15525         /* port-B for mic-in (rear panel) with vref */
15526         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15527         /* port-C for line-in (rear panel) */
15528         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15529         /* port-D for Front */
15530         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15531         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15532         /* port-E for HP out (front panel) */
15533         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15534         /* route front PCM to HP */
15535         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15536         /* port-F for mic-in (front panel) with vref */
15537         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15538         /* port-G for CLFE (rear panel) */
15539         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15540         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15541         /* port-H for side (rear panel) */
15542         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15543         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15544         /* CD-in */
15545         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15546         /* route front mic to ADC1*/
15547         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15548         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15549
15550         /* Unmute DAC0~3 & spdif out*/
15551         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15552         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15553         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15554         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15555         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15556
15557         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15558         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15559         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15560         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15561         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15562
15563         /* Unmute Stereo Mixer 15 */
15564         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15565         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15566         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15567         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15568
15569         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15570         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15571         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15572         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15573         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15574         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15575         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15576         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15577         /* hp used DAC 3 (Front) */
15578         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15579         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15580
15581         { }
15582 };
15583
15584 static struct hda_verb alc861_threestack_init_verbs[] = {
15585         /*
15586          * Unmute ADC0 and set the default input to mic-in
15587          */
15588         /* port-A for surround (rear panel) */
15589         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15590         /* port-B for mic-in (rear panel) with vref */
15591         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15592         /* port-C for line-in (rear panel) */
15593         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15594         /* port-D for Front */
15595         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15596         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15597         /* port-E for HP out (front panel) */
15598         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15599         /* route front PCM to HP */
15600         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15601         /* port-F for mic-in (front panel) with vref */
15602         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15603         /* port-G for CLFE (rear panel) */
15604         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15605         /* port-H for side (rear panel) */
15606         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15607         /* CD-in */
15608         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15609         /* route front mic to ADC1*/
15610         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15611         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15612         /* Unmute DAC0~3 & spdif out*/
15613         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15614         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15615         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15616         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15617         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15618
15619         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15620         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15621         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15622         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15623         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15624
15625         /* Unmute Stereo Mixer 15 */
15626         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15627         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15628         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15629         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15630
15631         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15632         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15633         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15634         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15635         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15636         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15637         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15638         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15639         /* hp used DAC 3 (Front) */
15640         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15641         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15642         { }
15643 };
15644
15645 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15646         /*
15647          * Unmute ADC0 and set the default input to mic-in
15648          */
15649         /* port-A for surround (rear panel) */
15650         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15651         /* port-B for mic-in (rear panel) with vref */
15652         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15653         /* port-C for line-in (rear panel) */
15654         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15655         /* port-D for Front */
15656         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15657         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15658         /* port-E for HP out (front panel) */
15659         /* this has to be set to VREF80 */
15660         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15661         /* route front PCM to HP */
15662         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15663         /* port-F for mic-in (front panel) with vref */
15664         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15665         /* port-G for CLFE (rear panel) */
15666         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15667         /* port-H for side (rear panel) */
15668         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15669         /* CD-in */
15670         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15671         /* route front mic to ADC1*/
15672         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15673         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15674         /* Unmute DAC0~3 & spdif out*/
15675         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15676         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15677         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15678         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15679         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15680
15681         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15682         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15683         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15684         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15685         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15686
15687         /* Unmute Stereo Mixer 15 */
15688         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15689         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15690         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15691         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15692
15693         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15694         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15695         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15696         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15697         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15698         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15699         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15700         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15701         /* hp used DAC 3 (Front) */
15702         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15703         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15704         { }
15705 };
15706
15707 static struct hda_verb alc861_asus_init_verbs[] = {
15708         /*
15709          * Unmute ADC0 and set the default input to mic-in
15710          */
15711         /* port-A for surround (rear panel)
15712          * according to codec#0 this is the HP jack
15713          */
15714         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15715         /* route front PCM to HP */
15716         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15717         /* port-B for mic-in (rear panel) with vref */
15718         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15719         /* port-C for line-in (rear panel) */
15720         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15721         /* port-D for Front */
15722         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15723         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15724         /* port-E for HP out (front panel) */
15725         /* this has to be set to VREF80 */
15726         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15727         /* route front PCM to HP */
15728         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15729         /* port-F for mic-in (front panel) with vref */
15730         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15731         /* port-G for CLFE (rear panel) */
15732         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15733         /* port-H for side (rear panel) */
15734         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15735         /* CD-in */
15736         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15737         /* route front mic to ADC1*/
15738         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15739         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15740         /* Unmute DAC0~3 & spdif out*/
15741         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15742         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15743         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15744         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15745         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15746         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15747         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15748         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15749         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15750         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15751
15752         /* Unmute Stereo Mixer 15 */
15753         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15754         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15755         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15756         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15757
15758         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15759         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15760         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15761         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15762         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15763         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15764         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15765         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15766         /* hp used DAC 3 (Front) */
15767         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15768         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15769         { }
15770 };
15771
15772 /* additional init verbs for ASUS laptops */
15773 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15774         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15775         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15776         { }
15777 };
15778
15779 /*
15780  * generic initialization of ADC, input mixers and output mixers
15781  */
15782 static struct hda_verb alc861_auto_init_verbs[] = {
15783         /*
15784          * Unmute ADC0 and set the default input to mic-in
15785          */
15786         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15787         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15788
15789         /* Unmute DAC0~3 & spdif out*/
15790         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15791         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15792         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15793         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15794         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15795
15796         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15797         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15798         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15799         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15800         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15801
15802         /* Unmute Stereo Mixer 15 */
15803         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15804         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15805         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15806         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15807
15808         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15809         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15810         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15811         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15812         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15813         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15814         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15815         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15816
15817         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15818         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15819         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15820         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15821         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15822         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15823         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15824         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15825
15826         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15827
15828         { }
15829 };
15830
15831 static struct hda_verb alc861_toshiba_init_verbs[] = {
15832         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15833
15834         { }
15835 };
15836
15837 /* toggle speaker-output according to the hp-jack state */
15838 static void alc861_toshiba_automute(struct hda_codec *codec)
15839 {
15840         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15841
15842         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15843                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15844         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15845                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15846 }
15847
15848 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15849                                        unsigned int res)
15850 {
15851         if ((res >> 26) == ALC880_HP_EVENT)
15852                 alc861_toshiba_automute(codec);
15853 }
15854
15855 /* pcm configuration: identical with ALC880 */
15856 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15857 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15858 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15859 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15860
15861
15862 #define ALC861_DIGOUT_NID       0x07
15863
15864 static struct hda_channel_mode alc861_8ch_modes[1] = {
15865         { 8, NULL }
15866 };
15867
15868 static hda_nid_t alc861_dac_nids[4] = {
15869         /* front, surround, clfe, side */
15870         0x03, 0x06, 0x05, 0x04
15871 };
15872
15873 static hda_nid_t alc660_dac_nids[3] = {
15874         /* front, clfe, surround */
15875         0x03, 0x05, 0x06
15876 };
15877
15878 static hda_nid_t alc861_adc_nids[1] = {
15879         /* ADC0-2 */
15880         0x08,
15881 };
15882
15883 static struct hda_input_mux alc861_capture_source = {
15884         .num_items = 5,
15885         .items = {
15886                 { "Mic", 0x0 },
15887                 { "Front Mic", 0x3 },
15888                 { "Line", 0x1 },
15889                 { "CD", 0x4 },
15890                 { "Mixer", 0x5 },
15891         },
15892 };
15893
15894 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15895 {
15896         struct alc_spec *spec = codec->spec;
15897         hda_nid_t mix, srcs[5];
15898         int i, j, num;
15899
15900         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15901                 return 0;
15902         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15903         if (num < 0)
15904                 return 0;
15905         for (i = 0; i < num; i++) {
15906                 unsigned int type;
15907                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15908                 if (type != AC_WID_AUD_OUT)
15909                         continue;
15910                 for (j = 0; j < spec->multiout.num_dacs; j++)
15911                         if (spec->multiout.dac_nids[j] == srcs[i])
15912                                 break;
15913                 if (j >= spec->multiout.num_dacs)
15914                         return srcs[i];
15915         }
15916         return 0;
15917 }
15918
15919 /* fill in the dac_nids table from the parsed pin configuration */
15920 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15921                                      const struct auto_pin_cfg *cfg)
15922 {
15923         struct alc_spec *spec = codec->spec;
15924         int i;
15925         hda_nid_t nid, dac;
15926
15927         spec->multiout.dac_nids = spec->private_dac_nids;
15928         for (i = 0; i < cfg->line_outs; i++) {
15929                 nid = cfg->line_out_pins[i];
15930                 dac = alc861_look_for_dac(codec, nid);
15931                 if (!dac)
15932                         continue;
15933                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15934         }
15935         return 0;
15936 }
15937
15938 static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15939                                   hda_nid_t nid, int idx, unsigned int chs)
15940 {
15941         return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
15942                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15943 }
15944
15945 #define alc861_create_out_sw(codec, pfx, nid, chs) \
15946         __alc861_create_out_sw(codec, pfx, nid, 0, chs)
15947
15948 /* add playback controls from the parsed DAC table */
15949 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15950                                              const struct auto_pin_cfg *cfg)
15951 {
15952         struct alc_spec *spec = codec->spec;
15953         static const char *chname[4] = {
15954                 "Front", "Surround", NULL /*CLFE*/, "Side"
15955         };
15956         const char *pfx = alc_get_line_out_pfx(cfg, true);
15957         hda_nid_t nid;
15958         int i, err;
15959
15960         for (i = 0; i < cfg->line_outs; i++) {
15961                 nid = spec->multiout.dac_nids[i];
15962                 if (!nid)
15963                         continue;
15964                 if (!pfx && i == 2) {
15965                         /* Center/LFE */
15966                         err = alc861_create_out_sw(codec, "Center", nid, 1);
15967                         if (err < 0)
15968                                 return err;
15969                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
15970                         if (err < 0)
15971                                 return err;
15972                 } else {
15973                         const char *name = pfx;
15974                         if (!name)
15975                                 name = chname[i];
15976                         err = __alc861_create_out_sw(codec, name, nid, i, 3);
15977                         if (err < 0)
15978                                 return err;
15979                 }
15980         }
15981         return 0;
15982 }
15983
15984 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15985 {
15986         struct alc_spec *spec = codec->spec;
15987         int err;
15988         hda_nid_t nid;
15989
15990         if (!pin)
15991                 return 0;
15992
15993         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15994                 nid = alc861_look_for_dac(codec, pin);
15995                 if (nid) {
15996                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15997                         if (err < 0)
15998                                 return err;
15999                         spec->multiout.hp_nid = nid;
16000                 }
16001         }
16002         return 0;
16003 }
16004
16005 /* create playback/capture controls for input pins */
16006 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
16007                                                 const struct auto_pin_cfg *cfg)
16008 {
16009         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
16010 }
16011
16012 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
16013                                               hda_nid_t nid,
16014                                               int pin_type, hda_nid_t dac)
16015 {
16016         hda_nid_t mix, srcs[5];
16017         int i, num;
16018
16019         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
16020                             pin_type);
16021         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16022                             AMP_OUT_UNMUTE);
16023         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
16024                 return;
16025         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
16026         if (num < 0)
16027                 return;
16028         for (i = 0; i < num; i++) {
16029                 unsigned int mute;
16030                 if (srcs[i] == dac || srcs[i] == 0x15)
16031                         mute = AMP_IN_UNMUTE(i);
16032                 else
16033                         mute = AMP_IN_MUTE(i);
16034                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16035                                     mute);
16036         }
16037 }
16038
16039 static void alc861_auto_init_multi_out(struct hda_codec *codec)
16040 {
16041         struct alc_spec *spec = codec->spec;
16042         int i;
16043
16044         for (i = 0; i < spec->autocfg.line_outs; i++) {
16045                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16046                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16047                 if (nid)
16048                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16049                                                           spec->multiout.dac_nids[i]);
16050         }
16051 }
16052
16053 static void alc861_auto_init_hp_out(struct hda_codec *codec)
16054 {
16055         struct alc_spec *spec = codec->spec;
16056
16057         if (spec->autocfg.hp_outs)
16058                 alc861_auto_set_output_and_unmute(codec,
16059                                                   spec->autocfg.hp_pins[0],
16060                                                   PIN_HP,
16061                                                   spec->multiout.hp_nid);
16062         if (spec->autocfg.speaker_outs)
16063                 alc861_auto_set_output_and_unmute(codec,
16064                                                   spec->autocfg.speaker_pins[0],
16065                                                   PIN_OUT,
16066                                                   spec->multiout.dac_nids[0]);
16067 }
16068
16069 static void alc861_auto_init_analog_input(struct hda_codec *codec)
16070 {
16071         struct alc_spec *spec = codec->spec;
16072         struct auto_pin_cfg *cfg = &spec->autocfg;
16073         int i;
16074
16075         for (i = 0; i < cfg->num_inputs; i++) {
16076                 hda_nid_t nid = cfg->inputs[i].pin;
16077                 if (nid >= 0x0c && nid <= 0x11)
16078                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16079         }
16080 }
16081
16082 /* parse the BIOS configuration and set up the alc_spec */
16083 /* return 1 if successful, 0 if the proper config is not found,
16084  * or a negative error code
16085  */
16086 static int alc861_parse_auto_config(struct hda_codec *codec)
16087 {
16088         struct alc_spec *spec = codec->spec;
16089         int err;
16090         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16091
16092         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16093                                            alc861_ignore);
16094         if (err < 0)
16095                 return err;
16096         if (!spec->autocfg.line_outs)
16097                 return 0; /* can't find valid BIOS pin config */
16098
16099         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16100         if (err < 0)
16101                 return err;
16102         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16103         if (err < 0)
16104                 return err;
16105         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16106         if (err < 0)
16107                 return err;
16108         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16109         if (err < 0)
16110                 return err;
16111
16112         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16113
16114         alc_auto_parse_digital(codec);
16115
16116         if (spec->kctls.list)
16117                 add_mixer(spec, spec->kctls.list);
16118
16119         add_verb(spec, alc861_auto_init_verbs);
16120
16121         spec->num_mux_defs = 1;
16122         spec->input_mux = &spec->private_imux[0];
16123
16124         spec->adc_nids = alc861_adc_nids;
16125         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16126         set_capture_mixer(codec);
16127
16128         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16129
16130         return 1;
16131 }
16132
16133 /* additional initialization for auto-configuration model */
16134 static void alc861_auto_init(struct hda_codec *codec)
16135 {
16136         struct alc_spec *spec = codec->spec;
16137         alc861_auto_init_multi_out(codec);
16138         alc861_auto_init_hp_out(codec);
16139         alc861_auto_init_analog_input(codec);
16140         alc_auto_init_digital(codec);
16141         if (spec->unsol_event)
16142                 alc_inithook(codec);
16143 }
16144
16145 #ifdef CONFIG_SND_HDA_POWER_SAVE
16146 static struct hda_amp_list alc861_loopbacks[] = {
16147         { 0x15, HDA_INPUT, 0 },
16148         { 0x15, HDA_INPUT, 1 },
16149         { 0x15, HDA_INPUT, 2 },
16150         { 0x15, HDA_INPUT, 3 },
16151         { } /* end */
16152 };
16153 #endif
16154
16155
16156 /*
16157  * configuration and preset
16158  */
16159 static const char *alc861_models[ALC861_MODEL_LAST] = {
16160         [ALC861_3ST]            = "3stack",
16161         [ALC660_3ST]            = "3stack-660",
16162         [ALC861_3ST_DIG]        = "3stack-dig",
16163         [ALC861_6ST_DIG]        = "6stack-dig",
16164         [ALC861_UNIWILL_M31]    = "uniwill-m31",
16165         [ALC861_TOSHIBA]        = "toshiba",
16166         [ALC861_ASUS]           = "asus",
16167         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
16168         [ALC861_AUTO]           = "auto",
16169 };
16170
16171 static struct snd_pci_quirk alc861_cfg_tbl[] = {
16172         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16173         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16174         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16175         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16176         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16177         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16178         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16179         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16180          *        Any other models that need this preset?
16181          */
16182         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16183         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16184         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16185         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16186         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16187         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16188         /* FIXME: the below seems conflict */
16189         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16190         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16191         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16192         {}
16193 };
16194
16195 static struct alc_config_preset alc861_presets[] = {
16196         [ALC861_3ST] = {
16197                 .mixers = { alc861_3ST_mixer },
16198                 .init_verbs = { alc861_threestack_init_verbs },
16199                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16200                 .dac_nids = alc861_dac_nids,
16201                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16202                 .channel_mode = alc861_threestack_modes,
16203                 .need_dac_fix = 1,
16204                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16205                 .adc_nids = alc861_adc_nids,
16206                 .input_mux = &alc861_capture_source,
16207         },
16208         [ALC861_3ST_DIG] = {
16209                 .mixers = { alc861_base_mixer },
16210                 .init_verbs = { alc861_threestack_init_verbs },
16211                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16212                 .dac_nids = alc861_dac_nids,
16213                 .dig_out_nid = ALC861_DIGOUT_NID,
16214                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16215                 .channel_mode = alc861_threestack_modes,
16216                 .need_dac_fix = 1,
16217                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16218                 .adc_nids = alc861_adc_nids,
16219                 .input_mux = &alc861_capture_source,
16220         },
16221         [ALC861_6ST_DIG] = {
16222                 .mixers = { alc861_base_mixer },
16223                 .init_verbs = { alc861_base_init_verbs },
16224                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16225                 .dac_nids = alc861_dac_nids,
16226                 .dig_out_nid = ALC861_DIGOUT_NID,
16227                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16228                 .channel_mode = alc861_8ch_modes,
16229                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16230                 .adc_nids = alc861_adc_nids,
16231                 .input_mux = &alc861_capture_source,
16232         },
16233         [ALC660_3ST] = {
16234                 .mixers = { alc861_3ST_mixer },
16235                 .init_verbs = { alc861_threestack_init_verbs },
16236                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
16237                 .dac_nids = alc660_dac_nids,
16238                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16239                 .channel_mode = alc861_threestack_modes,
16240                 .need_dac_fix = 1,
16241                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16242                 .adc_nids = alc861_adc_nids,
16243                 .input_mux = &alc861_capture_source,
16244         },
16245         [ALC861_UNIWILL_M31] = {
16246                 .mixers = { alc861_uniwill_m31_mixer },
16247                 .init_verbs = { alc861_uniwill_m31_init_verbs },
16248                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16249                 .dac_nids = alc861_dac_nids,
16250                 .dig_out_nid = ALC861_DIGOUT_NID,
16251                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16252                 .channel_mode = alc861_uniwill_m31_modes,
16253                 .need_dac_fix = 1,
16254                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16255                 .adc_nids = alc861_adc_nids,
16256                 .input_mux = &alc861_capture_source,
16257         },
16258         [ALC861_TOSHIBA] = {
16259                 .mixers = { alc861_toshiba_mixer },
16260                 .init_verbs = { alc861_base_init_verbs,
16261                                 alc861_toshiba_init_verbs },
16262                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16263                 .dac_nids = alc861_dac_nids,
16264                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16265                 .channel_mode = alc883_3ST_2ch_modes,
16266                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16267                 .adc_nids = alc861_adc_nids,
16268                 .input_mux = &alc861_capture_source,
16269                 .unsol_event = alc861_toshiba_unsol_event,
16270                 .init_hook = alc861_toshiba_automute,
16271         },
16272         [ALC861_ASUS] = {
16273                 .mixers = { alc861_asus_mixer },
16274                 .init_verbs = { alc861_asus_init_verbs },
16275                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16276                 .dac_nids = alc861_dac_nids,
16277                 .dig_out_nid = ALC861_DIGOUT_NID,
16278                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16279                 .channel_mode = alc861_asus_modes,
16280                 .need_dac_fix = 1,
16281                 .hp_nid = 0x06,
16282                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16283                 .adc_nids = alc861_adc_nids,
16284                 .input_mux = &alc861_capture_source,
16285         },
16286         [ALC861_ASUS_LAPTOP] = {
16287                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16288                 .init_verbs = { alc861_asus_init_verbs,
16289                                 alc861_asus_laptop_init_verbs },
16290                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
16291                 .dac_nids = alc861_dac_nids,
16292                 .dig_out_nid = ALC861_DIGOUT_NID,
16293                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16294                 .channel_mode = alc883_3ST_2ch_modes,
16295                 .need_dac_fix = 1,
16296                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16297                 .adc_nids = alc861_adc_nids,
16298                 .input_mux = &alc861_capture_source,
16299         },
16300 };
16301
16302 /* Pin config fixes */
16303 enum {
16304         PINFIX_FSC_AMILO_PI1505,
16305 };
16306
16307 static const struct alc_fixup alc861_fixups[] = {
16308         [PINFIX_FSC_AMILO_PI1505] = {
16309                 .pins = (const struct alc_pincfg[]) {
16310                         { 0x0b, 0x0221101f }, /* HP */
16311                         { 0x0f, 0x90170310 }, /* speaker */
16312                         { }
16313                 }
16314         },
16315 };
16316
16317 static struct snd_pci_quirk alc861_fixup_tbl[] = {
16318         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16319         {}
16320 };
16321
16322 static int patch_alc861(struct hda_codec *codec)
16323 {
16324         struct alc_spec *spec;
16325         int board_config;
16326         int err;
16327
16328         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16329         if (spec == NULL)
16330                 return -ENOMEM;
16331
16332         codec->spec = spec;
16333
16334         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16335                                                   alc861_models,
16336                                                   alc861_cfg_tbl);
16337
16338         if (board_config < 0) {
16339                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16340                        codec->chip_name);
16341                 board_config = ALC861_AUTO;
16342         }
16343
16344         if (board_config == ALC861_AUTO)
16345                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
16346
16347         if (board_config == ALC861_AUTO) {
16348                 /* automatic parse from the BIOS config */
16349                 err = alc861_parse_auto_config(codec);
16350                 if (err < 0) {
16351                         alc_free(codec);
16352                         return err;
16353                 } else if (!err) {
16354                         printk(KERN_INFO
16355                                "hda_codec: Cannot set up configuration "
16356                                "from BIOS.  Using base mode...\n");
16357                    board_config = ALC861_3ST_DIG;
16358                 }
16359         }
16360
16361         err = snd_hda_attach_beep_device(codec, 0x23);
16362         if (err < 0) {
16363                 alc_free(codec);
16364                 return err;
16365         }
16366
16367         if (board_config != ALC861_AUTO)
16368                 setup_preset(codec, &alc861_presets[board_config]);
16369
16370         spec->stream_analog_playback = &alc861_pcm_analog_playback;
16371         spec->stream_analog_capture = &alc861_pcm_analog_capture;
16372
16373         spec->stream_digital_playback = &alc861_pcm_digital_playback;
16374         spec->stream_digital_capture = &alc861_pcm_digital_capture;
16375
16376         if (!spec->cap_mixer)
16377                 set_capture_mixer(codec);
16378         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16379
16380         spec->vmaster_nid = 0x03;
16381
16382         if (board_config == ALC861_AUTO)
16383                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
16384
16385         codec->patch_ops = alc_patch_ops;
16386         if (board_config == ALC861_AUTO) {
16387                 spec->init_hook = alc861_auto_init;
16388 #ifdef CONFIG_SND_HDA_POWER_SAVE
16389                 spec->power_hook = alc_power_eapd;
16390 #endif
16391         }
16392 #ifdef CONFIG_SND_HDA_POWER_SAVE
16393         if (!spec->loopback.amplist)
16394                 spec->loopback.amplist = alc861_loopbacks;
16395 #endif
16396
16397         return 0;
16398 }
16399
16400 /*
16401  * ALC861-VD support
16402  *
16403  * Based on ALC882
16404  *
16405  * In addition, an independent DAC
16406  */
16407 #define ALC861VD_DIGOUT_NID     0x06
16408
16409 static hda_nid_t alc861vd_dac_nids[4] = {
16410         /* front, surr, clfe, side surr */
16411         0x02, 0x03, 0x04, 0x05
16412 };
16413
16414 /* dac_nids for ALC660vd are in a different order - according to
16415  * Realtek's driver.
16416  * This should probably result in a different mixer for 6stack models
16417  * of ALC660vd codecs, but for now there is only 3stack mixer
16418  * - and it is the same as in 861vd.
16419  * adc_nids in ALC660vd are (is) the same as in 861vd
16420  */
16421 static hda_nid_t alc660vd_dac_nids[3] = {
16422         /* front, rear, clfe, rear_surr */
16423         0x02, 0x04, 0x03
16424 };
16425
16426 static hda_nid_t alc861vd_adc_nids[1] = {
16427         /* ADC0 */
16428         0x09,
16429 };
16430
16431 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16432
16433 /* input MUX */
16434 /* FIXME: should be a matrix-type input source selection */
16435 static struct hda_input_mux alc861vd_capture_source = {
16436         .num_items = 4,
16437         .items = {
16438                 { "Mic", 0x0 },
16439                 { "Front Mic", 0x1 },
16440                 { "Line", 0x2 },
16441                 { "CD", 0x4 },
16442         },
16443 };
16444
16445 static struct hda_input_mux alc861vd_dallas_capture_source = {
16446         .num_items = 2,
16447         .items = {
16448                 { "Mic", 0x0 },
16449                 { "Internal Mic", 0x1 },
16450         },
16451 };
16452
16453 static struct hda_input_mux alc861vd_hp_capture_source = {
16454         .num_items = 2,
16455         .items = {
16456                 { "Front Mic", 0x0 },
16457                 { "ATAPI Mic", 0x1 },
16458         },
16459 };
16460
16461 /*
16462  * 2ch mode
16463  */
16464 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16465         { 2, NULL }
16466 };
16467
16468 /*
16469  * 6ch mode
16470  */
16471 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16472         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16473         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16474         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16475         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16476         { } /* end */
16477 };
16478
16479 /*
16480  * 8ch mode
16481  */
16482 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16483         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16484         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16485         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16486         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16487         { } /* end */
16488 };
16489
16490 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16491         { 6, alc861vd_6stack_ch6_init },
16492         { 8, alc861vd_6stack_ch8_init },
16493 };
16494
16495 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16496         {
16497                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16498                 .name = "Channel Mode",
16499                 .info = alc_ch_mode_info,
16500                 .get = alc_ch_mode_get,
16501                 .put = alc_ch_mode_put,
16502         },
16503         { } /* end */
16504 };
16505
16506 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16507  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16508  */
16509 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16510         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16511         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16512
16513         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16514         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16515
16516         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16517                                 HDA_OUTPUT),
16518         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16519                                 HDA_OUTPUT),
16520         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16521         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16522
16523         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16524         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16525
16526         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16527
16528         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16529         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16530         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16531
16532         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16533         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16534         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16535
16536         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16537         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16538
16539         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16540         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16541
16542         { } /* end */
16543 };
16544
16545 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16546         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16547         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16548
16549         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16550
16551         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16552         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16553         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16554
16555         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16556         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16557         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16558
16559         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16560         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16561
16562         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16563         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16564
16565         { } /* end */
16566 };
16567
16568 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16569         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16570         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16571         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16572
16573         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16574
16575         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16576         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16577         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16578
16579         HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16580         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16581         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16582
16583         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16584         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16585
16586         { } /* end */
16587 };
16588
16589 /* Pin assignment: Speaker=0x14, HP = 0x15,
16590  *                 Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16591  */
16592 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16593         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16594         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16595         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16596         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16597         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16598         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16599         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16600         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16601         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16602         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16603         { } /* end */
16604 };
16605
16606 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16607  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16608  */
16609 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16610         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16611         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16612         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16613         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16614         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16615         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16616         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16617         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16618
16619         { } /* end */
16620 };
16621
16622 /*
16623  * generic initialization of ADC, input mixers and output mixers
16624  */
16625 static struct hda_verb alc861vd_volume_init_verbs[] = {
16626         /*
16627          * Unmute ADC0 and set the default input to mic-in
16628          */
16629         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16630         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16631
16632         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16633          * the analog-loopback mixer widget
16634          */
16635         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16636         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16637         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16638         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16639         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16641
16642         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16643         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16644         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16645         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16646         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16647
16648         /*
16649          * Set up output mixers (0x02 - 0x05)
16650          */
16651         /* set vol=0 to output mixers */
16652         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16653         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16654         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16655         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16656
16657         /* set up input amps for analog loopback */
16658         /* Amp Indices: DAC = 0, mixer = 1 */
16659         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16660         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16661         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16662         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16663         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16664         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16665         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16666         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16667
16668         { }
16669 };
16670
16671 /*
16672  * 3-stack pin configuration:
16673  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16674  */
16675 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16676         /*
16677          * Set pin mode and muting
16678          */
16679         /* set front pin widgets 0x14 for output */
16680         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16681         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16682         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16683
16684         /* Mic (rear) pin: input vref at 80% */
16685         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16686         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16687         /* Front Mic pin: input vref at 80% */
16688         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16689         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16690         /* Line In pin: input */
16691         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16692         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16693         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16694         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16695         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16696         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16697         /* CD pin widget for input */
16698         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16699
16700         { }
16701 };
16702
16703 /*
16704  * 6-stack pin configuration:
16705  */
16706 static struct hda_verb alc861vd_6stack_init_verbs[] = {
16707         /*
16708          * Set pin mode and muting
16709          */
16710         /* set front pin widgets 0x14 for output */
16711         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16712         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16713         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16714
16715         /* Rear Pin: output 1 (0x0d) */
16716         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16717         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16718         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16719         /* CLFE Pin: output 2 (0x0e) */
16720         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16721         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16722         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16723         /* Side Pin: output 3 (0x0f) */
16724         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16725         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16726         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16727
16728         /* Mic (rear) pin: input vref at 80% */
16729         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16730         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16731         /* Front Mic pin: input vref at 80% */
16732         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16733         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16734         /* Line In pin: input */
16735         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16736         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16737         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16738         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16739         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16740         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16741         /* CD pin widget for input */
16742         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16743
16744         { }
16745 };
16746
16747 static struct hda_verb alc861vd_eapd_verbs[] = {
16748         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16749         { }
16750 };
16751
16752 static struct hda_verb alc660vd_eapd_verbs[] = {
16753         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16754         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16755         { }
16756 };
16757
16758 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16759         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16760         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16761         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16762         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16763         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16764         {}
16765 };
16766
16767 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16768 {
16769         struct alc_spec *spec = codec->spec;
16770         spec->autocfg.hp_pins[0] = 0x1b;
16771         spec->autocfg.speaker_pins[0] = 0x14;
16772 }
16773
16774 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16775 {
16776         alc_automute_amp(codec);
16777         alc88x_simple_mic_automute(codec);
16778 }
16779
16780 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16781                                         unsigned int res)
16782 {
16783         switch (res >> 26) {
16784         case ALC880_MIC_EVENT:
16785                 alc88x_simple_mic_automute(codec);
16786                 break;
16787         default:
16788                 alc_automute_amp_unsol_event(codec, res);
16789                 break;
16790         }
16791 }
16792
16793 static struct hda_verb alc861vd_dallas_verbs[] = {
16794         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16795         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16796         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16797         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16798
16799         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16800         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16801         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16802         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16803         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16804         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16805         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16806         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16807
16808         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16809         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16810         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16811         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16812         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16813         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16814         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16815         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16816
16817         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16818         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16819         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16820         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16821         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16822         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16823         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16824         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16825
16826         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16828         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16829         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16830
16831         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16832         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16833         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16834
16835         { } /* end */
16836 };
16837
16838 /* toggle speaker-output according to the hp-jack state */
16839 static void alc861vd_dallas_setup(struct hda_codec *codec)
16840 {
16841         struct alc_spec *spec = codec->spec;
16842
16843         spec->autocfg.hp_pins[0] = 0x15;
16844         spec->autocfg.speaker_pins[0] = 0x14;
16845 }
16846
16847 #ifdef CONFIG_SND_HDA_POWER_SAVE
16848 #define alc861vd_loopbacks      alc880_loopbacks
16849 #endif
16850
16851 /* pcm configuration: identical with ALC880 */
16852 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16853 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16854 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16855 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16856
16857 /*
16858  * configuration and preset
16859  */
16860 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16861         [ALC660VD_3ST]          = "3stack-660",
16862         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16863         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16864         [ALC861VD_3ST]          = "3stack",
16865         [ALC861VD_3ST_DIG]      = "3stack-digout",
16866         [ALC861VD_6ST_DIG]      = "6stack-digout",
16867         [ALC861VD_LENOVO]       = "lenovo",
16868         [ALC861VD_DALLAS]       = "dallas",
16869         [ALC861VD_HP]           = "hp",
16870         [ALC861VD_AUTO]         = "auto",
16871 };
16872
16873 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16874         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16875         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16876         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16877         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16878         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16879         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16880         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16881         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16882         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16883         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16884         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16885         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16886         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16887         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16888         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16889         {}
16890 };
16891
16892 static struct alc_config_preset alc861vd_presets[] = {
16893         [ALC660VD_3ST] = {
16894                 .mixers = { alc861vd_3st_mixer },
16895                 .init_verbs = { alc861vd_volume_init_verbs,
16896                                  alc861vd_3stack_init_verbs },
16897                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16898                 .dac_nids = alc660vd_dac_nids,
16899                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16900                 .channel_mode = alc861vd_3stack_2ch_modes,
16901                 .input_mux = &alc861vd_capture_source,
16902         },
16903         [ALC660VD_3ST_DIG] = {
16904                 .mixers = { alc861vd_3st_mixer },
16905                 .init_verbs = { alc861vd_volume_init_verbs,
16906                                  alc861vd_3stack_init_verbs },
16907                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16908                 .dac_nids = alc660vd_dac_nids,
16909                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16910                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16911                 .channel_mode = alc861vd_3stack_2ch_modes,
16912                 .input_mux = &alc861vd_capture_source,
16913         },
16914         [ALC861VD_3ST] = {
16915                 .mixers = { alc861vd_3st_mixer },
16916                 .init_verbs = { alc861vd_volume_init_verbs,
16917                                  alc861vd_3stack_init_verbs },
16918                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16919                 .dac_nids = alc861vd_dac_nids,
16920                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16921                 .channel_mode = alc861vd_3stack_2ch_modes,
16922                 .input_mux = &alc861vd_capture_source,
16923         },
16924         [ALC861VD_3ST_DIG] = {
16925                 .mixers = { alc861vd_3st_mixer },
16926                 .init_verbs = { alc861vd_volume_init_verbs,
16927                                  alc861vd_3stack_init_verbs },
16928                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16929                 .dac_nids = alc861vd_dac_nids,
16930                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16931                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16932                 .channel_mode = alc861vd_3stack_2ch_modes,
16933                 .input_mux = &alc861vd_capture_source,
16934         },
16935         [ALC861VD_6ST_DIG] = {
16936                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16937                 .init_verbs = { alc861vd_volume_init_verbs,
16938                                 alc861vd_6stack_init_verbs },
16939                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16940                 .dac_nids = alc861vd_dac_nids,
16941                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16942                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16943                 .channel_mode = alc861vd_6stack_modes,
16944                 .input_mux = &alc861vd_capture_source,
16945         },
16946         [ALC861VD_LENOVO] = {
16947                 .mixers = { alc861vd_lenovo_mixer },
16948                 .init_verbs = { alc861vd_volume_init_verbs,
16949                                 alc861vd_3stack_init_verbs,
16950                                 alc861vd_eapd_verbs,
16951                                 alc861vd_lenovo_unsol_verbs },
16952                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16953                 .dac_nids = alc660vd_dac_nids,
16954                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16955                 .channel_mode = alc861vd_3stack_2ch_modes,
16956                 .input_mux = &alc861vd_capture_source,
16957                 .unsol_event = alc861vd_lenovo_unsol_event,
16958                 .setup = alc861vd_lenovo_setup,
16959                 .init_hook = alc861vd_lenovo_init_hook,
16960         },
16961         [ALC861VD_DALLAS] = {
16962                 .mixers = { alc861vd_dallas_mixer },
16963                 .init_verbs = { alc861vd_dallas_verbs },
16964                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16965                 .dac_nids = alc861vd_dac_nids,
16966                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16967                 .channel_mode = alc861vd_3stack_2ch_modes,
16968                 .input_mux = &alc861vd_dallas_capture_source,
16969                 .unsol_event = alc_automute_amp_unsol_event,
16970                 .setup = alc861vd_dallas_setup,
16971                 .init_hook = alc_automute_amp,
16972         },
16973         [ALC861VD_HP] = {
16974                 .mixers = { alc861vd_hp_mixer },
16975                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16976                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16977                 .dac_nids = alc861vd_dac_nids,
16978                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16979                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16980                 .channel_mode = alc861vd_3stack_2ch_modes,
16981                 .input_mux = &alc861vd_hp_capture_source,
16982                 .unsol_event = alc_automute_amp_unsol_event,
16983                 .setup = alc861vd_dallas_setup,
16984                 .init_hook = alc_automute_amp,
16985         },
16986         [ALC660VD_ASUS_V1S] = {
16987                 .mixers = { alc861vd_lenovo_mixer },
16988                 .init_verbs = { alc861vd_volume_init_verbs,
16989                                 alc861vd_3stack_init_verbs,
16990                                 alc861vd_eapd_verbs,
16991                                 alc861vd_lenovo_unsol_verbs },
16992                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16993                 .dac_nids = alc660vd_dac_nids,
16994                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16995                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16996                 .channel_mode = alc861vd_3stack_2ch_modes,
16997                 .input_mux = &alc861vd_capture_source,
16998                 .unsol_event = alc861vd_lenovo_unsol_event,
16999                 .setup = alc861vd_lenovo_setup,
17000                 .init_hook = alc861vd_lenovo_init_hook,
17001         },
17002 };
17003
17004 /*
17005  * BIOS auto configuration
17006  */
17007 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17008                                                 const struct auto_pin_cfg *cfg)
17009 {
17010         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17011 }
17012
17013
17014 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17015                                 hda_nid_t nid, int pin_type, int dac_idx)
17016 {
17017         alc_set_pin_output(codec, nid, pin_type);
17018 }
17019
17020 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17021 {
17022         struct alc_spec *spec = codec->spec;
17023         int i;
17024
17025         for (i = 0; i <= HDA_SIDE; i++) {
17026                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17027                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17028                 if (nid)
17029                         alc861vd_auto_set_output_and_unmute(codec, nid,
17030                                                             pin_type, i);
17031         }
17032 }
17033
17034
17035 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17036 {
17037         struct alc_spec *spec = codec->spec;
17038         hda_nid_t pin;
17039
17040         pin = spec->autocfg.hp_pins[0];
17041         if (pin) /* connect to front and use dac 0 */
17042                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17043         pin = spec->autocfg.speaker_pins[0];
17044         if (pin)
17045                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17046 }
17047
17048 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
17049
17050 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17051 {
17052         struct alc_spec *spec = codec->spec;
17053         struct auto_pin_cfg *cfg = &spec->autocfg;
17054         int i;
17055
17056         for (i = 0; i < cfg->num_inputs; i++) {
17057                 hda_nid_t nid = cfg->inputs[i].pin;
17058                 if (alc_is_input_pin(codec, nid)) {
17059                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17060                         if (nid != ALC861VD_PIN_CD_NID &&
17061                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17062                                 snd_hda_codec_write(codec, nid, 0,
17063                                                 AC_VERB_SET_AMP_GAIN_MUTE,
17064                                                 AMP_OUT_MUTE);
17065                 }
17066         }
17067 }
17068
17069 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
17070
17071 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
17072 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
17073
17074 /* add playback controls from the parsed DAC table */
17075 /* Based on ALC880 version. But ALC861VD and ALC887 have separate,
17076  * different NIDs for mute/unmute switch and volume control */
17077 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17078                                              const struct auto_pin_cfg *cfg)
17079 {
17080         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
17081         const char *pfx = alc_get_line_out_pfx(cfg, true);
17082         hda_nid_t nid_v, nid_s;
17083         int i, err;
17084
17085         for (i = 0; i < cfg->line_outs; i++) {
17086                 if (!spec->multiout.dac_nids[i])
17087                         continue;
17088                 nid_v = alc861vd_idx_to_mixer_vol(
17089                                 alc880_dac_to_idx(
17090                                         spec->multiout.dac_nids[i]));
17091                 nid_s = alc861vd_idx_to_mixer_switch(
17092                                 alc880_dac_to_idx(
17093                                         spec->multiout.dac_nids[i]));
17094
17095                 if (!pfx && i == 2) {
17096                         /* Center/LFE */
17097                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17098                                               "Center",
17099                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17100                                                               HDA_OUTPUT));
17101                         if (err < 0)
17102                                 return err;
17103                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17104                                               "LFE",
17105                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17106                                                               HDA_OUTPUT));
17107                         if (err < 0)
17108                                 return err;
17109                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17110                                              "Center",
17111                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17112                                                               HDA_INPUT));
17113                         if (err < 0)
17114                                 return err;
17115                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17116                                              "LFE",
17117                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17118                                                               HDA_INPUT));
17119                         if (err < 0)
17120                                 return err;
17121                 } else {
17122                         const char *name = pfx;
17123                         if (!name)
17124                                 name = chname[i];
17125                         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17126                                                 name, i,
17127                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17128                                                               HDA_OUTPUT));
17129                         if (err < 0)
17130                                 return err;
17131                         err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17132                                                name, i,
17133                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17134                                                               HDA_INPUT));
17135                         if (err < 0)
17136                                 return err;
17137                 }
17138         }
17139         return 0;
17140 }
17141
17142 /* add playback controls for speaker and HP outputs */
17143 /* Based on ALC880 version. But ALC861VD has separate,
17144  * different NIDs for mute/unmute switch and volume control */
17145 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17146                                         hda_nid_t pin, const char *pfx)
17147 {
17148         hda_nid_t nid_v, nid_s;
17149         int err;
17150
17151         if (!pin)
17152                 return 0;
17153
17154         if (alc880_is_fixed_pin(pin)) {
17155                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17156                 /* specify the DAC as the extra output */
17157                 if (!spec->multiout.hp_nid)
17158                         spec->multiout.hp_nid = nid_v;
17159                 else
17160                         spec->multiout.extra_out_nid[0] = nid_v;
17161                 /* control HP volume/switch on the output mixer amp */
17162                 nid_v = alc861vd_idx_to_mixer_vol(
17163                                 alc880_fixed_pin_idx(pin));
17164                 nid_s = alc861vd_idx_to_mixer_switch(
17165                                 alc880_fixed_pin_idx(pin));
17166
17167                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17168                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17169                 if (err < 0)
17170                         return err;
17171                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17172                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17173                 if (err < 0)
17174                         return err;
17175         } else if (alc880_is_multi_pin(pin)) {
17176                 /* set manual connection */
17177                 /* we have only a switch on HP-out PIN */
17178                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17179                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17180                 if (err < 0)
17181                         return err;
17182         }
17183         return 0;
17184 }
17185
17186 /* parse the BIOS configuration and set up the alc_spec
17187  * return 1 if successful, 0 if the proper config is not found,
17188  * or a negative error code
17189  * Based on ALC880 version - had to change it to override
17190  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17191 static int alc861vd_parse_auto_config(struct hda_codec *codec)
17192 {
17193         struct alc_spec *spec = codec->spec;
17194         int err;
17195         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17196
17197         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17198                                            alc861vd_ignore);
17199         if (err < 0)
17200                 return err;
17201         if (!spec->autocfg.line_outs)
17202                 return 0; /* can't find valid BIOS pin config */
17203
17204         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17205         if (err < 0)
17206                 return err;
17207         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17208         if (err < 0)
17209                 return err;
17210         err = alc861vd_auto_create_extra_out(spec,
17211                                              spec->autocfg.speaker_pins[0],
17212                                              "Speaker");
17213         if (err < 0)
17214                 return err;
17215         err = alc861vd_auto_create_extra_out(spec,
17216                                              spec->autocfg.hp_pins[0],
17217                                              "Headphone");
17218         if (err < 0)
17219                 return err;
17220         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17221         if (err < 0)
17222                 return err;
17223
17224         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17225
17226         alc_auto_parse_digital(codec);
17227
17228         if (spec->kctls.list)
17229                 add_mixer(spec, spec->kctls.list);
17230
17231         add_verb(spec, alc861vd_volume_init_verbs);
17232
17233         spec->num_mux_defs = 1;
17234         spec->input_mux = &spec->private_imux[0];
17235
17236         err = alc_auto_add_mic_boost(codec);
17237         if (err < 0)
17238                 return err;
17239
17240         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17241
17242         return 1;
17243 }
17244
17245 /* additional initialization for auto-configuration model */
17246 static void alc861vd_auto_init(struct hda_codec *codec)
17247 {
17248         struct alc_spec *spec = codec->spec;
17249         alc861vd_auto_init_multi_out(codec);
17250         alc861vd_auto_init_hp_out(codec);
17251         alc861vd_auto_init_analog_input(codec);
17252         alc861vd_auto_init_input_src(codec);
17253         alc_auto_init_digital(codec);
17254         if (spec->unsol_event)
17255                 alc_inithook(codec);
17256 }
17257
17258 enum {
17259         ALC660VD_FIX_ASUS_GPIO1
17260 };
17261
17262 /* reset GPIO1 */
17263 static const struct alc_fixup alc861vd_fixups[] = {
17264         [ALC660VD_FIX_ASUS_GPIO1] = {
17265                 .verbs = (const struct hda_verb[]) {
17266                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17267                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17268                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17269                         { }
17270                 }
17271         },
17272 };
17273
17274 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17275         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17276         {}
17277 };
17278
17279 static int patch_alc861vd(struct hda_codec *codec)
17280 {
17281         struct alc_spec *spec;
17282         int err, board_config;
17283
17284         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17285         if (spec == NULL)
17286                 return -ENOMEM;
17287
17288         codec->spec = spec;
17289
17290         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17291                                                   alc861vd_models,
17292                                                   alc861vd_cfg_tbl);
17293
17294         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17295                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17296                        codec->chip_name);
17297                 board_config = ALC861VD_AUTO;
17298         }
17299
17300         if (board_config == ALC861VD_AUTO)
17301                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
17302
17303         if (board_config == ALC861VD_AUTO) {
17304                 /* automatic parse from the BIOS config */
17305                 err = alc861vd_parse_auto_config(codec);
17306                 if (err < 0) {
17307                         alc_free(codec);
17308                         return err;
17309                 } else if (!err) {
17310                         printk(KERN_INFO
17311                                "hda_codec: Cannot set up configuration "
17312                                "from BIOS.  Using base mode...\n");
17313                         board_config = ALC861VD_3ST;
17314                 }
17315         }
17316
17317         err = snd_hda_attach_beep_device(codec, 0x23);
17318         if (err < 0) {
17319                 alc_free(codec);
17320                 return err;
17321         }
17322
17323         if (board_config != ALC861VD_AUTO)
17324                 setup_preset(codec, &alc861vd_presets[board_config]);
17325
17326         if (codec->vendor_id == 0x10ec0660) {
17327                 /* always turn on EAPD */
17328                 add_verb(spec, alc660vd_eapd_verbs);
17329         }
17330
17331         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17332         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17333
17334         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17335         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17336
17337         if (!spec->adc_nids) {
17338                 spec->adc_nids = alc861vd_adc_nids;
17339                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17340         }
17341         if (!spec->capsrc_nids)
17342                 spec->capsrc_nids = alc861vd_capsrc_nids;
17343
17344         set_capture_mixer(codec);
17345         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17346
17347         spec->vmaster_nid = 0x02;
17348
17349         if (board_config == ALC861VD_AUTO)
17350                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
17351
17352         codec->patch_ops = alc_patch_ops;
17353
17354         if (board_config == ALC861VD_AUTO)
17355                 spec->init_hook = alc861vd_auto_init;
17356 #ifdef CONFIG_SND_HDA_POWER_SAVE
17357         if (!spec->loopback.amplist)
17358                 spec->loopback.amplist = alc861vd_loopbacks;
17359 #endif
17360
17361         return 0;
17362 }
17363
17364 /*
17365  * ALC662 support
17366  *
17367  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17368  * configuration.  Each pin widget can choose any input DACs and a mixer.
17369  * Each ADC is connected from a mixer of all inputs.  This makes possible
17370  * 6-channel independent captures.
17371  *
17372  * In addition, an independent DAC for the multi-playback (not used in this
17373  * driver yet).
17374  */
17375 #define ALC662_DIGOUT_NID       0x06
17376 #define ALC662_DIGIN_NID        0x0a
17377
17378 static hda_nid_t alc662_dac_nids[4] = {
17379         /* front, rear, clfe, rear_surr */
17380         0x02, 0x03, 0x04
17381 };
17382
17383 static hda_nid_t alc272_dac_nids[2] = {
17384         0x02, 0x03
17385 };
17386
17387 static hda_nid_t alc662_adc_nids[2] = {
17388         /* ADC1-2 */
17389         0x09, 0x08
17390 };
17391
17392 static hda_nid_t alc272_adc_nids[1] = {
17393         /* ADC1-2 */
17394         0x08,
17395 };
17396
17397 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17398 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17399
17400
17401 /* input MUX */
17402 /* FIXME: should be a matrix-type input source selection */
17403 static struct hda_input_mux alc662_capture_source = {
17404         .num_items = 4,
17405         .items = {
17406                 { "Mic", 0x0 },
17407                 { "Front Mic", 0x1 },
17408                 { "Line", 0x2 },
17409                 { "CD", 0x4 },
17410         },
17411 };
17412
17413 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17414         .num_items = 2,
17415         .items = {
17416                 { "Mic", 0x1 },
17417                 { "Line", 0x2 },
17418         },
17419 };
17420
17421 static struct hda_input_mux alc663_capture_source = {
17422         .num_items = 3,
17423         .items = {
17424                 { "Mic", 0x0 },
17425                 { "Front Mic", 0x1 },
17426                 { "Line", 0x2 },
17427         },
17428 };
17429
17430 #if 0 /* set to 1 for testing other input sources below */
17431 static struct hda_input_mux alc272_nc10_capture_source = {
17432         .num_items = 16,
17433         .items = {
17434                 { "Autoselect Mic", 0x0 },
17435                 { "Internal Mic", 0x1 },
17436                 { "In-0x02", 0x2 },
17437                 { "In-0x03", 0x3 },
17438                 { "In-0x04", 0x4 },
17439                 { "In-0x05", 0x5 },
17440                 { "In-0x06", 0x6 },
17441                 { "In-0x07", 0x7 },
17442                 { "In-0x08", 0x8 },
17443                 { "In-0x09", 0x9 },
17444                 { "In-0x0a", 0x0a },
17445                 { "In-0x0b", 0x0b },
17446                 { "In-0x0c", 0x0c },
17447                 { "In-0x0d", 0x0d },
17448                 { "In-0x0e", 0x0e },
17449                 { "In-0x0f", 0x0f },
17450         },
17451 };
17452 #endif
17453
17454 /*
17455  * 2ch mode
17456  */
17457 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17458         { 2, NULL }
17459 };
17460
17461 /*
17462  * 2ch mode
17463  */
17464 static struct hda_verb alc662_3ST_ch2_init[] = {
17465         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17466         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17467         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17468         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17469         { } /* end */
17470 };
17471
17472 /*
17473  * 6ch mode
17474  */
17475 static struct hda_verb alc662_3ST_ch6_init[] = {
17476         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17477         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17478         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17479         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17480         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17481         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17482         { } /* end */
17483 };
17484
17485 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17486         { 2, alc662_3ST_ch2_init },
17487         { 6, alc662_3ST_ch6_init },
17488 };
17489
17490 /*
17491  * 2ch mode
17492  */
17493 static struct hda_verb alc662_sixstack_ch6_init[] = {
17494         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17495         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17496         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17497         { } /* end */
17498 };
17499
17500 /*
17501  * 6ch mode
17502  */
17503 static struct hda_verb alc662_sixstack_ch8_init[] = {
17504         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17505         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17506         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17507         { } /* end */
17508 };
17509
17510 static struct hda_channel_mode alc662_5stack_modes[2] = {
17511         { 2, alc662_sixstack_ch6_init },
17512         { 6, alc662_sixstack_ch8_init },
17513 };
17514
17515 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17516  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17517  */
17518
17519 static struct snd_kcontrol_new alc662_base_mixer[] = {
17520         /* output mixer control */
17521         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17522         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17523         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17524         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17525         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17526         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17527         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17528         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17529         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17530
17531         /*Input mixer control */
17532         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17533         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17534         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17535         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17536         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17537         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17538         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17539         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17540         { } /* end */
17541 };
17542
17543 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17544         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17545         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17546         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17547         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17548         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17549         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17550         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17551         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17552         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17553         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17554         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17555         { } /* end */
17556 };
17557
17558 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17559         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17560         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17561         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17562         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17563         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17564         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17565         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17566         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17567         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17568         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17569         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17570         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17571         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17572         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17573         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17574         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17575         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17576         { } /* end */
17577 };
17578
17579 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17580         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17581         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17582         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17583         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17584         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17585         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17586         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17587         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17588         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17589         { } /* end */
17590 };
17591
17592 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17593         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17594         ALC262_HIPPO_MASTER_SWITCH,
17595
17596         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17597         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17598         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17599
17600         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17601         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17602         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17603         { } /* end */
17604 };
17605
17606 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17607         ALC262_HIPPO_MASTER_SWITCH,
17608         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17609         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17610         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17611         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17612         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17613         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17614         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17615         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17616         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17617         { } /* end */
17618 };
17619
17620 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17621         .ops = &snd_hda_bind_vol,
17622         .values = {
17623                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17624                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17625                 0
17626         },
17627 };
17628
17629 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17630         .ops = &snd_hda_bind_sw,
17631         .values = {
17632                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17633                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17634                 0
17635         },
17636 };
17637
17638 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17639         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17640         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17641         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17642         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17643         { } /* end */
17644 };
17645
17646 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17647         .ops = &snd_hda_bind_sw,
17648         .values = {
17649                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17650                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17651                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17652                 0
17653         },
17654 };
17655
17656 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17657         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17658         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17659         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17660         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17661         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17662         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17663
17664         { } /* end */
17665 };
17666
17667 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17668         .ops = &snd_hda_bind_sw,
17669         .values = {
17670                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17671                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17672                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17673                 0
17674         },
17675 };
17676
17677 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17678         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17679         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17680         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17681         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17682         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17683         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17684         { } /* end */
17685 };
17686
17687 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17688         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17689         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17690         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17691         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17692         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17693         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17694         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17695         { } /* end */
17696 };
17697
17698 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17699         .ops = &snd_hda_bind_vol,
17700         .values = {
17701                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17702                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17703                 0
17704         },
17705 };
17706
17707 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17708         .ops = &snd_hda_bind_sw,
17709         .values = {
17710                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17711                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17712                 0
17713         },
17714 };
17715
17716 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17717         HDA_BIND_VOL("Master Playback Volume",
17718                                 &alc663_asus_two_bind_master_vol),
17719         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17720         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17721         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17722         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17723         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17724         { } /* end */
17725 };
17726
17727 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17728         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17729         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17730         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17731         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17732         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17733         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17734         { } /* end */
17735 };
17736
17737 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17738         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17739         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17740         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17741         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17742         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17743
17744         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17745         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17746         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17747         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17748         { } /* end */
17749 };
17750
17751 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17752         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17753         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17754         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17755
17756         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17757         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17758         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17759         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17760         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17761         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17762         { } /* end */
17763 };
17764
17765 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17766         .ops = &snd_hda_bind_sw,
17767         .values = {
17768                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17769                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17770                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17771                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17772                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17773                 0
17774         },
17775 };
17776
17777 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17778         .ops = &snd_hda_bind_sw,
17779         .values = {
17780                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17781                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17782                 0
17783         },
17784 };
17785
17786 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17787         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17788         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17789         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17790         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17791         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17792         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17793         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17794         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17795         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17796         { } /* end */
17797 };
17798
17799 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17800         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17801         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17802         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17803         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17804         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17805         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17806         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17807         { } /* end */
17808 };
17809
17810
17811 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17812         {
17813                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17814                 .name = "Channel Mode",
17815                 .info = alc_ch_mode_info,
17816                 .get = alc_ch_mode_get,
17817                 .put = alc_ch_mode_put,
17818         },
17819         { } /* end */
17820 };
17821
17822 static struct hda_verb alc662_init_verbs[] = {
17823         /* ADC: mute amp left and right */
17824         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17825         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17826
17827         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17828         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17829         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17830         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17831         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17832         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17833
17834         /* Front Pin: output 0 (0x0c) */
17835         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17836         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17837
17838         /* Rear Pin: output 1 (0x0d) */
17839         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17840         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17841
17842         /* CLFE Pin: output 2 (0x0e) */
17843         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17844         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17845
17846         /* Mic (rear) pin: input vref at 80% */
17847         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17848         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17849         /* Front Mic pin: input vref at 80% */
17850         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17851         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17852         /* Line In pin: input */
17853         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17854         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17855         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17856         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17857         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17858         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17859         /* CD pin widget for input */
17860         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17861
17862         /* FIXME: use matrix-type input source selection */
17863         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17864         /* Input mixer */
17865         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17866         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17867
17868         /* always trun on EAPD */
17869         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17870         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17871
17872         { }
17873 };
17874
17875 static struct hda_verb alc663_init_verbs[] = {
17876         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17877         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17878         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17879         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17880         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17881         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17882         { }
17883 };
17884
17885 static struct hda_verb alc272_init_verbs[] = {
17886         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17887         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17888         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17889         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17890         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17891         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17892         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17893         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17894         { }
17895 };
17896
17897 static struct hda_verb alc662_sue_init_verbs[] = {
17898         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17899         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17900         {}
17901 };
17902
17903 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17904         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17905         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17906         {}
17907 };
17908
17909 /* Set Unsolicited Event*/
17910 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17911         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17912         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17913         {}
17914 };
17915
17916 static struct hda_verb alc663_m51va_init_verbs[] = {
17917         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17918         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17919         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17920         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17921         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17922         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17923         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17924         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17925         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17926         {}
17927 };
17928
17929 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17930         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17931         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17932         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17933         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17934         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17935         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17936         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17937         {}
17938 };
17939
17940 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17941         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17942         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17943         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17944         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17945         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17946         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17947         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17948         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17949         {}
17950 };
17951
17952 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17953         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17954         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17955         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17956         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17957         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17958         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17959         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17960         {}
17961 };
17962
17963 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17964         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17965         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17966         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17967         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17968         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17969         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17970         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17971         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17972         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17973         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17974         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17975         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17976         {}
17977 };
17978
17979 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17980         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17981         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17982         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17983         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17984         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17985         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17986         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17987         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17988         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17989         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17990         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17991         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17992         {}
17993 };
17994
17995 static struct hda_verb alc663_g71v_init_verbs[] = {
17996         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17997         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17998         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17999
18000         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18001         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18002         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18003
18004         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18005         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18006         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18007         {}
18008 };
18009
18010 static struct hda_verb alc663_g50v_init_verbs[] = {
18011         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18012         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18013         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
18014
18015         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18016         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18017         {}
18018 };
18019
18020 static struct hda_verb alc662_ecs_init_verbs[] = {
18021         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18022         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18023         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18024         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18025         {}
18026 };
18027
18028 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
18029         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18030         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18031         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18032         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18033         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18034         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18035         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18036         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18037         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18038         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18039         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18040         {}
18041 };
18042
18043 static struct hda_verb alc272_dell_init_verbs[] = {
18044         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18045         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18046         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18047         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18048         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18049         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18050         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18051         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18052         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18053         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18054         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18055         {}
18056 };
18057
18058 static struct hda_verb alc663_mode7_init_verbs[] = {
18059         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18060         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18061         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18062         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18063         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18064         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18065         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18066         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18067         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18068         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18069         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18070         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18071         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18072         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18073         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18074         {}
18075 };
18076
18077 static struct hda_verb alc663_mode8_init_verbs[] = {
18078         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18079         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18080         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18081         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18082         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18083         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18084         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18085         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18086         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18087         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18088         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
18089         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18090         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18091         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18092         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18093         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18094         {}
18095 };
18096
18097 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18098         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18099         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18100         { } /* end */
18101 };
18102
18103 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18104         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18105         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18106         { } /* end */
18107 };
18108
18109 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18110 {
18111         unsigned int present;
18112         unsigned char bits;
18113
18114         present = snd_hda_jack_detect(codec, 0x14);
18115         bits = present ? HDA_AMP_MUTE : 0;
18116
18117         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18118                                  HDA_AMP_MUTE, bits);
18119 }
18120
18121 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18122 {
18123         unsigned int present;
18124         unsigned char bits;
18125
18126         present = snd_hda_jack_detect(codec, 0x1b);
18127         bits = present ? HDA_AMP_MUTE : 0;
18128
18129         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18130                                  HDA_AMP_MUTE, bits);
18131         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18132                                  HDA_AMP_MUTE, bits);
18133 }
18134
18135 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18136                                            unsigned int res)
18137 {
18138         if ((res >> 26) == ALC880_HP_EVENT)
18139                 alc662_lenovo_101e_all_automute(codec);
18140         if ((res >> 26) == ALC880_FRONT_EVENT)
18141                 alc662_lenovo_101e_ispeaker_automute(codec);
18142 }
18143
18144 /* unsolicited event for HP jack sensing */
18145 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18146                                      unsigned int res)
18147 {
18148         if ((res >> 26) == ALC880_MIC_EVENT)
18149                 alc_mic_automute(codec);
18150         else
18151                 alc262_hippo_unsol_event(codec, res);
18152 }
18153
18154 static void alc662_eeepc_setup(struct hda_codec *codec)
18155 {
18156         struct alc_spec *spec = codec->spec;
18157
18158         alc262_hippo1_setup(codec);
18159         spec->ext_mic.pin = 0x18;
18160         spec->ext_mic.mux_idx = 0;
18161         spec->int_mic.pin = 0x19;
18162         spec->int_mic.mux_idx = 1;
18163         spec->auto_mic = 1;
18164 }
18165
18166 static void alc662_eeepc_inithook(struct hda_codec *codec)
18167 {
18168         alc262_hippo_automute(codec);
18169         alc_mic_automute(codec);
18170 }
18171
18172 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18173 {
18174         struct alc_spec *spec = codec->spec;
18175
18176         spec->autocfg.hp_pins[0] = 0x14;
18177         spec->autocfg.speaker_pins[0] = 0x1b;
18178 }
18179
18180 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
18181
18182 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18183 {
18184         unsigned int present;
18185         unsigned char bits;
18186
18187         present = snd_hda_jack_detect(codec, 0x21);
18188         bits = present ? HDA_AMP_MUTE : 0;
18189         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18190                                  HDA_AMP_MUTE, bits);
18191         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18192                                  HDA_AMP_MUTE, bits);
18193 }
18194
18195 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18196 {
18197         unsigned int present;
18198         unsigned char bits;
18199
18200         present = snd_hda_jack_detect(codec, 0x21);
18201         bits = present ? HDA_AMP_MUTE : 0;
18202         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18203                                  HDA_AMP_MUTE, bits);
18204         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18205                                  HDA_AMP_MUTE, bits);
18206         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18207                                  HDA_AMP_MUTE, bits);
18208         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18209                                  HDA_AMP_MUTE, bits);
18210 }
18211
18212 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18213 {
18214         unsigned int present;
18215         unsigned char bits;
18216
18217         present = snd_hda_jack_detect(codec, 0x15);
18218         bits = present ? HDA_AMP_MUTE : 0;
18219         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18220                                  HDA_AMP_MUTE, bits);
18221         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18222                                  HDA_AMP_MUTE, bits);
18223         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18224                                  HDA_AMP_MUTE, bits);
18225         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18226                                  HDA_AMP_MUTE, bits);
18227 }
18228
18229 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18230 {
18231         unsigned int present;
18232         unsigned char bits;
18233
18234         present = snd_hda_jack_detect(codec, 0x1b);
18235         bits = present ? 0 : PIN_OUT;
18236         snd_hda_codec_write(codec, 0x14, 0,
18237                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18238 }
18239
18240 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18241 {
18242         unsigned int present1, present2;
18243
18244         present1 = snd_hda_jack_detect(codec, 0x21);
18245         present2 = snd_hda_jack_detect(codec, 0x15);
18246
18247         if (present1 || present2) {
18248                 snd_hda_codec_write_cache(codec, 0x14, 0,
18249                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18250         } else {
18251                 snd_hda_codec_write_cache(codec, 0x14, 0,
18252                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18253         }
18254 }
18255
18256 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18257 {
18258         unsigned int present1, present2;
18259
18260         present1 = snd_hda_jack_detect(codec, 0x1b);
18261         present2 = snd_hda_jack_detect(codec, 0x15);
18262
18263         if (present1 || present2) {
18264                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18265                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18266                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18267                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
18268         } else {
18269                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18270                                          HDA_AMP_MUTE, 0);
18271                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18272                                          HDA_AMP_MUTE, 0);
18273         }
18274 }
18275
18276 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18277 {
18278         unsigned int present1, present2;
18279
18280         present1 = snd_hda_codec_read(codec, 0x1b, 0,
18281                         AC_VERB_GET_PIN_SENSE, 0)
18282                         & AC_PINSENSE_PRESENCE;
18283         present2 = snd_hda_codec_read(codec, 0x21, 0,
18284                         AC_VERB_GET_PIN_SENSE, 0)
18285                         & AC_PINSENSE_PRESENCE;
18286
18287         if (present1 || present2) {
18288                 snd_hda_codec_write_cache(codec, 0x14, 0,
18289                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18290                 snd_hda_codec_write_cache(codec, 0x17, 0,
18291                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18292         } else {
18293                 snd_hda_codec_write_cache(codec, 0x14, 0,
18294                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18295                 snd_hda_codec_write_cache(codec, 0x17, 0,
18296                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18297         }
18298 }
18299
18300 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18301 {
18302         unsigned int present1, present2;
18303
18304         present1 = snd_hda_codec_read(codec, 0x21, 0,
18305                         AC_VERB_GET_PIN_SENSE, 0)
18306                         & AC_PINSENSE_PRESENCE;
18307         present2 = snd_hda_codec_read(codec, 0x15, 0,
18308                         AC_VERB_GET_PIN_SENSE, 0)
18309                         & AC_PINSENSE_PRESENCE;
18310
18311         if (present1 || present2) {
18312                 snd_hda_codec_write_cache(codec, 0x14, 0,
18313                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18314                 snd_hda_codec_write_cache(codec, 0x17, 0,
18315                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18316         } else {
18317                 snd_hda_codec_write_cache(codec, 0x14, 0,
18318                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18319                 snd_hda_codec_write_cache(codec, 0x17, 0,
18320                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18321         }
18322 }
18323
18324 static void alc663_m51va_unsol_event(struct hda_codec *codec,
18325                                            unsigned int res)
18326 {
18327         switch (res >> 26) {
18328         case ALC880_HP_EVENT:
18329                 alc663_m51va_speaker_automute(codec);
18330                 break;
18331         case ALC880_MIC_EVENT:
18332                 alc_mic_automute(codec);
18333                 break;
18334         }
18335 }
18336
18337 static void alc663_m51va_setup(struct hda_codec *codec)
18338 {
18339         struct alc_spec *spec = codec->spec;
18340         spec->ext_mic.pin = 0x18;
18341         spec->ext_mic.mux_idx = 0;
18342         spec->int_mic.pin = 0x12;
18343         spec->int_mic.mux_idx = 9;
18344         spec->auto_mic = 1;
18345 }
18346
18347 static void alc663_m51va_inithook(struct hda_codec *codec)
18348 {
18349         alc663_m51va_speaker_automute(codec);
18350         alc_mic_automute(codec);
18351 }
18352
18353 /* ***************** Mode1 ******************************/
18354 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
18355
18356 static void alc663_mode1_setup(struct hda_codec *codec)
18357 {
18358         struct alc_spec *spec = codec->spec;
18359         spec->ext_mic.pin = 0x18;
18360         spec->ext_mic.mux_idx = 0;
18361         spec->int_mic.pin = 0x19;
18362         spec->int_mic.mux_idx = 1;
18363         spec->auto_mic = 1;
18364 }
18365
18366 #define alc663_mode1_inithook           alc663_m51va_inithook
18367
18368 /* ***************** Mode2 ******************************/
18369 static void alc662_mode2_unsol_event(struct hda_codec *codec,
18370                                            unsigned int res)
18371 {
18372         switch (res >> 26) {
18373         case ALC880_HP_EVENT:
18374                 alc662_f5z_speaker_automute(codec);
18375                 break;
18376         case ALC880_MIC_EVENT:
18377                 alc_mic_automute(codec);
18378                 break;
18379         }
18380 }
18381
18382 #define alc662_mode2_setup      alc663_mode1_setup
18383
18384 static void alc662_mode2_inithook(struct hda_codec *codec)
18385 {
18386         alc662_f5z_speaker_automute(codec);
18387         alc_mic_automute(codec);
18388 }
18389 /* ***************** Mode3 ******************************/
18390 static void alc663_mode3_unsol_event(struct hda_codec *codec,
18391                                            unsigned int res)
18392 {
18393         switch (res >> 26) {
18394         case ALC880_HP_EVENT:
18395                 alc663_two_hp_m1_speaker_automute(codec);
18396                 break;
18397         case ALC880_MIC_EVENT:
18398                 alc_mic_automute(codec);
18399                 break;
18400         }
18401 }
18402
18403 #define alc663_mode3_setup      alc663_mode1_setup
18404
18405 static void alc663_mode3_inithook(struct hda_codec *codec)
18406 {
18407         alc663_two_hp_m1_speaker_automute(codec);
18408         alc_mic_automute(codec);
18409 }
18410 /* ***************** Mode4 ******************************/
18411 static void alc663_mode4_unsol_event(struct hda_codec *codec,
18412                                            unsigned int res)
18413 {
18414         switch (res >> 26) {
18415         case ALC880_HP_EVENT:
18416                 alc663_21jd_two_speaker_automute(codec);
18417                 break;
18418         case ALC880_MIC_EVENT:
18419                 alc_mic_automute(codec);
18420                 break;
18421         }
18422 }
18423
18424 #define alc663_mode4_setup      alc663_mode1_setup
18425
18426 static void alc663_mode4_inithook(struct hda_codec *codec)
18427 {
18428         alc663_21jd_two_speaker_automute(codec);
18429         alc_mic_automute(codec);
18430 }
18431 /* ***************** Mode5 ******************************/
18432 static void alc663_mode5_unsol_event(struct hda_codec *codec,
18433                                            unsigned int res)
18434 {
18435         switch (res >> 26) {
18436         case ALC880_HP_EVENT:
18437                 alc663_15jd_two_speaker_automute(codec);
18438                 break;
18439         case ALC880_MIC_EVENT:
18440                 alc_mic_automute(codec);
18441                 break;
18442         }
18443 }
18444
18445 #define alc663_mode5_setup      alc663_mode1_setup
18446
18447 static void alc663_mode5_inithook(struct hda_codec *codec)
18448 {
18449         alc663_15jd_two_speaker_automute(codec);
18450         alc_mic_automute(codec);
18451 }
18452 /* ***************** Mode6 ******************************/
18453 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18454                                            unsigned int res)
18455 {
18456         switch (res >> 26) {
18457         case ALC880_HP_EVENT:
18458                 alc663_two_hp_m2_speaker_automute(codec);
18459                 break;
18460         case ALC880_MIC_EVENT:
18461                 alc_mic_automute(codec);
18462                 break;
18463         }
18464 }
18465
18466 #define alc663_mode6_setup      alc663_mode1_setup
18467
18468 static void alc663_mode6_inithook(struct hda_codec *codec)
18469 {
18470         alc663_two_hp_m2_speaker_automute(codec);
18471         alc_mic_automute(codec);
18472 }
18473
18474 /* ***************** Mode7 ******************************/
18475 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18476                                            unsigned int res)
18477 {
18478         switch (res >> 26) {
18479         case ALC880_HP_EVENT:
18480                 alc663_two_hp_m7_speaker_automute(codec);
18481                 break;
18482         case ALC880_MIC_EVENT:
18483                 alc_mic_automute(codec);
18484                 break;
18485         }
18486 }
18487
18488 #define alc663_mode7_setup      alc663_mode1_setup
18489
18490 static void alc663_mode7_inithook(struct hda_codec *codec)
18491 {
18492         alc663_two_hp_m7_speaker_automute(codec);
18493         alc_mic_automute(codec);
18494 }
18495
18496 /* ***************** Mode8 ******************************/
18497 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18498                                            unsigned int res)
18499 {
18500         switch (res >> 26) {
18501         case ALC880_HP_EVENT:
18502                 alc663_two_hp_m8_speaker_automute(codec);
18503                 break;
18504         case ALC880_MIC_EVENT:
18505                 alc_mic_automute(codec);
18506                 break;
18507         }
18508 }
18509
18510 #define alc663_mode8_setup      alc663_m51va_setup
18511
18512 static void alc663_mode8_inithook(struct hda_codec *codec)
18513 {
18514         alc663_two_hp_m8_speaker_automute(codec);
18515         alc_mic_automute(codec);
18516 }
18517
18518 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18519 {
18520         unsigned int present;
18521         unsigned char bits;
18522
18523         present = snd_hda_jack_detect(codec, 0x21);
18524         bits = present ? HDA_AMP_MUTE : 0;
18525         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18526                                  HDA_AMP_MUTE, bits);
18527         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18528                                  HDA_AMP_MUTE, bits);
18529 }
18530
18531 static void alc663_g71v_front_automute(struct hda_codec *codec)
18532 {
18533         unsigned int present;
18534         unsigned char bits;
18535
18536         present = snd_hda_jack_detect(codec, 0x15);
18537         bits = present ? HDA_AMP_MUTE : 0;
18538         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18539                                  HDA_AMP_MUTE, bits);
18540 }
18541
18542 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18543                                            unsigned int res)
18544 {
18545         switch (res >> 26) {
18546         case ALC880_HP_EVENT:
18547                 alc663_g71v_hp_automute(codec);
18548                 break;
18549         case ALC880_FRONT_EVENT:
18550                 alc663_g71v_front_automute(codec);
18551                 break;
18552         case ALC880_MIC_EVENT:
18553                 alc_mic_automute(codec);
18554                 break;
18555         }
18556 }
18557
18558 #define alc663_g71v_setup       alc663_m51va_setup
18559
18560 static void alc663_g71v_inithook(struct hda_codec *codec)
18561 {
18562         alc663_g71v_front_automute(codec);
18563         alc663_g71v_hp_automute(codec);
18564         alc_mic_automute(codec);
18565 }
18566
18567 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18568                                            unsigned int res)
18569 {
18570         switch (res >> 26) {
18571         case ALC880_HP_EVENT:
18572                 alc663_m51va_speaker_automute(codec);
18573                 break;
18574         case ALC880_MIC_EVENT:
18575                 alc_mic_automute(codec);
18576                 break;
18577         }
18578 }
18579
18580 #define alc663_g50v_setup       alc663_m51va_setup
18581
18582 static void alc663_g50v_inithook(struct hda_codec *codec)
18583 {
18584         alc663_m51va_speaker_automute(codec);
18585         alc_mic_automute(codec);
18586 }
18587
18588 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18589         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18590         ALC262_HIPPO_MASTER_SWITCH,
18591
18592         HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18593         HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18594         HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18595
18596         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18597         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18598         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18599         { } /* end */
18600 };
18601
18602 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18603         /* Master Playback automatically created from Speaker and Headphone */
18604         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18605         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18606         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18607         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18608
18609         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18610         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18611         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18612
18613         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18614         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18615         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18616         { } /* end */
18617 };
18618
18619 #ifdef CONFIG_SND_HDA_POWER_SAVE
18620 #define alc662_loopbacks        alc880_loopbacks
18621 #endif
18622
18623
18624 /* pcm configuration: identical with ALC880 */
18625 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18626 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18627 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18628 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18629
18630 /*
18631  * configuration and preset
18632  */
18633 static const char *alc662_models[ALC662_MODEL_LAST] = {
18634         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18635         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18636         [ALC662_3ST_6ch]        = "3stack-6ch",
18637         [ALC662_5ST_DIG]        = "6stack-dig",
18638         [ALC662_LENOVO_101E]    = "lenovo-101e",
18639         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18640         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18641         [ALC662_ECS] = "ecs",
18642         [ALC663_ASUS_M51VA] = "m51va",
18643         [ALC663_ASUS_G71V] = "g71v",
18644         [ALC663_ASUS_H13] = "h13",
18645         [ALC663_ASUS_G50V] = "g50v",
18646         [ALC663_ASUS_MODE1] = "asus-mode1",
18647         [ALC662_ASUS_MODE2] = "asus-mode2",
18648         [ALC663_ASUS_MODE3] = "asus-mode3",
18649         [ALC663_ASUS_MODE4] = "asus-mode4",
18650         [ALC663_ASUS_MODE5] = "asus-mode5",
18651         [ALC663_ASUS_MODE6] = "asus-mode6",
18652         [ALC663_ASUS_MODE7] = "asus-mode7",
18653         [ALC663_ASUS_MODE8] = "asus-mode8",
18654         [ALC272_DELL]           = "dell",
18655         [ALC272_DELL_ZM1]       = "dell-zm1",
18656         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18657         [ALC662_AUTO]           = "auto",
18658 };
18659
18660 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18661         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18662         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18663         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18664         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18665         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18666         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18667         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18668         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18669         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18670         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18671         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18672         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18673         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18674         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18675         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18676         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18677         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18678         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18679         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18680         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18681         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18682         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18683         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18684         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18685         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18686         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18687         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18688         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18689         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18690         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18691         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18692         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18693         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18694         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18695         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18696         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18697         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18698         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18699         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18700         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18701         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18702         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18703         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18704         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18705         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18706         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18707         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18708         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18709         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18710         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18711         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18712         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18713         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18714         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18715         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18716         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18717         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18718         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18719         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18720         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18721         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18722         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18723         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18724         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18725                       ALC662_3ST_6ch_DIG),
18726         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18727         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18728         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18729                       ALC662_3ST_6ch_DIG),
18730         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18731         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18732         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18733         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18734         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18735                                         ALC662_3ST_6ch_DIG),
18736         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18737                            ALC663_ASUS_H13),
18738         {}
18739 };
18740
18741 static struct alc_config_preset alc662_presets[] = {
18742         [ALC662_3ST_2ch_DIG] = {
18743                 .mixers = { alc662_3ST_2ch_mixer },
18744                 .init_verbs = { alc662_init_verbs },
18745                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18746                 .dac_nids = alc662_dac_nids,
18747                 .dig_out_nid = ALC662_DIGOUT_NID,
18748                 .dig_in_nid = ALC662_DIGIN_NID,
18749                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18750                 .channel_mode = alc662_3ST_2ch_modes,
18751                 .input_mux = &alc662_capture_source,
18752         },
18753         [ALC662_3ST_6ch_DIG] = {
18754                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18755                 .init_verbs = { alc662_init_verbs },
18756                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18757                 .dac_nids = alc662_dac_nids,
18758                 .dig_out_nid = ALC662_DIGOUT_NID,
18759                 .dig_in_nid = ALC662_DIGIN_NID,
18760                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18761                 .channel_mode = alc662_3ST_6ch_modes,
18762                 .need_dac_fix = 1,
18763                 .input_mux = &alc662_capture_source,
18764         },
18765         [ALC662_3ST_6ch] = {
18766                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18767                 .init_verbs = { alc662_init_verbs },
18768                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18769                 .dac_nids = alc662_dac_nids,
18770                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18771                 .channel_mode = alc662_3ST_6ch_modes,
18772                 .need_dac_fix = 1,
18773                 .input_mux = &alc662_capture_source,
18774         },
18775         [ALC662_5ST_DIG] = {
18776                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18777                 .init_verbs = { alc662_init_verbs },
18778                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18779                 .dac_nids = alc662_dac_nids,
18780                 .dig_out_nid = ALC662_DIGOUT_NID,
18781                 .dig_in_nid = ALC662_DIGIN_NID,
18782                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18783                 .channel_mode = alc662_5stack_modes,
18784                 .input_mux = &alc662_capture_source,
18785         },
18786         [ALC662_LENOVO_101E] = {
18787                 .mixers = { alc662_lenovo_101e_mixer },
18788                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18789                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18790                 .dac_nids = alc662_dac_nids,
18791                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18792                 .channel_mode = alc662_3ST_2ch_modes,
18793                 .input_mux = &alc662_lenovo_101e_capture_source,
18794                 .unsol_event = alc662_lenovo_101e_unsol_event,
18795                 .init_hook = alc662_lenovo_101e_all_automute,
18796         },
18797         [ALC662_ASUS_EEEPC_P701] = {
18798                 .mixers = { alc662_eeepc_p701_mixer },
18799                 .init_verbs = { alc662_init_verbs,
18800                                 alc662_eeepc_sue_init_verbs },
18801                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18802                 .dac_nids = alc662_dac_nids,
18803                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18804                 .channel_mode = alc662_3ST_2ch_modes,
18805                 .unsol_event = alc662_eeepc_unsol_event,
18806                 .setup = alc662_eeepc_setup,
18807                 .init_hook = alc662_eeepc_inithook,
18808         },
18809         [ALC662_ASUS_EEEPC_EP20] = {
18810                 .mixers = { alc662_eeepc_ep20_mixer,
18811                             alc662_chmode_mixer },
18812                 .init_verbs = { alc662_init_verbs,
18813                                 alc662_eeepc_ep20_sue_init_verbs },
18814                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18815                 .dac_nids = alc662_dac_nids,
18816                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18817                 .channel_mode = alc662_3ST_6ch_modes,
18818                 .input_mux = &alc662_lenovo_101e_capture_source,
18819                 .unsol_event = alc662_eeepc_unsol_event,
18820                 .setup = alc662_eeepc_ep20_setup,
18821                 .init_hook = alc662_eeepc_ep20_inithook,
18822         },
18823         [ALC662_ECS] = {
18824                 .mixers = { alc662_ecs_mixer },
18825                 .init_verbs = { alc662_init_verbs,
18826                                 alc662_ecs_init_verbs },
18827                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18828                 .dac_nids = alc662_dac_nids,
18829                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18830                 .channel_mode = alc662_3ST_2ch_modes,
18831                 .unsol_event = alc662_eeepc_unsol_event,
18832                 .setup = alc662_eeepc_setup,
18833                 .init_hook = alc662_eeepc_inithook,
18834         },
18835         [ALC663_ASUS_M51VA] = {
18836                 .mixers = { alc663_m51va_mixer },
18837                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18838                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18839                 .dac_nids = alc662_dac_nids,
18840                 .dig_out_nid = ALC662_DIGOUT_NID,
18841                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18842                 .channel_mode = alc662_3ST_2ch_modes,
18843                 .unsol_event = alc663_m51va_unsol_event,
18844                 .setup = alc663_m51va_setup,
18845                 .init_hook = alc663_m51va_inithook,
18846         },
18847         [ALC663_ASUS_G71V] = {
18848                 .mixers = { alc663_g71v_mixer },
18849                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18850                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18851                 .dac_nids = alc662_dac_nids,
18852                 .dig_out_nid = ALC662_DIGOUT_NID,
18853                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18854                 .channel_mode = alc662_3ST_2ch_modes,
18855                 .unsol_event = alc663_g71v_unsol_event,
18856                 .setup = alc663_g71v_setup,
18857                 .init_hook = alc663_g71v_inithook,
18858         },
18859         [ALC663_ASUS_H13] = {
18860                 .mixers = { alc663_m51va_mixer },
18861                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18862                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18863                 .dac_nids = alc662_dac_nids,
18864                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18865                 .channel_mode = alc662_3ST_2ch_modes,
18866                 .unsol_event = alc663_m51va_unsol_event,
18867                 .init_hook = alc663_m51va_inithook,
18868         },
18869         [ALC663_ASUS_G50V] = {
18870                 .mixers = { alc663_g50v_mixer },
18871                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18872                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18873                 .dac_nids = alc662_dac_nids,
18874                 .dig_out_nid = ALC662_DIGOUT_NID,
18875                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18876                 .channel_mode = alc662_3ST_6ch_modes,
18877                 .input_mux = &alc663_capture_source,
18878                 .unsol_event = alc663_g50v_unsol_event,
18879                 .setup = alc663_g50v_setup,
18880                 .init_hook = alc663_g50v_inithook,
18881         },
18882         [ALC663_ASUS_MODE1] = {
18883                 .mixers = { alc663_m51va_mixer },
18884                 .cap_mixer = alc662_auto_capture_mixer,
18885                 .init_verbs = { alc662_init_verbs,
18886                                 alc663_21jd_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_mode1_unsol_event,
18894                 .setup = alc663_mode1_setup,
18895                 .init_hook = alc663_mode1_inithook,
18896         },
18897         [ALC662_ASUS_MODE2] = {
18898                 .mixers = { alc662_1bjd_mixer },
18899                 .cap_mixer = alc662_auto_capture_mixer,
18900                 .init_verbs = { alc662_init_verbs,
18901                                 alc662_1bjd_amic_init_verbs },
18902                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18903                 .dac_nids = alc662_dac_nids,
18904                 .dig_out_nid = ALC662_DIGOUT_NID,
18905                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18906                 .channel_mode = alc662_3ST_2ch_modes,
18907                 .unsol_event = alc662_mode2_unsol_event,
18908                 .setup = alc662_mode2_setup,
18909                 .init_hook = alc662_mode2_inithook,
18910         },
18911         [ALC663_ASUS_MODE3] = {
18912                 .mixers = { alc663_two_hp_m1_mixer },
18913                 .cap_mixer = alc662_auto_capture_mixer,
18914                 .init_verbs = { alc662_init_verbs,
18915                                 alc663_two_hp_amic_m1_init_verbs },
18916                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18917                 .hp_nid = 0x03,
18918                 .dac_nids = alc662_dac_nids,
18919                 .dig_out_nid = ALC662_DIGOUT_NID,
18920                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18921                 .channel_mode = alc662_3ST_2ch_modes,
18922                 .unsol_event = alc663_mode3_unsol_event,
18923                 .setup = alc663_mode3_setup,
18924                 .init_hook = alc663_mode3_inithook,
18925         },
18926         [ALC663_ASUS_MODE4] = {
18927                 .mixers = { alc663_asus_21jd_clfe_mixer },
18928                 .cap_mixer = alc662_auto_capture_mixer,
18929                 .init_verbs = { alc662_init_verbs,
18930                                 alc663_21jd_amic_init_verbs},
18931                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18932                 .hp_nid = 0x03,
18933                 .dac_nids = alc662_dac_nids,
18934                 .dig_out_nid = ALC662_DIGOUT_NID,
18935                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18936                 .channel_mode = alc662_3ST_2ch_modes,
18937                 .unsol_event = alc663_mode4_unsol_event,
18938                 .setup = alc663_mode4_setup,
18939                 .init_hook = alc663_mode4_inithook,
18940         },
18941         [ALC663_ASUS_MODE5] = {
18942                 .mixers = { alc663_asus_15jd_clfe_mixer },
18943                 .cap_mixer = alc662_auto_capture_mixer,
18944                 .init_verbs = { alc662_init_verbs,
18945                                 alc663_15jd_amic_init_verbs },
18946                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18947                 .hp_nid = 0x03,
18948                 .dac_nids = alc662_dac_nids,
18949                 .dig_out_nid = ALC662_DIGOUT_NID,
18950                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18951                 .channel_mode = alc662_3ST_2ch_modes,
18952                 .unsol_event = alc663_mode5_unsol_event,
18953                 .setup = alc663_mode5_setup,
18954                 .init_hook = alc663_mode5_inithook,
18955         },
18956         [ALC663_ASUS_MODE6] = {
18957                 .mixers = { alc663_two_hp_m2_mixer },
18958                 .cap_mixer = alc662_auto_capture_mixer,
18959                 .init_verbs = { alc662_init_verbs,
18960                                 alc663_two_hp_amic_m2_init_verbs },
18961                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18962                 .hp_nid = 0x03,
18963                 .dac_nids = alc662_dac_nids,
18964                 .dig_out_nid = ALC662_DIGOUT_NID,
18965                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18966                 .channel_mode = alc662_3ST_2ch_modes,
18967                 .unsol_event = alc663_mode6_unsol_event,
18968                 .setup = alc663_mode6_setup,
18969                 .init_hook = alc663_mode6_inithook,
18970         },
18971         [ALC663_ASUS_MODE7] = {
18972                 .mixers = { alc663_mode7_mixer },
18973                 .cap_mixer = alc662_auto_capture_mixer,
18974                 .init_verbs = { alc662_init_verbs,
18975                                 alc663_mode7_init_verbs },
18976                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18977                 .hp_nid = 0x03,
18978                 .dac_nids = alc662_dac_nids,
18979                 .dig_out_nid = ALC662_DIGOUT_NID,
18980                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18981                 .channel_mode = alc662_3ST_2ch_modes,
18982                 .unsol_event = alc663_mode7_unsol_event,
18983                 .setup = alc663_mode7_setup,
18984                 .init_hook = alc663_mode7_inithook,
18985         },
18986         [ALC663_ASUS_MODE8] = {
18987                 .mixers = { alc663_mode8_mixer },
18988                 .cap_mixer = alc662_auto_capture_mixer,
18989                 .init_verbs = { alc662_init_verbs,
18990                                 alc663_mode8_init_verbs },
18991                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18992                 .hp_nid = 0x03,
18993                 .dac_nids = alc662_dac_nids,
18994                 .dig_out_nid = ALC662_DIGOUT_NID,
18995                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18996                 .channel_mode = alc662_3ST_2ch_modes,
18997                 .unsol_event = alc663_mode8_unsol_event,
18998                 .setup = alc663_mode8_setup,
18999                 .init_hook = alc663_mode8_inithook,
19000         },
19001         [ALC272_DELL] = {
19002                 .mixers = { alc663_m51va_mixer },
19003                 .cap_mixer = alc272_auto_capture_mixer,
19004                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
19005                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19006                 .dac_nids = alc662_dac_nids,
19007                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19008                 .adc_nids = alc272_adc_nids,
19009                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
19010                 .capsrc_nids = alc272_capsrc_nids,
19011                 .channel_mode = alc662_3ST_2ch_modes,
19012                 .unsol_event = alc663_m51va_unsol_event,
19013                 .setup = alc663_m51va_setup,
19014                 .init_hook = alc663_m51va_inithook,
19015         },
19016         [ALC272_DELL_ZM1] = {
19017                 .mixers = { alc663_m51va_mixer },
19018                 .cap_mixer = alc662_auto_capture_mixer,
19019                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
19020                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19021                 .dac_nids = alc662_dac_nids,
19022                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19023                 .adc_nids = alc662_adc_nids,
19024                 .num_adc_nids = 1,
19025                 .capsrc_nids = alc662_capsrc_nids,
19026                 .channel_mode = alc662_3ST_2ch_modes,
19027                 .unsol_event = alc663_m51va_unsol_event,
19028                 .setup = alc663_m51va_setup,
19029                 .init_hook = alc663_m51va_inithook,
19030         },
19031         [ALC272_SAMSUNG_NC10] = {
19032                 .mixers = { alc272_nc10_mixer },
19033                 .init_verbs = { alc662_init_verbs,
19034                                 alc663_21jd_amic_init_verbs },
19035                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
19036                 .dac_nids = alc272_dac_nids,
19037                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19038                 .channel_mode = alc662_3ST_2ch_modes,
19039                 /*.input_mux = &alc272_nc10_capture_source,*/
19040                 .unsol_event = alc663_mode4_unsol_event,
19041                 .setup = alc663_mode4_setup,
19042                 .init_hook = alc663_mode4_inithook,
19043         },
19044 };
19045
19046
19047 /*
19048  * BIOS auto configuration
19049  */
19050
19051 /* convert from MIX nid to DAC */
19052 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
19053 {
19054         if (nid == 0x0f)
19055                 return 0x02;
19056         else if (nid >= 0x0c && nid <= 0x0e)
19057                 return nid - 0x0c + 0x02;
19058         else if (nid == 0x26) /* ALC887-VD has this DAC too */
19059                 return 0x25;
19060         else
19061                 return 0;
19062 }
19063
19064 /* get MIX nid connected to the given pin targeted to DAC */
19065 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19066                                    hda_nid_t dac)
19067 {
19068         hda_nid_t mix[5];
19069         int i, num;
19070
19071         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19072         for (i = 0; i < num; i++) {
19073                 if (alc662_mix_to_dac(mix[i]) == dac)
19074                         return mix[i];
19075         }
19076         return 0;
19077 }
19078
19079 /* look for an empty DAC slot */
19080 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19081 {
19082         struct alc_spec *spec = codec->spec;
19083         hda_nid_t srcs[5];
19084         int i, j, num;
19085
19086         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19087         if (num < 0)
19088                 return 0;
19089         for (i = 0; i < num; i++) {
19090                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19091                 if (!nid)
19092                         continue;
19093                 for (j = 0; j < spec->multiout.num_dacs; j++)
19094                         if (spec->multiout.dac_nids[j] == nid)
19095                                 break;
19096                 if (j >= spec->multiout.num_dacs)
19097                         return nid;
19098         }
19099         return 0;
19100 }
19101
19102 /* fill in the dac_nids table from the parsed pin configuration */
19103 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19104                                      const struct auto_pin_cfg *cfg)
19105 {
19106         struct alc_spec *spec = codec->spec;
19107         int i;
19108         hda_nid_t dac;
19109
19110         spec->multiout.dac_nids = spec->private_dac_nids;
19111         for (i = 0; i < cfg->line_outs; i++) {
19112                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19113                 if (!dac)
19114                         continue;
19115                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19116         }
19117         return 0;
19118 }
19119
19120 static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19121                                        hda_nid_t nid, int idx, unsigned int chs)
19122 {
19123         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
19124                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19125 }
19126
19127 static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19128                                       hda_nid_t nid, int idx, unsigned int chs)
19129 {
19130         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19131                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19132 }
19133
19134 #define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19135         __alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19136 #define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19137         __alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19138 #define alc662_add_stereo_vol(spec, pfx, nid) \
19139         alc662_add_vol_ctl(spec, pfx, nid, 3)
19140 #define alc662_add_stereo_sw(spec, pfx, nid) \
19141         alc662_add_sw_ctl(spec, pfx, nid, 3)
19142
19143 /* add playback controls from the parsed DAC table */
19144 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19145                                              const struct auto_pin_cfg *cfg)
19146 {
19147         struct alc_spec *spec = codec->spec;
19148         static const char *chname[4] = {
19149                 "Front", "Surround", NULL /*CLFE*/, "Side"
19150         };
19151         const char *pfx = alc_get_line_out_pfx(cfg, true);
19152         hda_nid_t nid, mix;
19153         int i, err;
19154
19155         for (i = 0; i < cfg->line_outs; i++) {
19156                 nid = spec->multiout.dac_nids[i];
19157                 if (!nid)
19158                         continue;
19159                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19160                 if (!mix)
19161                         continue;
19162                 if (!pfx && i == 2) {
19163                         /* Center/LFE */
19164                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19165                         if (err < 0)
19166                                 return err;
19167                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19168                         if (err < 0)
19169                                 return err;
19170                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19171                         if (err < 0)
19172                                 return err;
19173                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19174                         if (err < 0)
19175                                 return err;
19176                 } else {
19177                         const char *name = pfx;
19178                         if (!name)
19179                                 name = chname[i];
19180                         err = __alc662_add_vol_ctl(spec, name, nid, i, 3);
19181                         if (err < 0)
19182                                 return err;
19183                         err = __alc662_add_sw_ctl(spec, name, mix, i, 3);
19184                         if (err < 0)
19185                                 return err;
19186                 }
19187         }
19188         return 0;
19189 }
19190
19191 /* add playback controls for speaker and HP outputs */
19192 /* return DAC nid if any new DAC is assigned */
19193 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19194                                         const char *pfx)
19195 {
19196         struct alc_spec *spec = codec->spec;
19197         hda_nid_t nid, mix;
19198         int err;
19199
19200         if (!pin)
19201                 return 0;
19202         nid = alc662_look_for_dac(codec, pin);
19203         if (!nid) {
19204                 /* the corresponding DAC is already occupied */
19205                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19206                         return 0; /* no way */
19207                 /* create a switch only */
19208                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19209                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19210         }
19211
19212         mix = alc662_dac_to_mix(codec, pin, nid);
19213         if (!mix)
19214                 return 0;
19215         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19216         if (err < 0)
19217                 return err;
19218         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19219         if (err < 0)
19220                 return err;
19221         return nid;
19222 }
19223
19224 /* create playback/capture controls for input pins */
19225 #define alc662_auto_create_input_ctls \
19226         alc882_auto_create_input_ctls
19227
19228 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19229                                               hda_nid_t nid, int pin_type,
19230                                               hda_nid_t dac)
19231 {
19232         int i, num;
19233         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19234
19235         alc_set_pin_output(codec, nid, pin_type);
19236         /* need the manual connection? */
19237         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19238         if (num <= 1)
19239                 return;
19240         for (i = 0; i < num; i++) {
19241                 if (alc662_mix_to_dac(srcs[i]) != dac)
19242                         continue;
19243                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19244                 return;
19245         }
19246 }
19247
19248 static void alc662_auto_init_multi_out(struct hda_codec *codec)
19249 {
19250         struct alc_spec *spec = codec->spec;
19251         int pin_type = get_pin_type(spec->autocfg.line_out_type);
19252         int i;
19253
19254         for (i = 0; i <= HDA_SIDE; i++) {
19255                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
19256                 if (nid)
19257                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19258                                         spec->multiout.dac_nids[i]);
19259         }
19260 }
19261
19262 static void alc662_auto_init_hp_out(struct hda_codec *codec)
19263 {
19264         struct alc_spec *spec = codec->spec;
19265         hda_nid_t pin;
19266
19267         pin = spec->autocfg.hp_pins[0];
19268         if (pin)
19269                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19270                                                   spec->multiout.hp_nid);
19271         pin = spec->autocfg.speaker_pins[0];
19272         if (pin)
19273                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19274                                         spec->multiout.extra_out_nid[0]);
19275 }
19276
19277 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
19278
19279 static void alc662_auto_init_analog_input(struct hda_codec *codec)
19280 {
19281         struct alc_spec *spec = codec->spec;
19282         struct auto_pin_cfg *cfg = &spec->autocfg;
19283         int i;
19284
19285         for (i = 0; i < cfg->num_inputs; i++) {
19286                 hda_nid_t nid = cfg->inputs[i].pin;
19287                 if (alc_is_input_pin(codec, nid)) {
19288                         alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19289                         if (nid != ALC662_PIN_CD_NID &&
19290                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19291                                 snd_hda_codec_write(codec, nid, 0,
19292                                                     AC_VERB_SET_AMP_GAIN_MUTE,
19293                                                     AMP_OUT_MUTE);
19294                 }
19295         }
19296 }
19297
19298 #define alc662_auto_init_input_src      alc882_auto_init_input_src
19299
19300 static int alc662_parse_auto_config(struct hda_codec *codec)
19301 {
19302         struct alc_spec *spec = codec->spec;
19303         int err;
19304         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19305
19306         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19307                                            alc662_ignore);
19308         if (err < 0)
19309                 return err;
19310         if (!spec->autocfg.line_outs)
19311                 return 0; /* can't find valid BIOS pin config */
19312
19313         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19314         if (err < 0)
19315                 return err;
19316         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19317         if (err < 0)
19318                 return err;
19319         err = alc662_auto_create_extra_out(codec,
19320                                            spec->autocfg.speaker_pins[0],
19321                                            "Speaker");
19322         if (err < 0)
19323                 return err;
19324         if (err)
19325                 spec->multiout.extra_out_nid[0] = err;
19326         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19327                                            "Headphone");
19328         if (err < 0)
19329                 return err;
19330         if (err)
19331                 spec->multiout.hp_nid = err;
19332         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19333         if (err < 0)
19334                 return err;
19335
19336         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19337
19338         alc_auto_parse_digital(codec);
19339
19340         if (spec->kctls.list)
19341                 add_mixer(spec, spec->kctls.list);
19342
19343         spec->num_mux_defs = 1;
19344         spec->input_mux = &spec->private_imux[0];
19345
19346         add_verb(spec, alc662_init_verbs);
19347         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19348             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19349                 add_verb(spec, alc663_init_verbs);
19350
19351         if (codec->vendor_id == 0x10ec0272)
19352                 add_verb(spec, alc272_init_verbs);
19353
19354         err = alc_auto_add_mic_boost(codec);
19355         if (err < 0)
19356                 return err;
19357
19358         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19359             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19360             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19361         else
19362             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19363
19364         return 1;
19365 }
19366
19367 /* additional initialization for auto-configuration model */
19368 static void alc662_auto_init(struct hda_codec *codec)
19369 {
19370         struct alc_spec *spec = codec->spec;
19371         alc662_auto_init_multi_out(codec);
19372         alc662_auto_init_hp_out(codec);
19373         alc662_auto_init_analog_input(codec);
19374         alc662_auto_init_input_src(codec);
19375         alc_auto_init_digital(codec);
19376         if (spec->unsol_event)
19377                 alc_inithook(codec);
19378 }
19379
19380 static void alc272_fixup_mario(struct hda_codec *codec,
19381                                const struct alc_fixup *fix, int pre_init) {
19382         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19383                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19384                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19385                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19386                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
19387                 printk(KERN_WARNING
19388                        "hda_codec: failed to override amp caps for NID 0x2\n");
19389 }
19390
19391 enum {
19392         ALC662_FIXUP_ASPIRE,
19393         ALC662_FIXUP_IDEAPAD,
19394         ALC272_FIXUP_MARIO,
19395 };
19396
19397 static const struct alc_fixup alc662_fixups[] = {
19398         [ALC662_FIXUP_ASPIRE] = {
19399                 .pins = (const struct alc_pincfg[]) {
19400                         { 0x15, 0x99130112 }, /* subwoofer */
19401                         { }
19402                 }
19403         },
19404         [ALC662_FIXUP_IDEAPAD] = {
19405                 .pins = (const struct alc_pincfg[]) {
19406                         { 0x17, 0x99130112 }, /* subwoofer */
19407                         { }
19408                 }
19409         },
19410         [ALC272_FIXUP_MARIO] = {
19411                 .func = alc272_fixup_mario,
19412         }
19413 };
19414
19415 static struct snd_pci_quirk alc662_fixup_tbl[] = {
19416         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19417         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19418         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19419         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19420         {}
19421 };
19422
19423 static const struct alc_model_fixup alc662_fixup_models[] = {
19424         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
19425         {}
19426 };
19427
19428
19429 static int patch_alc662(struct hda_codec *codec)
19430 {
19431         struct alc_spec *spec;
19432         int err, board_config;
19433         int coef;
19434
19435         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19436         if (!spec)
19437                 return -ENOMEM;
19438
19439         codec->spec = spec;
19440
19441         alc_auto_parse_customize_define(codec);
19442
19443         alc_fix_pll_init(codec, 0x20, 0x04, 15);
19444
19445         coef = alc_read_coef_idx(codec, 0);
19446         if (coef == 0x8020 || coef == 0x8011)
19447                 alc_codec_rename(codec, "ALC661");
19448         else if (coef & (1 << 14) &&
19449                 codec->bus->pci->subsystem_vendor == 0x1025 &&
19450                 spec->cdefine.platform_type == 1)
19451                 alc_codec_rename(codec, "ALC272X");
19452         else if (coef == 0x4011)
19453                 alc_codec_rename(codec, "ALC656");
19454
19455         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19456                                                   alc662_models,
19457                                                   alc662_cfg_tbl);
19458         if (board_config < 0) {
19459                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19460                        codec->chip_name);
19461                 board_config = ALC662_AUTO;
19462         }
19463
19464         if (board_config == ALC662_AUTO) {
19465                 alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1);
19466                 /* automatic parse from the BIOS config */
19467                 err = alc662_parse_auto_config(codec);
19468                 if (err < 0) {
19469                         alc_free(codec);
19470                         return err;
19471                 } else if (!err) {
19472                         printk(KERN_INFO
19473                                "hda_codec: Cannot set up configuration "
19474                                "from BIOS.  Using base mode...\n");
19475                         board_config = ALC662_3ST_2ch_DIG;
19476                 }
19477         }
19478
19479         if (has_cdefine_beep(codec)) {
19480                 err = snd_hda_attach_beep_device(codec, 0x1);
19481                 if (err < 0) {
19482                         alc_free(codec);
19483                         return err;
19484                 }
19485         }
19486
19487         if (board_config != ALC662_AUTO)
19488                 setup_preset(codec, &alc662_presets[board_config]);
19489
19490         spec->stream_analog_playback = &alc662_pcm_analog_playback;
19491         spec->stream_analog_capture = &alc662_pcm_analog_capture;
19492
19493         spec->stream_digital_playback = &alc662_pcm_digital_playback;
19494         spec->stream_digital_capture = &alc662_pcm_digital_capture;
19495
19496         if (!spec->adc_nids) {
19497                 spec->adc_nids = alc662_adc_nids;
19498                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19499         }
19500         if (!spec->capsrc_nids)
19501                 spec->capsrc_nids = alc662_capsrc_nids;
19502
19503         if (!spec->cap_mixer)
19504                 set_capture_mixer(codec);
19505
19506         if (has_cdefine_beep(codec)) {
19507                 switch (codec->vendor_id) {
19508                 case 0x10ec0662:
19509                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19510                         break;
19511                 case 0x10ec0272:
19512                 case 0x10ec0663:
19513                 case 0x10ec0665:
19514                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19515                         break;
19516                 case 0x10ec0273:
19517                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19518                         break;
19519                 }
19520         }
19521         spec->vmaster_nid = 0x02;
19522
19523         codec->patch_ops = alc_patch_ops;
19524         if (board_config == ALC662_AUTO) {
19525                 spec->init_hook = alc662_auto_init;
19526                 alc_pick_fixup_model(codec, alc662_fixup_models,
19527                                      alc662_fixup_tbl, alc662_fixups, 0);
19528         }
19529
19530         alc_init_jacks(codec);
19531
19532 #ifdef CONFIG_SND_HDA_POWER_SAVE
19533         if (!spec->loopback.amplist)
19534                 spec->loopback.amplist = alc662_loopbacks;
19535 #endif
19536
19537         return 0;
19538 }
19539
19540 static int patch_alc888(struct hda_codec *codec)
19541 {
19542         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19543                 kfree(codec->chip_name);
19544                 if (codec->vendor_id == 0x10ec0887)
19545                         codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19546                 else
19547                         codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19548                 if (!codec->chip_name) {
19549                         alc_free(codec);
19550                         return -ENOMEM;
19551                 }
19552                 return patch_alc662(codec);
19553         }
19554         return patch_alc882(codec);
19555 }
19556
19557 /*
19558  * ALC680 support
19559  */
19560 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19561 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19562 #define alc680_modes            alc260_modes
19563
19564 static hda_nid_t alc680_dac_nids[3] = {
19565         /* Lout1, Lout2, hp */
19566         0x02, 0x03, 0x04
19567 };
19568
19569 static hda_nid_t alc680_adc_nids[3] = {
19570         /* ADC0-2 */
19571         /* DMIC, MIC, Line-in*/
19572         0x07, 0x08, 0x09
19573 };
19574
19575 /*
19576  * Analog capture ADC cgange
19577  */
19578 static void alc680_rec_autoswitch(struct hda_codec *codec)
19579 {
19580         struct alc_spec *spec = codec->spec;
19581         struct auto_pin_cfg *cfg = &spec->autocfg;
19582         int pin_found = 0;
19583         int type_found = AUTO_PIN_LAST;
19584         hda_nid_t nid;
19585         int i;
19586
19587         for (i = 0; i < cfg->num_inputs; i++) {
19588                 nid = cfg->inputs[i].pin;
19589                 if (!(snd_hda_query_pin_caps(codec, nid) &
19590                       AC_PINCAP_PRES_DETECT))
19591                         continue;
19592                 if (snd_hda_jack_detect(codec, nid)) {
19593                         if (cfg->inputs[i].type < type_found) {
19594                                 type_found = cfg->inputs[i].type;
19595                                 pin_found = nid;
19596                         }
19597                 }
19598         }
19599
19600         nid = 0x07;
19601         if (pin_found)
19602                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19603
19604         if (nid != spec->cur_adc)
19605                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19606         spec->cur_adc = nid;
19607         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19608                                    spec->cur_adc_format);
19609 }
19610
19611 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19612                                       struct hda_codec *codec,
19613                                       unsigned int stream_tag,
19614                                       unsigned int format,
19615                                       struct snd_pcm_substream *substream)
19616 {
19617         struct alc_spec *spec = codec->spec;
19618
19619         spec->cur_adc = 0x07;
19620         spec->cur_adc_stream_tag = stream_tag;
19621         spec->cur_adc_format = format;
19622
19623         alc680_rec_autoswitch(codec);
19624         return 0;
19625 }
19626
19627 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19628                                       struct hda_codec *codec,
19629                                       struct snd_pcm_substream *substream)
19630 {
19631         snd_hda_codec_cleanup_stream(codec, 0x07);
19632         snd_hda_codec_cleanup_stream(codec, 0x08);
19633         snd_hda_codec_cleanup_stream(codec, 0x09);
19634         return 0;
19635 }
19636
19637 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19638         .substreams = 1, /* can be overridden */
19639         .channels_min = 2,
19640         .channels_max = 2,
19641         /* NID is set in alc_build_pcms */
19642         .ops = {
19643                 .prepare = alc680_capture_pcm_prepare,
19644                 .cleanup = alc680_capture_pcm_cleanup
19645         },
19646 };
19647
19648 static struct snd_kcontrol_new alc680_base_mixer[] = {
19649         /* output mixer control */
19650         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19651         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19652         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19653         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19654         HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19655         HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19656         HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19657         { }
19658 };
19659
19660 static struct hda_bind_ctls alc680_bind_cap_vol = {
19661         .ops = &snd_hda_bind_vol,
19662         .values = {
19663                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19664                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19665                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19666                 0
19667         },
19668 };
19669
19670 static struct hda_bind_ctls alc680_bind_cap_switch = {
19671         .ops = &snd_hda_bind_sw,
19672         .values = {
19673                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19674                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19675                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19676                 0
19677         },
19678 };
19679
19680 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19681         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19682         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19683         { } /* end */
19684 };
19685
19686 /*
19687  * generic initialization of ADC, input mixers and output mixers
19688  */
19689 static struct hda_verb alc680_init_verbs[] = {
19690         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19691         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19692         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19693
19694         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19695         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19696         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19697         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19698         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19699         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19700
19701         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19702         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19703         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19704         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19705         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19706
19707         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19708         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19709         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19710
19711         { }
19712 };
19713
19714 /* toggle speaker-output according to the hp-jack state */
19715 static void alc680_base_setup(struct hda_codec *codec)
19716 {
19717         struct alc_spec *spec = codec->spec;
19718
19719         spec->autocfg.hp_pins[0] = 0x16;
19720         spec->autocfg.speaker_pins[0] = 0x14;
19721         spec->autocfg.speaker_pins[1] = 0x15;
19722         spec->autocfg.num_inputs = 2;
19723         spec->autocfg.inputs[0].pin = 0x18;
19724         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19725         spec->autocfg.inputs[1].pin = 0x19;
19726         spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19727 }
19728
19729 static void alc680_unsol_event(struct hda_codec *codec,
19730                                            unsigned int res)
19731 {
19732         if ((res >> 26) == ALC880_HP_EVENT)
19733                 alc_automute_amp(codec);
19734         if ((res >> 26) == ALC880_MIC_EVENT)
19735                 alc680_rec_autoswitch(codec);
19736 }
19737
19738 static void alc680_inithook(struct hda_codec *codec)
19739 {
19740         alc_automute_amp(codec);
19741         alc680_rec_autoswitch(codec);
19742 }
19743
19744 /* create input playback/capture controls for the given pin */
19745 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19746                                     const char *ctlname, int idx)
19747 {
19748         hda_nid_t dac;
19749         int err;
19750
19751         switch (nid) {
19752         case 0x14:
19753                 dac = 0x02;
19754                 break;
19755         case 0x15:
19756                 dac = 0x03;
19757                 break;
19758         case 0x16:
19759                 dac = 0x04;
19760                 break;
19761         default:
19762                 return 0;
19763         }
19764         if (spec->multiout.dac_nids[0] != dac &&
19765             spec->multiout.dac_nids[1] != dac) {
19766                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19767                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19768                                                       HDA_OUTPUT));
19769                 if (err < 0)
19770                         return err;
19771
19772                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19773                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19774
19775                 if (err < 0)
19776                         return err;
19777                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19778         }
19779
19780         return 0;
19781 }
19782
19783 /* add playback controls from the parsed DAC table */
19784 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19785                                              const struct auto_pin_cfg *cfg)
19786 {
19787         hda_nid_t nid;
19788         int err;
19789
19790         spec->multiout.dac_nids = spec->private_dac_nids;
19791
19792         nid = cfg->line_out_pins[0];
19793         if (nid) {
19794                 const char *name;
19795                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19796                         name = "Speaker";
19797                 else
19798                         name = "Front";
19799                 err = alc680_new_analog_output(spec, nid, name, 0);
19800                 if (err < 0)
19801                         return err;
19802         }
19803
19804         nid = cfg->speaker_pins[0];
19805         if (nid) {
19806                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19807                 if (err < 0)
19808                         return err;
19809         }
19810         nid = cfg->hp_pins[0];
19811         if (nid) {
19812                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19813                 if (err < 0)
19814                         return err;
19815         }
19816
19817         return 0;
19818 }
19819
19820 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19821                                               hda_nid_t nid, int pin_type)
19822 {
19823         alc_set_pin_output(codec, nid, pin_type);
19824 }
19825
19826 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19827 {
19828         struct alc_spec *spec = codec->spec;
19829         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19830         if (nid) {
19831                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19832                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19833         }
19834 }
19835
19836 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19837 {
19838         struct alc_spec *spec = codec->spec;
19839         hda_nid_t pin;
19840
19841         pin = spec->autocfg.hp_pins[0];
19842         if (pin)
19843                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19844         pin = spec->autocfg.speaker_pins[0];
19845         if (pin)
19846                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19847 }
19848
19849 /* pcm configuration: identical with ALC880 */
19850 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19851 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19852 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19853 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19854 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19855
19856 /*
19857  * BIOS auto configuration
19858  */
19859 static int alc680_parse_auto_config(struct hda_codec *codec)
19860 {
19861         struct alc_spec *spec = codec->spec;
19862         int err;
19863         static hda_nid_t alc680_ignore[] = { 0 };
19864
19865         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19866                                            alc680_ignore);
19867         if (err < 0)
19868                 return err;
19869
19870         if (!spec->autocfg.line_outs) {
19871                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19872                         spec->multiout.max_channels = 2;
19873                         spec->no_analog = 1;
19874                         goto dig_only;
19875                 }
19876                 return 0; /* can't find valid BIOS pin config */
19877         }
19878         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19879         if (err < 0)
19880                 return err;
19881
19882         spec->multiout.max_channels = 2;
19883
19884  dig_only:
19885         /* digital only support output */
19886         alc_auto_parse_digital(codec);
19887         if (spec->kctls.list)
19888                 add_mixer(spec, spec->kctls.list);
19889
19890         add_verb(spec, alc680_init_verbs);
19891
19892         err = alc_auto_add_mic_boost(codec);
19893         if (err < 0)
19894                 return err;
19895
19896         return 1;
19897 }
19898
19899 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19900
19901 /* init callback for auto-configuration model -- overriding the default init */
19902 static void alc680_auto_init(struct hda_codec *codec)
19903 {
19904         struct alc_spec *spec = codec->spec;
19905         alc680_auto_init_multi_out(codec);
19906         alc680_auto_init_hp_out(codec);
19907         alc680_auto_init_analog_input(codec);
19908         alc_auto_init_digital(codec);
19909         if (spec->unsol_event)
19910                 alc_inithook(codec);
19911 }
19912
19913 /*
19914  * configuration and preset
19915  */
19916 static const char *alc680_models[ALC680_MODEL_LAST] = {
19917         [ALC680_BASE]           = "base",
19918         [ALC680_AUTO]           = "auto",
19919 };
19920
19921 static struct snd_pci_quirk alc680_cfg_tbl[] = {
19922         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19923         {}
19924 };
19925
19926 static struct alc_config_preset alc680_presets[] = {
19927         [ALC680_BASE] = {
19928                 .mixers = { alc680_base_mixer },
19929                 .cap_mixer =  alc680_master_capture_mixer,
19930                 .init_verbs = { alc680_init_verbs },
19931                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
19932                 .dac_nids = alc680_dac_nids,
19933                 .dig_out_nid = ALC680_DIGOUT_NID,
19934                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
19935                 .channel_mode = alc680_modes,
19936                 .unsol_event = alc680_unsol_event,
19937                 .setup = alc680_base_setup,
19938                 .init_hook = alc680_inithook,
19939
19940         },
19941 };
19942
19943 static int patch_alc680(struct hda_codec *codec)
19944 {
19945         struct alc_spec *spec;
19946         int board_config;
19947         int err;
19948
19949         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19950         if (spec == NULL)
19951                 return -ENOMEM;
19952
19953         codec->spec = spec;
19954
19955         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19956                                                   alc680_models,
19957                                                   alc680_cfg_tbl);
19958
19959         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19960                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19961                        codec->chip_name);
19962                 board_config = ALC680_AUTO;
19963         }
19964
19965         if (board_config == ALC680_AUTO) {
19966                 /* automatic parse from the BIOS config */
19967                 err = alc680_parse_auto_config(codec);
19968                 if (err < 0) {
19969                         alc_free(codec);
19970                         return err;
19971                 } else if (!err) {
19972                         printk(KERN_INFO
19973                                "hda_codec: Cannot set up configuration "
19974                                "from BIOS.  Using base mode...\n");
19975                         board_config = ALC680_BASE;
19976                 }
19977         }
19978
19979         if (board_config != ALC680_AUTO)
19980                 setup_preset(codec, &alc680_presets[board_config]);
19981
19982         spec->stream_analog_playback = &alc680_pcm_analog_playback;
19983         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19984         spec->stream_digital_playback = &alc680_pcm_digital_playback;
19985         spec->stream_digital_capture = &alc680_pcm_digital_capture;
19986
19987         if (!spec->adc_nids) {
19988                 spec->adc_nids = alc680_adc_nids;
19989                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19990         }
19991
19992         if (!spec->cap_mixer)
19993                 set_capture_mixer(codec);
19994
19995         spec->vmaster_nid = 0x02;
19996
19997         codec->patch_ops = alc_patch_ops;
19998         if (board_config == ALC680_AUTO)
19999                 spec->init_hook = alc680_auto_init;
20000
20001         return 0;
20002 }
20003
20004 /*
20005  * patch entries
20006  */
20007 static struct hda_codec_preset snd_hda_preset_realtek[] = {
20008         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20009         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20010         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20011         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20012         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20013         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20014         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20015         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20016         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20017           .patch = patch_alc861 },
20018         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20019         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20020         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20021         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20022           .patch = patch_alc882 },
20023         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20024           .patch = patch_alc662 },
20025         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20026         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20027         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20028         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20029         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20030         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20031         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20032         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20033           .patch = patch_alc882 },
20034         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20035           .patch = patch_alc882 },
20036         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20037         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20038         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20039           .patch = patch_alc882 },
20040         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20041         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20042         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20043         {} /* terminator */
20044 };
20045
20046 MODULE_ALIAS("snd-hda-codec-id:10ec*");
20047
20048 MODULE_LICENSE("GPL");
20049 MODULE_DESCRIPTION("Realtek HD-audio codec");
20050
20051 static struct hda_codec_preset_list realtek_list = {
20052         .preset = snd_hda_preset_realtek,
20053         .owner = THIS_MODULE,
20054 };
20055
20056 static int __init patch_realtek_init(void)
20057 {
20058         return snd_hda_add_codec_preset(&realtek_list);
20059 }
20060
20061 static void __exit patch_realtek_exit(void)
20062 {
20063         snd_hda_delete_codec_preset(&realtek_list);
20064 }
20065
20066 module_init(patch_realtek_init)
20067 module_exit(patch_realtek_exit)