SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_AMIC,
 135         ALC269_DMIC,
 136         ALC269VB_AMIC,
 137         ALC269VB_DMIC,
 138         ALC269_FUJITSU,
 139         ALC269_LIFEBOOK,
 140         ALC269_AUTO,
 141         ALC269_MODEL_LAST /* last tag */
 142 };
 143
 144 /* ALC861 models */
 145 enum {
 146         ALC861_3ST,
 147         ALC660_3ST,
 148         ALC861_3ST_DIG,
 149         ALC861_6ST_DIG,
 150         ALC861_UNIWILL_M31,
 151         ALC861_TOSHIBA,
 152         ALC861_ASUS,
 153         ALC861_ASUS_LAPTOP,
 154         ALC861_AUTO,
 155         ALC861_MODEL_LAST,
 156 };
 157
 158 /* ALC861-VD models */
 159 enum {
 160         ALC660VD_3ST,
 161         ALC660VD_3ST_DIG,
 162         ALC660VD_ASUS_V1S,
 163         ALC861VD_3ST,
 164         ALC861VD_3ST_DIG,
 165         ALC861VD_6ST_DIG,
 166         ALC861VD_LENOVO,
 167         ALC861VD_DALLAS,
 168         ALC861VD_HP,
 169         ALC861VD_AUTO,
 170         ALC861VD_MODEL_LAST,
 171 };
 172
 173 /* ALC662 models */
 174 enum {
 175         ALC662_3ST_2ch_DIG,
 176         ALC662_3ST_6ch_DIG,
 177         ALC662_3ST_6ch,
 178         ALC662_5ST_DIG,
 179         ALC662_LENOVO_101E,
 180         ALC662_ASUS_EEEPC_P701,
 181         ALC662_ASUS_EEEPC_EP20,
 182         ALC663_ASUS_M51VA,
 183         ALC663_ASUS_G71V,
 184         ALC663_ASUS_H13,
 185         ALC663_ASUS_G50V,
 186         ALC662_ECS,
 187         ALC663_ASUS_MODE1,
 188         ALC662_ASUS_MODE2,
 189         ALC663_ASUS_MODE3,
 190         ALC663_ASUS_MODE4,
 191         ALC663_ASUS_MODE5,
 192         ALC663_ASUS_MODE6,
 193         ALC663_ASUS_MODE7,
 194         ALC663_ASUS_MODE8,
 195         ALC272_DELL,
 196         ALC272_DELL_ZM1,
 197         ALC272_SAMSUNG_NC10,
 198         ALC662_AUTO,
 199         ALC662_MODEL_LAST,
 200 };
 201
 202 /* ALC882 models */
 203 enum {
 204         ALC882_3ST_DIG,
 205         ALC882_6ST_DIG,
 206         ALC882_ARIMA,
 207         ALC882_W2JC,
 208         ALC882_TARGA,
 209         ALC882_ASUS_A7J,
 210         ALC882_ASUS_A7M,
 211         ALC885_MACPRO,
 212         ALC885_MBA21,
 213         ALC885_MBP3,
 214         ALC885_MB5,
 215         ALC885_MACMINI3,
 216         ALC885_IMAC24,
 217         ALC885_IMAC91,
 218         ALC883_3ST_2ch_DIG,
 219         ALC883_3ST_6ch_DIG,
 220         ALC883_3ST_6ch,
 221         ALC883_6ST_DIG,
 222         ALC883_TARGA_DIG,
 223         ALC883_TARGA_2ch_DIG,
 224         ALC883_TARGA_8ch_DIG,
 225         ALC883_ACER,
 226         ALC883_ACER_ASPIRE,
 227         ALC888_ACER_ASPIRE_4930G,
 228         ALC888_ACER_ASPIRE_6530G,
 229         ALC888_ACER_ASPIRE_8930G,
 230         ALC888_ACER_ASPIRE_7730G,
 231         ALC883_MEDION,
 232         ALC883_MEDION_MD2,
 233         ALC883_LAPTOP_EAPD,
 234         ALC883_LENOVO_101E_2ch,
 235         ALC883_LENOVO_NB0763,
 236         ALC888_LENOVO_MS7195_DIG,
 237         ALC888_LENOVO_SKY,
 238         ALC883_HAIER_W66,
 239         ALC888_3ST_HP,
 240         ALC888_6ST_DELL,
 241         ALC883_MITAC,
 242         ALC883_CLEVO_M540R,
 243         ALC883_CLEVO_M720,
 244         ALC883_FUJITSU_PI2515,
 245         ALC888_FUJITSU_XA3530,
 246         ALC883_3ST_6ch_INTEL,
 247         ALC889A_INTEL,
 248         ALC889_INTEL,
 249         ALC888_ASUS_M90V,
 250         ALC888_ASUS_EEE1601,
 251         ALC889A_MB31,
 252         ALC1200_ASUS_P5Q,
 253         ALC883_SONY_VAIO_TT,
 254         ALC882_AUTO,
 255         ALC882_MODEL_LAST,
 256 };
 257
 258 /* for GPIO Poll */
 259 #define GPIO_MASK       0x03
 260
 261 /* extra amp-initialization sequence types */
 262 enum {
 263         ALC_INIT_NONE,
 264         ALC_INIT_DEFAULT,
 265         ALC_INIT_GPIO1,
 266         ALC_INIT_GPIO2,
 267         ALC_INIT_GPIO3,
 268 };
 269
 270 struct alc_mic_route {
 271         hda_nid_t pin;
 272         unsigned char mux_idx;
 273         unsigned char amix_idx;
 274 };
 275
 276 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 277
 278 struct alc_spec {
 279         /* codec parameterization */
 280         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 281         unsigned int num_mixers;
 282         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 283         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 284
 285         const struct hda_verb *init_verbs[10];  /* initialization verbs
 286                                                  * don't forget NULL
 287                                                  * termination!
 288                                                  */
 289         unsigned int num_init_verbs;
 290
 291         char stream_name_analog[32];    /* analog PCM stream */
 292         struct hda_pcm_stream *stream_analog_playback;
 293         struct hda_pcm_stream *stream_analog_capture;
 294         struct hda_pcm_stream *stream_analog_alt_playback;
 295         struct hda_pcm_stream *stream_analog_alt_capture;
 296
 297         char stream_name_digital[32];   /* digital PCM stream */
 298         struct hda_pcm_stream *stream_digital_playback;
 299         struct hda_pcm_stream *stream_digital_capture;
 300
 301         /* playback */
 302         struct hda_multi_out multiout;  /* playback set-up
 303                                          * max_channels, dacs must be set
 304                                          * dig_out_nid and hp_nid are optional
 305                                          */
 306         hda_nid_t alt_dac_nid;
 307         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 308         int dig_out_type;
 309
 310         /* capture */
 311         unsigned int num_adc_nids;
 312         hda_nid_t *adc_nids;
 313         hda_nid_t *capsrc_nids;
 314         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 315
 316         /* capture source */
 317         unsigned int num_mux_defs;
 318         const struct hda_input_mux *input_mux;
 319         unsigned int cur_mux[3];
 320         struct alc_mic_route ext_mic;
 321         struct alc_mic_route int_mic;
 322
 323         /* channel model */
 324         const struct hda_channel_mode *channel_mode;
 325         int num_channel_mode;
 326         int need_dac_fix;
 327         int const_channel_count;
 328         int ext_channel_count;
 329
 330         /* PCM information */
 331         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 332
 333         /* dynamic controls, init_verbs and input_mux */
 334         struct auto_pin_cfg autocfg;
 335         struct snd_array kctls;
 336         struct hda_input_mux private_imux[3];
 337         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 338         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 339         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 340
 341         /* hooks */
 342         void (*init_hook)(struct hda_codec *codec);
 343         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 344 #ifdef CONFIG_SND_HDA_POWER_SAVE
 345         void (*power_hook)(struct hda_codec *codec);
 346 #endif
 347
 348         /* for pin sensing */
 349         unsigned int sense_updated: 1;
 350         unsigned int jack_present: 1;
 351         unsigned int master_sw: 1;
 352         unsigned int auto_mic:1;
 353
 354         /* other flags */
 355         unsigned int no_analog :1; /* digital I/O only */
 356         int init_amp;
 357
 358         /* for virtual master */
 359         hda_nid_t vmaster_nid;
 360 #ifdef CONFIG_SND_HDA_POWER_SAVE
 361         struct hda_loopback_check loopback;
 362 #endif
 363
 364         /* for PLL fix */
 365         hda_nid_t pll_nid;
 366         unsigned int pll_coef_idx, pll_coef_bit;
 367 };
 368
 369 /*
 370  * configuration template - to be copied to the spec instance
 371  */
 372 struct alc_config_preset {
 373         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 374                                              * with spec
 375                                              */
 376         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 377         const struct hda_verb *init_verbs[5];
 378         unsigned int num_dacs;
 379         hda_nid_t *dac_nids;
 380         hda_nid_t dig_out_nid;          /* optional */
 381         hda_nid_t hp_nid;               /* optional */
 382         hda_nid_t *slave_dig_outs;
 383         unsigned int num_adc_nids;
 384         hda_nid_t *adc_nids;
 385         hda_nid_t *capsrc_nids;
 386         hda_nid_t dig_in_nid;
 387         unsigned int num_channel_mode;
 388         const struct hda_channel_mode *channel_mode;
 389         int need_dac_fix;
 390         int const_channel_count;
 391         unsigned int num_mux_defs;
 392         const struct hda_input_mux *input_mux;
 393         void (*unsol_event)(struct hda_codec *, unsigned int);
 394         void (*setup)(struct hda_codec *);
 395         void (*init_hook)(struct hda_codec *);
 396 #ifdef CONFIG_SND_HDA_POWER_SAVE
 397         struct hda_amp_list *loopbacks;
 398         void (*power_hook)(struct hda_codec *codec);
 399 #endif
 400 };
 401
 402
 403 /*
 404  * input MUX handling
 405  */
 406 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 407                              struct snd_ctl_elem_info *uinfo)
 408 {
 409         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 410         struct alc_spec *spec = codec->spec;
 411         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 412         if (mux_idx >= spec->num_mux_defs)
 413                 mux_idx = 0;
 414         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 415                 mux_idx = 0;
 416         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 417 }
 418
 419 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 420                             struct snd_ctl_elem_value *ucontrol)
 421 {
 422         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 423         struct alc_spec *spec = codec->spec;
 424         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 425
 426         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 427         return 0;
 428 }
 429
 430 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 431                             struct snd_ctl_elem_value *ucontrol)
 432 {
 433         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 434         struct alc_spec *spec = codec->spec;
 435         const struct hda_input_mux *imux;
 436         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 437         unsigned int mux_idx;
 438         hda_nid_t nid = spec->capsrc_nids ?
 439                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 440         unsigned int type;
 441
 442         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 443         imux = &spec->input_mux[mux_idx];
 444         if (!imux->num_items && mux_idx > 0)
 445                 imux = &spec->input_mux[0];
 446
 447         type = get_wcaps_type(get_wcaps(codec, nid));
 448         if (type == AC_WID_AUD_MIX) {
 449                 /* Matrix-mixer style (e.g. ALC882) */
 450                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 451                 unsigned int i, idx;
 452
 453                 idx = ucontrol->value.enumerated.item[0];
 454                 if (idx >= imux->num_items)
 455                         idx = imux->num_items - 1;
 456                 if (*cur_val == idx)
 457                         return 0;
 458                 for (i = 0; i < imux->num_items; i++) {
 459                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 460                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 461                                                  imux->items[i].index,
 462                                                  HDA_AMP_MUTE, v);
 463                 }
 464                 *cur_val = idx;
 465                 return 1;
 466         } else {
 467                 /* MUX style (e.g. ALC880) */
 468                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 469                                              &spec->cur_mux[adc_idx]);
 470         }
 471 }
 472
 473 /*
 474  * channel mode setting
 475  */
 476 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 477                             struct snd_ctl_elem_info *uinfo)
 478 {
 479         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 480         struct alc_spec *spec = codec->spec;
 481         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 482                                     spec->num_channel_mode);
 483 }
 484
 485 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 486                            struct snd_ctl_elem_value *ucontrol)
 487 {
 488         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 489         struct alc_spec *spec = codec->spec;
 490         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 491                                    spec->num_channel_mode,
 492                                    spec->ext_channel_count);
 493 }
 494
 495 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 496                            struct snd_ctl_elem_value *ucontrol)
 497 {
 498         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 499         struct alc_spec *spec = codec->spec;
 500         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 501                                       spec->num_channel_mode,
 502                                       &spec->ext_channel_count);
 503         if (err >= 0 && !spec->const_channel_count) {
 504                 spec->multiout.max_channels = spec->ext_channel_count;
 505                 if (spec->need_dac_fix)
 506                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 507         }
 508         return err;
 509 }
 510
 511 /*
 512  * Control the mode of pin widget settings via the mixer.  "pc" is used
 513  * instead of "%" to avoid consequences of accidently treating the % as
 514  * being part of a format specifier.  Maximum allowed length of a value is
 515  * 63 characters plus NULL terminator.
 516  *
 517  * Note: some retasking pin complexes seem to ignore requests for input
 518  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 519  * are requested.  Therefore order this list so that this behaviour will not
 520  * cause problems when mixer clients move through the enum sequentially.
 521  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 522  * March 2006.
 523  */
 524 static char *alc_pin_mode_names[] = {
 525         "Mic 50pc bias", "Mic 80pc bias",
 526         "Line in", "Line out", "Headphone out",
 527 };
 528 static unsigned char alc_pin_mode_values[] = {
 529         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 530 };
 531 /* The control can present all 5 options, or it can limit the options based
 532  * in the pin being assumed to be exclusively an input or an output pin.  In
 533  * addition, "input" pins may or may not process the mic bias option
 534  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 535  * accept requests for bias as of chip versions up to March 2006) and/or
 536  * wiring in the computer.
 537  */
 538 #define ALC_PIN_DIR_IN              0x00
 539 #define ALC_PIN_DIR_OUT             0x01
 540 #define ALC_PIN_DIR_INOUT           0x02
 541 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 542 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 543
 544 /* Info about the pin modes supported by the different pin direction modes.
 545  * For each direction the minimum and maximum values are given.
 546  */
 547 static signed char alc_pin_mode_dir_info[5][2] = {
 548         { 0, 2 },    /* ALC_PIN_DIR_IN */
 549         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 550         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 551         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 552         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 553 };
 554 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 555 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 556 #define alc_pin_mode_n_items(_dir) \
 557         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 558
 559 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 560                              struct snd_ctl_elem_info *uinfo)
 561 {
 562         unsigned int item_num = uinfo->value.enumerated.item;
 563         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 564
 565         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 566         uinfo->count = 1;
 567         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 568
 569         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 570                 item_num = alc_pin_mode_min(dir);
 571         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 572         return 0;
 573 }
 574
 575 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 576                             struct snd_ctl_elem_value *ucontrol)
 577 {
 578         unsigned int i;
 579         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 580         hda_nid_t nid = kcontrol->private_value & 0xffff;
 581         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 582         long *valp = ucontrol->value.integer.value;
 583         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 584                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 585                                                  0x00);
 586
 587         /* Find enumerated value for current pinctl setting */
 588         i = alc_pin_mode_min(dir);
 589         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 590                 i++;
 591         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 592         return 0;
 593 }
 594
 595 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 596                             struct snd_ctl_elem_value *ucontrol)
 597 {
 598         signed int change;
 599         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 600         hda_nid_t nid = kcontrol->private_value & 0xffff;
 601         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 602         long val = *ucontrol->value.integer.value;
 603         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 604                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 605                                                  0x00);
 606
 607         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 608                 val = alc_pin_mode_min(dir);
 609
 610         change = pinctl != alc_pin_mode_values[val];
 611         if (change) {
 612                 /* Set pin mode to that requested */
 613                 snd_hda_codec_write_cache(codec, nid, 0,
 614                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 615                                           alc_pin_mode_values[val]);
 616
 617                 /* Also enable the retasking pin's input/output as required
 618                  * for the requested pin mode.  Enum values of 2 or less are
 619                  * input modes.
 620                  *
 621                  * Dynamically switching the input/output buffers probably
 622                  * reduces noise slightly (particularly on input) so we'll
 623                  * do it.  However, having both input and output buffers
 624                  * enabled simultaneously doesn't seem to be problematic if
 625                  * this turns out to be necessary in the future.
 626                  */
 627                 if (val <= 2) {
 628                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 629                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 630                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 631                                                  HDA_AMP_MUTE, 0);
 632                 } else {
 633                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 634                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 635                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 636                                                  HDA_AMP_MUTE, 0);
 637                 }
 638         }
 639         return change;
 640 }
 641
 642 #define ALC_PIN_MODE(xname, nid, dir) \
 643         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 644           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 645           .info = alc_pin_mode_info, \
 646           .get = alc_pin_mode_get, \
 647           .put = alc_pin_mode_put, \
 648           .private_value = nid | (dir<<16) }
 649
 650 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 651  * together using a mask with more than one bit set.  This control is
 652  * currently used only by the ALC260 test model.  At this stage they are not
 653  * needed for any "production" models.
 654  */
 655 #ifdef CONFIG_SND_DEBUG
 656 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 657
 658 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 659                              struct snd_ctl_elem_value *ucontrol)
 660 {
 661         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 662         hda_nid_t nid = kcontrol->private_value & 0xffff;
 663         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 664         long *valp = ucontrol->value.integer.value;
 665         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 666                                               AC_VERB_GET_GPIO_DATA, 0x00);
 667
 668         *valp = (val & mask) != 0;
 669         return 0;
 670 }
 671 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 672                              struct snd_ctl_elem_value *ucontrol)
 673 {
 674         signed int change;
 675         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 676         hda_nid_t nid = kcontrol->private_value & 0xffff;
 677         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 678         long val = *ucontrol->value.integer.value;
 679         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 680                                                     AC_VERB_GET_GPIO_DATA,
 681                                                     0x00);
 682
 683         /* Set/unset the masked GPIO bit(s) as needed */
 684         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 685         if (val == 0)
 686                 gpio_data &= ~mask;
 687         else
 688                 gpio_data |= mask;
 689         snd_hda_codec_write_cache(codec, nid, 0,
 690                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 691
 692         return change;
 693 }
 694 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 695         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 696           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 697           .info = alc_gpio_data_info, \
 698           .get = alc_gpio_data_get, \
 699           .put = alc_gpio_data_put, \
 700           .private_value = nid | (mask<<16) }
 701 #endif   /* CONFIG_SND_DEBUG */
 702
 703 /* A switch control to allow the enabling of the digital IO pins on the
 704  * ALC260.  This is incredibly simplistic; the intention of this control is
 705  * to provide something in the test model allowing digital outputs to be
 706  * identified if present.  If models are found which can utilise these
 707  * outputs a more complete mixer control can be devised for those models if
 708  * necessary.
 709  */
 710 #ifdef CONFIG_SND_DEBUG
 711 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 712
 713 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 714                               struct snd_ctl_elem_value *ucontrol)
 715 {
 716         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 717         hda_nid_t nid = kcontrol->private_value & 0xffff;
 718         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 719         long *valp = ucontrol->value.integer.value;
 720         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 721                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 722
 723         *valp = (val & mask) != 0;
 724         return 0;
 725 }
 726 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 727                               struct snd_ctl_elem_value *ucontrol)
 728 {
 729         signed int change;
 730         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 731         hda_nid_t nid = kcontrol->private_value & 0xffff;
 732         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 733         long val = *ucontrol->value.integer.value;
 734         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 735                                                     AC_VERB_GET_DIGI_CONVERT_1,
 736                                                     0x00);
 737
 738         /* Set/unset the masked control bit(s) as needed */
 739         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 740         if (val==0)
 741                 ctrl_data &= ~mask;
 742         else
 743                 ctrl_data |= mask;
 744         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 745                                   ctrl_data);
 746
 747         return change;
 748 }
 749 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 750         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 751           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 752           .info = alc_spdif_ctrl_info, \
 753           .get = alc_spdif_ctrl_get, \
 754           .put = alc_spdif_ctrl_put, \
 755           .private_value = nid | (mask<<16) }
 756 #endif   /* CONFIG_SND_DEBUG */
 757
 758 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 759  * Again, this is only used in the ALC26x test models to help identify when
 760  * the EAPD line must be asserted for features to work.
 761  */
 762 #ifdef CONFIG_SND_DEBUG
 763 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 764
 765 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 766                               struct snd_ctl_elem_value *ucontrol)
 767 {
 768         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 769         hda_nid_t nid = kcontrol->private_value & 0xffff;
 770         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 771         long *valp = ucontrol->value.integer.value;
 772         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 773                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 774
 775         *valp = (val & mask) != 0;
 776         return 0;
 777 }
 778
 779 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 780                               struct snd_ctl_elem_value *ucontrol)
 781 {
 782         int change;
 783         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 784         hda_nid_t nid = kcontrol->private_value & 0xffff;
 785         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 786         long val = *ucontrol->value.integer.value;
 787         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 788                                                     AC_VERB_GET_EAPD_BTLENABLE,
 789                                                     0x00);
 790
 791         /* Set/unset the masked control bit(s) as needed */
 792         change = (!val ? 0 : mask) != (ctrl_data & mask);
 793         if (!val)
 794                 ctrl_data &= ~mask;
 795         else
 796                 ctrl_data |= mask;
 797         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 798                                   ctrl_data);
 799
 800         return change;
 801 }
 802
 803 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 804         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 805           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 806           .info = alc_eapd_ctrl_info, \
 807           .get = alc_eapd_ctrl_get, \
 808           .put = alc_eapd_ctrl_put, \
 809           .private_value = nid | (mask<<16) }
 810 #endif   /* CONFIG_SND_DEBUG */
 811
 812 /*
 813  * set up the input pin config (depending on the given auto-pin type)
 814  */
 815 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 816                               int auto_pin_type)
 817 {
 818         unsigned int val = PIN_IN;
 819
 820         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 821                 unsigned int pincap;
 822                 pincap = snd_hda_query_pin_caps(codec, nid);
 823                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 824                 if (pincap & AC_PINCAP_VREF_80)
 825                         val = PIN_VREF80;
 826                 else if (pincap & AC_PINCAP_VREF_50)
 827                         val = PIN_VREF50;
 828                 else if (pincap & AC_PINCAP_VREF_100)
 829                         val = PIN_VREF100;
 830                 else if (pincap & AC_PINCAP_VREF_GRD)
 831                         val = PIN_VREFGRD;
 832         }
 833         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 834 }
 835
 836 /*
 837  */
 838 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 839 {
 840         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 841                 return;
 842         spec->mixers[spec->num_mixers++] = mix;
 843 }
 844
 845 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 846 {
 847         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 848                 return;
 849         spec->init_verbs[spec->num_init_verbs++] = verb;
 850 }
 851
 852 /*
 853  * set up from the preset table
 854  */
 855 static void setup_preset(struct hda_codec *codec,
 856                          const struct alc_config_preset *preset)
 857 {
 858         struct alc_spec *spec = codec->spec;
 859         int i;
 860
 861         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 862                 add_mixer(spec, preset->mixers[i]);
 863         spec->cap_mixer = preset->cap_mixer;
 864         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 865              i++)
 866                 add_verb(spec, preset->init_verbs[i]);
 867
 868         spec->channel_mode = preset->channel_mode;
 869         spec->num_channel_mode = preset->num_channel_mode;
 870         spec->need_dac_fix = preset->need_dac_fix;
 871         spec->const_channel_count = preset->const_channel_count;
 872
 873         if (preset->const_channel_count)
 874                 spec->multiout.max_channels = preset->const_channel_count;
 875         else
 876                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 877         spec->ext_channel_count = spec->channel_mode[0].channels;
 878
 879         spec->multiout.num_dacs = preset->num_dacs;
 880         spec->multiout.dac_nids = preset->dac_nids;
 881         spec->multiout.dig_out_nid = preset->dig_out_nid;
 882         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 883         spec->multiout.hp_nid = preset->hp_nid;
 884
 885         spec->num_mux_defs = preset->num_mux_defs;
 886         if (!spec->num_mux_defs)
 887                 spec->num_mux_defs = 1;
 888         spec->input_mux = preset->input_mux;
 889
 890         spec->num_adc_nids = preset->num_adc_nids;
 891         spec->adc_nids = preset->adc_nids;
 892         spec->capsrc_nids = preset->capsrc_nids;
 893         spec->dig_in_nid = preset->dig_in_nid;
 894
 895         spec->unsol_event = preset->unsol_event;
 896         spec->init_hook = preset->init_hook;
 897 #ifdef CONFIG_SND_HDA_POWER_SAVE
 898         spec->power_hook = preset->power_hook;
 899         spec->loopback.amplist = preset->loopbacks;
 900 #endif
 901
 902         if (preset->setup)
 903                 preset->setup(codec);
 904 }
 905
 906 /* Enable GPIO mask and set output */
 907 static struct hda_verb alc_gpio1_init_verbs[] = {
 908         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 909         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 910         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 911         { }
 912 };
 913
 914 static struct hda_verb alc_gpio2_init_verbs[] = {
 915         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 916         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 917         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 918         { }
 919 };
 920
 921 static struct hda_verb alc_gpio3_init_verbs[] = {
 922         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 923         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 924         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 925         { }
 926 };
 927
 928 /*
 929  * Fix hardware PLL issue
 930  * On some codecs, the analog PLL gating control must be off while
 931  * the default value is 1.
 932  */
 933 static void alc_fix_pll(struct hda_codec *codec)
 934 {
 935         struct alc_spec *spec = codec->spec;
 936         unsigned int val;
 937
 938         if (!spec->pll_nid)
 939                 return;
 940         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 941                             spec->pll_coef_idx);
 942         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 943                                  AC_VERB_GET_PROC_COEF, 0);
 944         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 945                             spec->pll_coef_idx);
 946         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 947                             val & ~(1 << spec->pll_coef_bit));
 948 }
 949
 950 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 951                              unsigned int coef_idx, unsigned int coef_bit)
 952 {
 953         struct alc_spec *spec = codec->spec;
 954         spec->pll_nid = nid;
 955         spec->pll_coef_idx = coef_idx;
 956         spec->pll_coef_bit = coef_bit;
 957         alc_fix_pll(codec);
 958 }
 959
 960 static void alc_automute_pin(struct hda_codec *codec)
 961 {
 962         struct alc_spec *spec = codec->spec;
 963         unsigned int nid = spec->autocfg.hp_pins[0];
 964         int i;
 965
 966         if (!nid)
 967                 return;
 968         spec->jack_present = snd_hda_jack_detect(codec, nid);
 969         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 970                 nid = spec->autocfg.speaker_pins[i];
 971                 if (!nid)
 972                         break;
 973                 snd_hda_codec_write(codec, nid, 0,
 974                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 975                                     spec->jack_present ? 0 : PIN_OUT);
 976         }
 977 }
 978
 979 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 980                                 hda_nid_t nid)
 981 {
 982         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 983         int i, nums;
 984
 985         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 986         for (i = 0; i < nums; i++)
 987                 if (conn[i] == nid)
 988                         return i;
 989         return -1;
 990 }
 991
 992 static void alc_mic_automute(struct hda_codec *codec)
 993 {
 994         struct alc_spec *spec = codec->spec;
 995         struct alc_mic_route *dead, *alive;
 996         unsigned int present, type;
 997         hda_nid_t cap_nid;
 998
 999         if (!spec->auto_mic)
1000                 return;
1001         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1002                 return;
1003         if (snd_BUG_ON(!spec->adc_nids))
1004                 return;
1005
1006         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1007
1008         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1009         if (present) {
1010                 alive = &spec->ext_mic;
1011                 dead = &spec->int_mic;
1012         } else {
1013                 alive = &spec->int_mic;
1014                 dead = &spec->ext_mic;
1015         }
1016
1017         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1018         if (type == AC_WID_AUD_MIX) {
1019                 /* Matrix-mixer style (e.g. ALC882) */
1020                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1021                                          alive->mux_idx,
1022                                          HDA_AMP_MUTE, 0);
1023                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1024                                          dead->mux_idx,
1025                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1026         } else {
1027                 /* MUX style (e.g. ALC880) */
1028                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1029                                           AC_VERB_SET_CONNECT_SEL,
1030                                           alive->mux_idx);
1031         }
1032
1033         /* FIXME: analog mixer */
1034 }
1035
1036 /* unsolicited event for HP jack sensing */
1037 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1038 {
1039         if (codec->vendor_id == 0x10ec0880)
1040                 res >>= 28;
1041         else
1042                 res >>= 26;
1043         switch (res) {
1044         case ALC880_HP_EVENT:
1045                 alc_automute_pin(codec);
1046                 break;
1047         case ALC880_MIC_EVENT:
1048                 alc_mic_automute(codec);
1049                 break;
1050         }
1051 }
1052
1053 static void alc_inithook(struct hda_codec *codec)
1054 {
1055         alc_automute_pin(codec);
1056         alc_mic_automute(codec);
1057 }
1058
1059 /* additional initialization for ALC888 variants */
1060 static void alc888_coef_init(struct hda_codec *codec)
1061 {
1062         unsigned int tmp;
1063
1064         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1065         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1066         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1067         if ((tmp & 0xf0) == 0x20)
1068                 /* alc888S-VC */
1069                 snd_hda_codec_read(codec, 0x20, 0,
1070                                    AC_VERB_SET_PROC_COEF, 0x830);
1071          else
1072                  /* alc888-VB */
1073                  snd_hda_codec_read(codec, 0x20, 0,
1074                                     AC_VERB_SET_PROC_COEF, 0x3030);
1075 }
1076
1077 static void alc889_coef_init(struct hda_codec *codec)
1078 {
1079         unsigned int tmp;
1080
1081         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1082         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1083         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1084         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1085 }
1086
1087 /* turn on/off EAPD control (only if available) */
1088 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1089 {
1090         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1091                 return;
1092         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1093                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1094                                     on ? 2 : 0);
1095 }
1096
1097 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1098 {
1099         unsigned int tmp;
1100
1101         switch (type) {
1102         case ALC_INIT_GPIO1:
1103                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1104                 break;
1105         case ALC_INIT_GPIO2:
1106                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1107                 break;
1108         case ALC_INIT_GPIO3:
1109                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1110                 break;
1111         case ALC_INIT_DEFAULT:
1112                 switch (codec->vendor_id) {
1113                 case 0x10ec0260:
1114                         set_eapd(codec, 0x0f, 1);
1115                         set_eapd(codec, 0x10, 1);
1116                         break;
1117                 case 0x10ec0262:
1118                 case 0x10ec0267:
1119                 case 0x10ec0268:
1120                 case 0x10ec0269:
1121                 case 0x10ec0270:
1122                 case 0x10ec0272:
1123                 case 0x10ec0660:
1124                 case 0x10ec0662:
1125                 case 0x10ec0663:
1126                 case 0x10ec0862:
1127                 case 0x10ec0889:
1128                         set_eapd(codec, 0x14, 1);
1129                         set_eapd(codec, 0x15, 1);
1130                         break;
1131                 }
1132                 switch (codec->vendor_id) {
1133                 case 0x10ec0260:
1134                         snd_hda_codec_write(codec, 0x1a, 0,
1135                                             AC_VERB_SET_COEF_INDEX, 7);
1136                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1137                                                  AC_VERB_GET_PROC_COEF, 0);
1138                         snd_hda_codec_write(codec, 0x1a, 0,
1139                                             AC_VERB_SET_COEF_INDEX, 7);
1140                         snd_hda_codec_write(codec, 0x1a, 0,
1141                                             AC_VERB_SET_PROC_COEF,
1142                                             tmp | 0x2010);
1143                         break;
1144                 case 0x10ec0262:
1145                 case 0x10ec0880:
1146                 case 0x10ec0882:
1147                 case 0x10ec0883:
1148                 case 0x10ec0885:
1149                 case 0x10ec0887:
1150                 case 0x10ec0889:
1151                         alc889_coef_init(codec);
1152                         break;
1153                 case 0x10ec0888:
1154                         alc888_coef_init(codec);
1155                         break;
1156 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1157                 case 0x10ec0267:
1158                 case 0x10ec0268:
1159                         snd_hda_codec_write(codec, 0x20, 0,
1160                                             AC_VERB_SET_COEF_INDEX, 7);
1161                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1162                                                  AC_VERB_GET_PROC_COEF, 0);
1163                         snd_hda_codec_write(codec, 0x20, 0,
1164                                             AC_VERB_SET_COEF_INDEX, 7);
1165                         snd_hda_codec_write(codec, 0x20, 0,
1166                                             AC_VERB_SET_PROC_COEF,
1167                                             tmp | 0x3000);
1168                         break;
1169 #endif /* XXX */
1170                 }
1171                 break;
1172         }
1173 }
1174
1175 static void alc_init_auto_hp(struct hda_codec *codec)
1176 {
1177         struct alc_spec *spec = codec->spec;
1178
1179         if (!spec->autocfg.hp_pins[0])
1180                 return;
1181
1182         if (!spec->autocfg.speaker_pins[0]) {
1183                 if (spec->autocfg.line_out_pins[0] &&
1184                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1185                         spec->autocfg.speaker_pins[0] =
1186                                 spec->autocfg.line_out_pins[0];
1187                 else
1188                         return;
1189         }
1190
1191         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1192                     spec->autocfg.hp_pins[0]);
1193         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1194                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1195                                   AC_USRSP_EN | ALC880_HP_EVENT);
1196         spec->unsol_event = alc_sku_unsol_event;
1197 }
1198
1199 static void alc_init_auto_mic(struct hda_codec *codec)
1200 {
1201         struct alc_spec *spec = codec->spec;
1202         struct auto_pin_cfg *cfg = &spec->autocfg;
1203         hda_nid_t fixed, ext;
1204         int i;
1205
1206         /* there must be only two mic inputs exclusively */
1207         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1208                 if (cfg->input_pins[i])
1209                         return;
1210
1211         fixed = ext = 0;
1212         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1213                 hda_nid_t nid = cfg->input_pins[i];
1214                 unsigned int defcfg;
1215                 if (!nid)
1216                         return;
1217                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1218                 switch (get_defcfg_connect(defcfg)) {
1219                 case AC_JACK_PORT_FIXED:
1220                         if (fixed)
1221                                 return; /* already occupied */
1222                         fixed = nid;
1223                         break;
1224                 case AC_JACK_PORT_COMPLEX:
1225                         if (ext)
1226                                 return; /* already occupied */
1227                         ext = nid;
1228                         break;
1229                 default:
1230                         return; /* invalid entry */
1231                 }
1232         }
1233         if (!ext || !fixed)
1234                 return;
1235         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1236                 return; /* no unsol support */
1237         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1238                     ext, fixed);
1239         spec->ext_mic.pin = ext;
1240         spec->int_mic.pin = fixed;
1241         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1242         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1243         spec->auto_mic = 1;
1244         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1245                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1246                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1247         spec->unsol_event = alc_sku_unsol_event;
1248 }
1249
1250 /* check subsystem ID and set up device-specific initialization;
1251  * return 1 if initialized, 0 if invalid SSID
1252  */
1253 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1254  *      31 ~ 16 :       Manufacture ID
1255  *      15 ~ 8  :       SKU ID
1256  *      7  ~ 0  :       Assembly ID
1257  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1258  */
1259 static int alc_subsystem_id(struct hda_codec *codec,
1260                             hda_nid_t porta, hda_nid_t porte,
1261                             hda_nid_t portd, hda_nid_t porti)
1262 {
1263         unsigned int ass, tmp, i;
1264         unsigned nid;
1265         struct alc_spec *spec = codec->spec;
1266
1267         ass = codec->subsystem_id & 0xffff;
1268         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1269                 goto do_sku;
1270
1271         /* invalid SSID, check the special NID pin defcfg instead */
1272         /*
1273          * 31~30        : port connectivity
1274          * 29~21        : reserve
1275          * 20           : PCBEEP input
1276          * 19~16        : Check sum (15:1)
1277          * 15~1         : Custom
1278          * 0            : override
1279         */
1280         nid = 0x1d;
1281         if (codec->vendor_id == 0x10ec0260)
1282                 nid = 0x17;
1283         ass = snd_hda_codec_get_pincfg(codec, nid);
1284         snd_printd("realtek: No valid SSID, "
1285                    "checking pincfg 0x%08x for NID 0x%x\n",
1286                    ass, nid);
1287         if (!(ass & 1))
1288                 return 0;
1289         if ((ass >> 30) != 1)   /* no physical connection */
1290                 return 0;
1291
1292         /* check sum */
1293         tmp = 0;
1294         for (i = 1; i < 16; i++) {
1295                 if ((ass >> i) & 1)
1296                         tmp++;
1297         }
1298         if (((ass >> 16) & 0xf) != tmp)
1299                 return 0;
1300 do_sku:
1301         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1302                    ass & 0xffff, codec->vendor_id);
1303         /*
1304          * 0 : override
1305          * 1 :  Swap Jack
1306          * 2 : 0 --> Desktop, 1 --> Laptop
1307          * 3~5 : External Amplifier control
1308          * 7~6 : Reserved
1309         */
1310         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1311         switch (tmp) {
1312         case 1:
1313                 spec->init_amp = ALC_INIT_GPIO1;
1314                 break;
1315         case 3:
1316                 spec->init_amp = ALC_INIT_GPIO2;
1317                 break;
1318         case 7:
1319                 spec->init_amp = ALC_INIT_GPIO3;
1320                 break;
1321         case 5:
1322                 spec->init_amp = ALC_INIT_DEFAULT;
1323                 break;
1324         }
1325
1326         /* is laptop or Desktop and enable the function "Mute internal speaker
1327          * when the external headphone out jack is plugged"
1328          */
1329         if (!(ass & 0x8000))
1330                 return 1;
1331         /*
1332          * 10~8 : Jack location
1333          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1334          * 14~13: Resvered
1335          * 15   : 1 --> enable the function "Mute internal speaker
1336          *              when the external headphone out jack is plugged"
1337          */
1338         if (!spec->autocfg.hp_pins[0]) {
1339                 hda_nid_t nid;
1340                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1341                 if (tmp == 0)
1342                         nid = porta;
1343                 else if (tmp == 1)
1344                         nid = porte;
1345                 else if (tmp == 2)
1346                         nid = portd;
1347                 else if (tmp == 3)
1348                         nid = porti;
1349                 else
1350                         return 1;
1351                 for (i = 0; i < spec->autocfg.line_outs; i++)
1352                         if (spec->autocfg.line_out_pins[i] == nid)
1353                                 return 1;
1354                 spec->autocfg.hp_pins[0] = nid;
1355         }
1356
1357         alc_init_auto_hp(codec);
1358         alc_init_auto_mic(codec);
1359         return 1;
1360 }
1361
1362 static void alc_ssid_check(struct hda_codec *codec,
1363                            hda_nid_t porta, hda_nid_t porte,
1364                            hda_nid_t portd, hda_nid_t porti)
1365 {
1366         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1367                 struct alc_spec *spec = codec->spec;
1368                 snd_printd("realtek: "
1369                            "Enable default setup for auto mode as fallback\n");
1370                 spec->init_amp = ALC_INIT_DEFAULT;
1371                 alc_init_auto_hp(codec);
1372                 alc_init_auto_mic(codec);
1373         }
1374 }
1375
1376 /*
1377  * Fix-up pin default configurations and add default verbs
1378  */
1379
1380 struct alc_pincfg {
1381         hda_nid_t nid;
1382         u32 val;
1383 };
1384
1385 struct alc_fixup {
1386         const struct alc_pincfg *pins;
1387         const struct hda_verb *verbs;
1388 };
1389
1390 static void alc_pick_fixup(struct hda_codec *codec,
1391                            const struct snd_pci_quirk *quirk,
1392                            const struct alc_fixup *fix)
1393 {
1394         const struct alc_pincfg *cfg;
1395
1396         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1397         if (!quirk)
1398                 return;
1399
1400         fix += quirk->value;
1401         cfg = fix->pins;
1402         if (cfg) {
1403                 for (; cfg->nid; cfg++)
1404                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1405         }
1406         if (fix->verbs)
1407                 add_verb(codec->spec, fix->verbs);
1408 }
1409
1410 static int alc_read_coef_idx(struct hda_codec *codec,
1411                         unsigned int coef_idx)
1412 {
1413         unsigned int val;
1414         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1415                                 coef_idx);
1416         val = snd_hda_codec_read(codec, 0x20, 0,
1417                                 AC_VERB_GET_PROC_COEF, 0);
1418         return val;
1419 }
1420
1421 /*
1422  * ALC888
1423  */
1424
1425 /*
1426  * 2ch mode
1427  */
1428 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1429 /* Mic-in jack as mic in */
1430         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1431         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1432 /* Line-in jack as Line in */
1433         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1434         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1435 /* Line-Out as Front */
1436         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1437         { } /* end */
1438 };
1439
1440 /*
1441  * 4ch mode
1442  */
1443 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1444 /* Mic-in jack as mic in */
1445         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1446         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1447 /* Line-in jack as Surround */
1448         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1449         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1450 /* Line-Out as Front */
1451         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1452         { } /* end */
1453 };
1454
1455 /*
1456  * 6ch mode
1457  */
1458 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1459 /* Mic-in jack as CLFE */
1460         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1461         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1462 /* Line-in jack as Surround */
1463         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1464         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1465 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1466         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1467         { } /* end */
1468 };
1469
1470 /*
1471  * 8ch mode
1472  */
1473 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1474 /* Mic-in jack as CLFE */
1475         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477 /* Line-in jack as Surround */
1478         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1480 /* Line-Out as Side */
1481         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1482         { } /* end */
1483 };
1484
1485 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1486         { 2, alc888_4ST_ch2_intel_init },
1487         { 4, alc888_4ST_ch4_intel_init },
1488         { 6, alc888_4ST_ch6_intel_init },
1489         { 8, alc888_4ST_ch8_intel_init },
1490 };
1491
1492 /*
1493  * ALC888 Fujitsu Siemens Amillo xa3530
1494  */
1495
1496 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1497 /* Front Mic: set to PIN_IN (empty by default) */
1498         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1499 /* Connect Internal HP to Front */
1500         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1501         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1502         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1503 /* Connect Bass HP to Front */
1504         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1505         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1506         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1507 /* Connect Line-Out side jack (SPDIF) to Side */
1508         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1509         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1510         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1511 /* Connect Mic jack to CLFE */
1512         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1513         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1514         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1515 /* Connect Line-in jack to Surround */
1516         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1517         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1518         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1519 /* Connect HP out jack to Front */
1520         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1521         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1522         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1523 /* Enable unsolicited event for HP jack and Line-out jack */
1524         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1525         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1526         {}
1527 };
1528
1529 static void alc_automute_amp(struct hda_codec *codec)
1530 {
1531         struct alc_spec *spec = codec->spec;
1532         unsigned int mute;
1533         hda_nid_t nid;
1534         int i;
1535
1536         spec->jack_present = 0;
1537         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1538                 nid = spec->autocfg.hp_pins[i];
1539                 if (!nid)
1540                         break;
1541                 if (snd_hda_jack_detect(codec, nid)) {
1542                         spec->jack_present = 1;
1543                         break;
1544                 }
1545         }
1546
1547         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1548         /* Toggle internal speakers muting */
1549         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1550                 nid = spec->autocfg.speaker_pins[i];
1551                 if (!nid)
1552                         break;
1553                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1554                                          HDA_AMP_MUTE, mute);
1555         }
1556 }
1557
1558 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1559                                          unsigned int res)
1560 {
1561         if (codec->vendor_id == 0x10ec0880)
1562                 res >>= 28;
1563         else
1564                 res >>= 26;
1565         if (res == ALC880_HP_EVENT)
1566                 alc_automute_amp(codec);
1567 }
1568
1569 static void alc889_automute_setup(struct hda_codec *codec)
1570 {
1571         struct alc_spec *spec = codec->spec;
1572
1573         spec->autocfg.hp_pins[0] = 0x15;
1574         spec->autocfg.speaker_pins[0] = 0x14;
1575         spec->autocfg.speaker_pins[1] = 0x16;
1576         spec->autocfg.speaker_pins[2] = 0x17;
1577         spec->autocfg.speaker_pins[3] = 0x19;
1578         spec->autocfg.speaker_pins[4] = 0x1a;
1579 }
1580
1581 static void alc889_intel_init_hook(struct hda_codec *codec)
1582 {
1583         alc889_coef_init(codec);
1584         alc_automute_amp(codec);
1585 }
1586
1587 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1588 {
1589         struct alc_spec *spec = codec->spec;
1590
1591         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1592         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1593         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1594         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1595 }
1596
1597 /*
1598  * ALC888 Acer Aspire 4930G model
1599  */
1600
1601 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1602 /* Front Mic: set to PIN_IN (empty by default) */
1603         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1604 /* Unselect Front Mic by default in input mixer 3 */
1605         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1606 /* Enable unsolicited event for HP jack */
1607         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1608 /* Connect Internal HP to front */
1609         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1610         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1611         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1612 /* Connect HP out to front */
1613         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1614         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1615         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1616         { }
1617 };
1618
1619 /*
1620  * ALC888 Acer Aspire 6530G model
1621  */
1622
1623 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1624 /* Bias voltage on for external mic port */
1625         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1626 /* Front Mic: set to PIN_IN (empty by default) */
1627         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1628 /* Unselect Front Mic by default in input mixer 3 */
1629         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1630 /* Enable unsolicited event for HP jack */
1631         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1632 /* Enable speaker output */
1633         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1634         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1635 /* Enable headphone output */
1636         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1637         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1638         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1639         { }
1640 };
1641
1642 /*
1643  * ALC889 Acer Aspire 8930G model
1644  */
1645
1646 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1647 /* Front Mic: set to PIN_IN (empty by default) */
1648         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1649 /* Unselect Front Mic by default in input mixer 3 */
1650         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1651 /* Enable unsolicited event for HP jack */
1652         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1653 /* Connect Internal Front to Front */
1654         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1655         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1656         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1657 /* Connect Internal Rear to Rear */
1658         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1659         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1660         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1661 /* Connect Internal CLFE to CLFE */
1662         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1663         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1664         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1665 /* Connect HP out to Front */
1666         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1667         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1668         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1669 /* Enable all DACs */
1670 /*  DAC DISABLE/MUTE 1? */
1671 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1672         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1673         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1674 /*  DAC DISABLE/MUTE 2? */
1675 /*  some bit here disables the other DACs. Init=0x4900 */
1676         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1677         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1678 /* DMIC fix
1679  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1680  * which makes the stereo useless. However, either the mic or the ALC889
1681  * makes the signal become a difference/sum signal instead of standard
1682  * stereo, which is annoying. So instead we flip this bit which makes the
1683  * codec replicate the sum signal to both channels, turning it into a
1684  * normal mono mic.
1685  */
1686 /*  DMIC_CONTROL? Init value = 0x0001 */
1687         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1688         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1689         { }
1690 };
1691
1692 static struct hda_input_mux alc888_2_capture_sources[2] = {
1693         /* Front mic only available on one ADC */
1694         {
1695                 .num_items = 4,
1696                 .items = {
1697                         { "Mic", 0x0 },
1698                         { "Line", 0x2 },
1699                         { "CD", 0x4 },
1700                         { "Front Mic", 0xb },
1701                 },
1702         },
1703         {
1704                 .num_items = 3,
1705                 .items = {
1706                         { "Mic", 0x0 },
1707                         { "Line", 0x2 },
1708                         { "CD", 0x4 },
1709                 },
1710         }
1711 };
1712
1713 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1714         /* Interal mic only available on one ADC */
1715         {
1716                 .num_items = 5,
1717                 .items = {
1718                         { "Ext Mic", 0x0 },
1719                         { "Line In", 0x2 },
1720                         { "CD", 0x4 },
1721                         { "Input Mix", 0xa },
1722                         { "Int Mic", 0xb },
1723                 },
1724         },
1725         {
1726                 .num_items = 4,
1727                 .items = {
1728                         { "Ext Mic", 0x0 },
1729                         { "Line In", 0x2 },
1730                         { "CD", 0x4 },
1731                         { "Input Mix", 0xa },
1732                 },
1733         }
1734 };
1735
1736 static struct hda_input_mux alc889_capture_sources[3] = {
1737         /* Digital mic only available on first "ADC" */
1738         {
1739                 .num_items = 5,
1740                 .items = {
1741                         { "Mic", 0x0 },
1742                         { "Line", 0x2 },
1743                         { "CD", 0x4 },
1744                         { "Front Mic", 0xb },
1745                         { "Input Mix", 0xa },
1746                 },
1747         },
1748         {
1749                 .num_items = 4,
1750                 .items = {
1751                         { "Mic", 0x0 },
1752                         { "Line", 0x2 },
1753                         { "CD", 0x4 },
1754                         { "Input Mix", 0xa },
1755                 },
1756         },
1757         {
1758                 .num_items = 4,
1759                 .items = {
1760                         { "Mic", 0x0 },
1761                         { "Line", 0x2 },
1762                         { "CD", 0x4 },
1763                         { "Input Mix", 0xa },
1764                 },
1765         }
1766 };
1767
1768 static struct snd_kcontrol_new alc888_base_mixer[] = {
1769         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1770         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1771         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1772         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1773         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1774                 HDA_OUTPUT),
1775         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1776         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1777         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1778         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1779         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1780         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1781         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1782         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1783         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1784         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1785         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1787         { } /* end */
1788 };
1789
1790 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1791         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1792         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1793         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1794         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1795         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1796                 HDA_OUTPUT),
1797         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1798         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1799         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1800         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1801         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1802         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1803         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1805         { } /* end */
1806 };
1807
1808
1809 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1810 {
1811         struct alc_spec *spec = codec->spec;
1812
1813         spec->autocfg.hp_pins[0] = 0x15;
1814         spec->autocfg.speaker_pins[0] = 0x14;
1815         spec->autocfg.speaker_pins[1] = 0x16;
1816         spec->autocfg.speaker_pins[2] = 0x17;
1817 }
1818
1819 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1820 {
1821         struct alc_spec *spec = codec->spec;
1822
1823         spec->autocfg.hp_pins[0] = 0x15;
1824         spec->autocfg.speaker_pins[0] = 0x14;
1825         spec->autocfg.speaker_pins[1] = 0x16;
1826         spec->autocfg.speaker_pins[2] = 0x17;
1827 }
1828
1829 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1830 {
1831         struct alc_spec *spec = codec->spec;
1832
1833         spec->autocfg.hp_pins[0] = 0x15;
1834         spec->autocfg.speaker_pins[0] = 0x14;
1835         spec->autocfg.speaker_pins[1] = 0x16;
1836         spec->autocfg.speaker_pins[2] = 0x1b;
1837 }
1838
1839 /*
1840  * ALC880 3-stack model
1841  *
1842  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1843  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1844  *                 F-Mic = 0x1b, HP = 0x19
1845  */
1846
1847 static hda_nid_t alc880_dac_nids[4] = {
1848         /* front, rear, clfe, rear_surr */
1849         0x02, 0x05, 0x04, 0x03
1850 };
1851
1852 static hda_nid_t alc880_adc_nids[3] = {
1853         /* ADC0-2 */
1854         0x07, 0x08, 0x09,
1855 };
1856
1857 /* The datasheet says the node 0x07 is connected from inputs,
1858  * but it shows zero connection in the real implementation on some devices.
1859  * Note: this is a 915GAV bug, fixed on 915GLV
1860  */
1861 static hda_nid_t alc880_adc_nids_alt[2] = {
1862         /* ADC1-2 */
1863         0x08, 0x09,
1864 };
1865
1866 #define ALC880_DIGOUT_NID       0x06
1867 #define ALC880_DIGIN_NID        0x0a
1868
1869 static struct hda_input_mux alc880_capture_source = {
1870         .num_items = 4,
1871         .items = {
1872                 { "Mic", 0x0 },
1873                 { "Front Mic", 0x3 },
1874                 { "Line", 0x2 },
1875                 { "CD", 0x4 },
1876         },
1877 };
1878
1879 /* channel source setting (2/6 channel selection for 3-stack) */
1880 /* 2ch mode */
1881 static struct hda_verb alc880_threestack_ch2_init[] = {
1882         /* set line-in to input, mute it */
1883         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1884         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1885         /* set mic-in to input vref 80%, mute it */
1886         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1887         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1888         { } /* end */
1889 };
1890
1891 /* 6ch mode */
1892 static struct hda_verb alc880_threestack_ch6_init[] = {
1893         /* set line-in to output, unmute it */
1894         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1895         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1896         /* set mic-in to output, unmute it */
1897         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1898         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1899         { } /* end */
1900 };
1901
1902 static struct hda_channel_mode alc880_threestack_modes[2] = {
1903         { 2, alc880_threestack_ch2_init },
1904         { 6, alc880_threestack_ch6_init },
1905 };
1906
1907 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1908         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1909         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1910         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1911         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1912         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1913         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1914         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1915         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1916         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1917         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1918         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1919         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1920         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1921         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1922         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1923         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1924         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1925         {
1926                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1927                 .name = "Channel Mode",
1928                 .info = alc_ch_mode_info,
1929                 .get = alc_ch_mode_get,
1930                 .put = alc_ch_mode_put,
1931         },
1932         { } /* end */
1933 };
1934
1935 /* capture mixer elements */
1936 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1937                             struct snd_ctl_elem_info *uinfo)
1938 {
1939         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1940         struct alc_spec *spec = codec->spec;
1941         int err;
1942
1943         mutex_lock(&codec->control_mutex);
1944         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1945                                                       HDA_INPUT);
1946         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1947         mutex_unlock(&codec->control_mutex);
1948         return err;
1949 }
1950
1951 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1952                            unsigned int size, unsigned int __user *tlv)
1953 {
1954         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1955         struct alc_spec *spec = codec->spec;
1956         int err;
1957
1958         mutex_lock(&codec->control_mutex);
1959         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1960                                                       HDA_INPUT);
1961         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1962         mutex_unlock(&codec->control_mutex);
1963         return err;
1964 }
1965
1966 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1967                              struct snd_ctl_elem_value *ucontrol);
1968
1969 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1970                                  struct snd_ctl_elem_value *ucontrol,
1971                                  getput_call_t func)
1972 {
1973         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1974         struct alc_spec *spec = codec->spec;
1975         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1976         int err;
1977
1978         mutex_lock(&codec->control_mutex);
1979         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1980                                                       3, 0, HDA_INPUT);
1981         err = func(kcontrol, ucontrol);
1982         mutex_unlock(&codec->control_mutex);
1983         return err;
1984 }
1985
1986 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1987                            struct snd_ctl_elem_value *ucontrol)
1988 {
1989         return alc_cap_getput_caller(kcontrol, ucontrol,
1990                                      snd_hda_mixer_amp_volume_get);
1991 }
1992
1993 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1994                            struct snd_ctl_elem_value *ucontrol)
1995 {
1996         return alc_cap_getput_caller(kcontrol, ucontrol,
1997                                      snd_hda_mixer_amp_volume_put);
1998 }
1999
2000 /* capture mixer elements */
2001 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2002
2003 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2004                           struct snd_ctl_elem_value *ucontrol)
2005 {
2006         return alc_cap_getput_caller(kcontrol, ucontrol,
2007                                      snd_hda_mixer_amp_switch_get);
2008 }
2009
2010 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2011                           struct snd_ctl_elem_value *ucontrol)
2012 {
2013         return alc_cap_getput_caller(kcontrol, ucontrol,
2014                                      snd_hda_mixer_amp_switch_put);
2015 }
2016
2017 #define _DEFINE_CAPMIX(num) \
2018         { \
2019                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2020                 .name = "Capture Switch", \
2021                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2022                 .count = num, \
2023                 .info = alc_cap_sw_info, \
2024                 .get = alc_cap_sw_get, \
2025                 .put = alc_cap_sw_put, \
2026         }, \
2027         { \
2028                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2029                 .name = "Capture Volume", \
2030                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2031                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2032                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2033                 .count = num, \
2034                 .info = alc_cap_vol_info, \
2035                 .get = alc_cap_vol_get, \
2036                 .put = alc_cap_vol_put, \
2037                 .tlv = { .c = alc_cap_vol_tlv }, \
2038         }
2039
2040 #define _DEFINE_CAPSRC(num) \
2041         { \
2042                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2043                 /* .name = "Capture Source", */ \
2044                 .name = "Input Source", \
2045                 .count = num, \
2046                 .info = alc_mux_enum_info, \
2047                 .get = alc_mux_enum_get, \
2048                 .put = alc_mux_enum_put, \
2049         }
2050
2051 #define DEFINE_CAPMIX(num) \
2052 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2053         _DEFINE_CAPMIX(num),                                  \
2054         _DEFINE_CAPSRC(num),                                  \
2055         { } /* end */                                         \
2056 }
2057
2058 #define DEFINE_CAPMIX_NOSRC(num) \
2059 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2060         _DEFINE_CAPMIX(num),                                        \
2061         { } /* end */                                               \
2062 }
2063
2064 /* up to three ADCs */
2065 DEFINE_CAPMIX(1);
2066 DEFINE_CAPMIX(2);
2067 DEFINE_CAPMIX(3);
2068 DEFINE_CAPMIX_NOSRC(1);
2069 DEFINE_CAPMIX_NOSRC(2);
2070 DEFINE_CAPMIX_NOSRC(3);
2071
2072 /*
2073  * ALC880 5-stack model
2074  *
2075  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2076  *      Side = 0x02 (0xd)
2077  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2078  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2079  */
2080
2081 /* additional mixers to alc880_three_stack_mixer */
2082 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2083         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2084         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2085         { } /* end */
2086 };
2087
2088 /* channel source setting (6/8 channel selection for 5-stack) */
2089 /* 6ch mode */
2090 static struct hda_verb alc880_fivestack_ch6_init[] = {
2091         /* set line-in to input, mute it */
2092         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2093         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2094         { } /* end */
2095 };
2096
2097 /* 8ch mode */
2098 static struct hda_verb alc880_fivestack_ch8_init[] = {
2099         /* set line-in to output, unmute it */
2100         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2101         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2102         { } /* end */
2103 };
2104
2105 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2106         { 6, alc880_fivestack_ch6_init },
2107         { 8, alc880_fivestack_ch8_init },
2108 };
2109
2110
2111 /*
2112  * ALC880 6-stack model
2113  *
2114  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2115  *      Side = 0x05 (0x0f)
2116  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2117  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2118  */
2119
2120 static hda_nid_t alc880_6st_dac_nids[4] = {
2121         /* front, rear, clfe, rear_surr */
2122         0x02, 0x03, 0x04, 0x05
2123 };
2124
2125 static struct hda_input_mux alc880_6stack_capture_source = {
2126         .num_items = 4,
2127         .items = {
2128                 { "Mic", 0x0 },
2129                 { "Front Mic", 0x1 },
2130                 { "Line", 0x2 },
2131                 { "CD", 0x4 },
2132         },
2133 };
2134
2135 /* fixed 8-channels */
2136 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2137         { 8, NULL },
2138 };
2139
2140 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2141         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2142         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2143         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2144         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2145         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2146         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2147         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2148         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2149         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2150         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2151         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2152         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2153         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2154         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2155         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2156         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2157         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2158         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2159         {
2160                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2161                 .name = "Channel Mode",
2162                 .info = alc_ch_mode_info,
2163                 .get = alc_ch_mode_get,
2164                 .put = alc_ch_mode_put,
2165         },
2166         { } /* end */
2167 };
2168
2169
2170 /*
2171  * ALC880 W810 model
2172  *
2173  * W810 has rear IO for:
2174  * Front (DAC 02)
2175  * Surround (DAC 03)
2176  * Center/LFE (DAC 04)
2177  * Digital out (06)
2178  *
2179  * The system also has a pair of internal speakers, and a headphone jack.
2180  * These are both connected to Line2 on the codec, hence to DAC 02.
2181  *
2182  * There is a variable resistor to control the speaker or headphone
2183  * volume. This is a hardware-only device without a software API.
2184  *
2185  * Plugging headphones in will disable the internal speakers. This is
2186  * implemented in hardware, not via the driver using jack sense. In
2187  * a similar fashion, plugging into the rear socket marked "front" will
2188  * disable both the speakers and headphones.
2189  *
2190  * For input, there's a microphone jack, and an "audio in" jack.
2191  * These may not do anything useful with this driver yet, because I
2192  * haven't setup any initialization verbs for these yet...
2193  */
2194
2195 static hda_nid_t alc880_w810_dac_nids[3] = {
2196         /* front, rear/surround, clfe */
2197         0x02, 0x03, 0x04
2198 };
2199
2200 /* fixed 6 channels */
2201 static struct hda_channel_mode alc880_w810_modes[1] = {
2202         { 6, NULL }
2203 };
2204
2205 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2206 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2207         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2208         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2209         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2210         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2211         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2212         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2213         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2214         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2215         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2216         { } /* end */
2217 };
2218
2219
2220 /*
2221  * Z710V model
2222  *
2223  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2224  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2225  *                 Line = 0x1a
2226  */
2227
2228 static hda_nid_t alc880_z71v_dac_nids[1] = {
2229         0x02
2230 };
2231 #define ALC880_Z71V_HP_DAC      0x03
2232
2233 /* fixed 2 channels */
2234 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2235         { 2, NULL }
2236 };
2237
2238 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2239         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2240         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2241         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2242         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2243         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2244         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2245         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2246         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2247         { } /* end */
2248 };
2249
2250
2251 /*
2252  * ALC880 F1734 model
2253  *
2254  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2255  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2256  */
2257
2258 static hda_nid_t alc880_f1734_dac_nids[1] = {
2259         0x03
2260 };
2261 #define ALC880_F1734_HP_DAC     0x02
2262
2263 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2264         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2265         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2266         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2267         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2268         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2269         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2270         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2271         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2272         { } /* end */
2273 };
2274
2275 static struct hda_input_mux alc880_f1734_capture_source = {
2276         .num_items = 2,
2277         .items = {
2278                 { "Mic", 0x1 },
2279                 { "CD", 0x4 },
2280         },
2281 };
2282
2283
2284 /*
2285  * ALC880 ASUS model
2286  *
2287  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2288  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2289  *  Mic = 0x18, Line = 0x1a
2290  */
2291
2292 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2293 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2294
2295 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2296         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2297         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2298         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2299         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2300         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2301         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2302         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2303         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2304         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2305         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2306         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2307         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2308         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2309         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2310         {
2311                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2312                 .name = "Channel Mode",
2313                 .info = alc_ch_mode_info,
2314                 .get = alc_ch_mode_get,
2315                 .put = alc_ch_mode_put,
2316         },
2317         { } /* end */
2318 };
2319
2320 /*
2321  * ALC880 ASUS W1V model
2322  *
2323  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2324  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2325  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2326  */
2327
2328 /* additional mixers to alc880_asus_mixer */
2329 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2330         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2331         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2332         { } /* end */
2333 };
2334
2335 /* TCL S700 */
2336 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2337         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2338         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2339         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2340         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2341         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2342         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2343         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2344         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2345         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2346         { } /* end */
2347 };
2348
2349 /* Uniwill */
2350 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2351         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2352         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2353         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2354         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2355         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2356         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2357         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2358         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2359         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2360         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2361         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2362         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2363         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2364         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2365         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2366         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2367         {
2368                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2369                 .name = "Channel Mode",
2370                 .info = alc_ch_mode_info,
2371                 .get = alc_ch_mode_get,
2372                 .put = alc_ch_mode_put,
2373         },
2374         { } /* end */
2375 };
2376
2377 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2378         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2379         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2380         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2381         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2382         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2383         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2384         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2385         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2386         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2387         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2388         { } /* end */
2389 };
2390
2391 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2392         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2393         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2394         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2395         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2396         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2397         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2398         { } /* end */
2399 };
2400
2401 /*
2402  * virtual master controls
2403  */
2404
2405 /*
2406  * slave controls for virtual master
2407  */
2408 static const char *alc_slave_vols[] = {
2409         "Front Playback Volume",
2410         "Surround Playback Volume",
2411         "Center Playback Volume",
2412         "LFE Playback Volume",
2413         "Side Playback Volume",
2414         "Headphone Playback Volume",
2415         "Speaker Playback Volume",
2416         "Mono Playback Volume",
2417         "Line-Out Playback Volume",
2418         "PCM Playback Volume",
2419         NULL,
2420 };
2421
2422 static const char *alc_slave_sws[] = {
2423         "Front Playback Switch",
2424         "Surround Playback Switch",
2425         "Center Playback Switch",
2426         "LFE Playback Switch",
2427         "Side Playback Switch",
2428         "Headphone Playback Switch",
2429         "Speaker Playback Switch",
2430         "Mono Playback Switch",
2431         "IEC958 Playback Switch",
2432         "Line-Out Playback Switch",
2433         "PCM Playback Switch",
2434         NULL,
2435 };
2436
2437 /*
2438  * build control elements
2439  */
2440
2441 #define NID_MAPPING             (-1)
2442
2443 #define SUBDEV_SPEAKER_         (0 << 6)
2444 #define SUBDEV_HP_              (1 << 6)
2445 #define SUBDEV_LINE_            (2 << 6)
2446 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2447 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2448 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2449
2450 static void alc_free_kctls(struct hda_codec *codec);
2451
2452 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2453 /* additional beep mixers; the actual parameters are overwritten at build */
2454 static struct snd_kcontrol_new alc_beep_mixer[] = {
2455         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2456         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2457         { } /* end */
2458 };
2459 #endif
2460
2461 static int alc_build_controls(struct hda_codec *codec)
2462 {
2463         struct alc_spec *spec = codec->spec;
2464         struct snd_kcontrol *kctl;
2465         struct snd_kcontrol_new *knew;
2466         int i, j, err;
2467         unsigned int u;
2468         hda_nid_t nid;
2469
2470         for (i = 0; i < spec->num_mixers; i++) {
2471                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2472                 if (err < 0)
2473                         return err;
2474         }
2475         if (spec->cap_mixer) {
2476                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2477                 if (err < 0)
2478                         return err;
2479         }
2480         if (spec->multiout.dig_out_nid) {
2481                 err = snd_hda_create_spdif_out_ctls(codec,
2482                                                     spec->multiout.dig_out_nid);
2483                 if (err < 0)
2484                         return err;
2485                 if (!spec->no_analog) {
2486                         err = snd_hda_create_spdif_share_sw(codec,
2487                                                             &spec->multiout);
2488                         if (err < 0)
2489                                 return err;
2490                         spec->multiout.share_spdif = 1;
2491                 }
2492         }
2493         if (spec->dig_in_nid) {
2494                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2495                 if (err < 0)
2496                         return err;
2497         }
2498
2499 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2500         /* create beep controls if needed */
2501         if (spec->beep_amp) {
2502                 struct snd_kcontrol_new *knew;
2503                 for (knew = alc_beep_mixer; knew->name; knew++) {
2504                         struct snd_kcontrol *kctl;
2505                         kctl = snd_ctl_new1(knew, codec);
2506                         if (!kctl)
2507                                 return -ENOMEM;
2508                         kctl->private_value = spec->beep_amp;
2509                         err = snd_hda_ctl_add(codec, 0, kctl);
2510                         if (err < 0)
2511                                 return err;
2512                 }
2513         }
2514 #endif
2515
2516         /* if we have no master control, let's create it */
2517         if (!spec->no_analog &&
2518             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2519                 unsigned int vmaster_tlv[4];
2520                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2521                                         HDA_OUTPUT, vmaster_tlv);
2522                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2523                                           vmaster_tlv, alc_slave_vols);
2524                 if (err < 0)
2525                         return err;
2526         }
2527         if (!spec->no_analog &&
2528             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2529                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2530                                           NULL, alc_slave_sws);
2531                 if (err < 0)
2532                         return err;
2533         }
2534
2535         /* assign Capture Source enums to NID */
2536         kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2537         if (!kctl)
2538                 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2539         for (i = 0; kctl && i < kctl->count; i++) {
2540                 hda_nid_t *nids = spec->capsrc_nids;
2541                 if (!nids)
2542                         nids = spec->adc_nids;
2543                 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2544                 if (err < 0)
2545                         return err;
2546         }
2547         if (spec->cap_mixer) {
2548                 const char *kname = kctl ? kctl->id.name : NULL;
2549                 for (knew = spec->cap_mixer; knew->name; knew++) {
2550                         if (kname && strcmp(knew->name, kname) == 0)
2551                                 continue;
2552                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2553                         for (i = 0; kctl && i < kctl->count; i++) {
2554                                 err = snd_hda_add_nid(codec, kctl, i,
2555                                                       spec->adc_nids[i]);
2556                                 if (err < 0)
2557                                         return err;
2558                         }
2559                 }
2560         }
2561
2562         /* other nid->control mapping */
2563         for (i = 0; i < spec->num_mixers; i++) {
2564                 for (knew = spec->mixers[i]; knew->name; knew++) {
2565                         if (knew->iface != NID_MAPPING)
2566                                 continue;
2567                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2568                         if (kctl == NULL)
2569                                 continue;
2570                         u = knew->subdevice;
2571                         for (j = 0; j < 4; j++, u >>= 8) {
2572                                 nid = u & 0x3f;
2573                                 if (nid == 0)
2574                                         continue;
2575                                 switch (u & 0xc0) {
2576                                 case SUBDEV_SPEAKER_:
2577                                         nid = spec->autocfg.speaker_pins[nid];
2578                                         break;
2579                                 case SUBDEV_LINE_:
2580                                         nid = spec->autocfg.line_out_pins[nid];
2581                                         break;
2582                                 case SUBDEV_HP_:
2583                                         nid = spec->autocfg.hp_pins[nid];
2584                                         break;
2585                                 default:
2586                                         continue;
2587                                 }
2588                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2589                                 if (err < 0)
2590                                         return err;
2591                         }
2592                         u = knew->private_value;
2593                         for (j = 0; j < 4; j++, u >>= 8) {
2594                                 nid = u & 0xff;
2595                                 if (nid == 0)
2596                                         continue;
2597                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2598                                 if (err < 0)
2599                                         return err;
2600                         }
2601                 }
2602         }
2603
2604         alc_free_kctls(codec); /* no longer needed */
2605
2606         return 0;
2607 }
2608
2609
2610 /*
2611  * initialize the codec volumes, etc
2612  */
2613
2614 /*
2615  * generic initialization of ADC, input mixers and output mixers
2616  */
2617 static struct hda_verb alc880_volume_init_verbs[] = {
2618         /*
2619          * Unmute ADC0-2 and set the default input to mic-in
2620          */
2621         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2622         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2623         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2624         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2625         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2626         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2627
2628         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2629          * mixer widget
2630          * Note: PASD motherboards uses the Line In 2 as the input for front
2631          * panel mic (mic 2)
2632          */
2633         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2634         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2635         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2636         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2637         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2638         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2639         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2641
2642         /*
2643          * Set up output mixers (0x0c - 0x0f)
2644          */
2645         /* set vol=0 to output mixers */
2646         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2647         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2648         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2649         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2650         /* set up input amps for analog loopback */
2651         /* Amp Indices: DAC = 0, mixer = 1 */
2652         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2653         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2654         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2655         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2656         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2657         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2658         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2659         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2660
2661         { }
2662 };
2663
2664 /*
2665  * 3-stack pin configuration:
2666  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2667  */
2668 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2669         /*
2670          * preset connection lists of input pins
2671          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2672          */
2673         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2674         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2675         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2676
2677         /*
2678          * Set pin mode and muting
2679          */
2680         /* set front pin widgets 0x14 for output */
2681         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2682         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2683         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2684         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2685         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2686         /* Mic2 (as headphone out) for HP output */
2687         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2688         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2689         /* Line In pin widget for input */
2690         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2691         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2692         /* Line2 (as front mic) pin widget for input and vref at 80% */
2693         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2694         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2695         /* CD pin widget for input */
2696         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2697
2698         { }
2699 };
2700
2701 /*
2702  * 5-stack pin configuration:
2703  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2704  * line-in/side = 0x1a, f-mic = 0x1b
2705  */
2706 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2707         /*
2708          * preset connection lists of input pins
2709          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2710          */
2711         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2712         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2713
2714         /*
2715          * Set pin mode and muting
2716          */
2717         /* set pin widgets 0x14-0x17 for output */
2718         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2719         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2720         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2721         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2722         /* unmute pins for output (no gain on this amp) */
2723         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2724         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2725         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2726         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2727
2728         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2729         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2730         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2731         /* Mic2 (as headphone out) for HP output */
2732         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2733         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734         /* Line In pin widget for input */
2735         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2736         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2737         /* Line2 (as front mic) pin widget for input and vref at 80% */
2738         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2739         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2740         /* CD pin widget for input */
2741         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2742
2743         { }
2744 };
2745
2746 /*
2747  * W810 pin configuration:
2748  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2749  */
2750 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2751         /* hphone/speaker input selector: front DAC */
2752         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2753
2754         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2755         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2756         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2757         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2758         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2759         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2760
2761         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2762         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2763
2764         { }
2765 };
2766
2767 /*
2768  * Z71V pin configuration:
2769  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2770  */
2771 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2772         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2773         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2774         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2775         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2776
2777         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2778         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2779         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2780         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2781
2782         { }
2783 };
2784
2785 /*
2786  * 6-stack pin configuration:
2787  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2788  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2789  */
2790 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2791         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2792
2793         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2794         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2795         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2796         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2797         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2798         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2799         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2800         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2801
2802         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2803         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2804         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2805         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2806         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2807         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2808         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2809         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2810         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2811
2812         { }
2813 };
2814
2815 /*
2816  * Uniwill pin configuration:
2817  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2818  * line = 0x1a
2819  */
2820 static struct hda_verb alc880_uniwill_init_verbs[] = {
2821         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2822
2823         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2824         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2825         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2826         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2827         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2828         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2829         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2830         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2831         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2832         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2833         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2834         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2835         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2836         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2837
2838         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2839         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2840         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2841         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2842         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2843         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2844         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2845         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2846         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2847
2848         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2849         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2850
2851         { }
2852 };
2853
2854 /*
2855 * Uniwill P53
2856 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2857  */
2858 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2859         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2860
2861         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2862         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2863         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2864         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2865         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2866         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2867         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2868         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2869         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2870         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2871         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2872         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2873
2874         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2875         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2876         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2877         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2878         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2879         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2880
2881         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2882         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2883
2884         { }
2885 };
2886
2887 static struct hda_verb alc880_beep_init_verbs[] = {
2888         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2889         { }
2890 };
2891
2892 /* auto-toggle front mic */
2893 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2894 {
2895         unsigned int present;
2896         unsigned char bits;
2897
2898         present = snd_hda_jack_detect(codec, 0x18);
2899         bits = present ? HDA_AMP_MUTE : 0;
2900         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2901 }
2902
2903 static void alc880_uniwill_setup(struct hda_codec *codec)
2904 {
2905         struct alc_spec *spec = codec->spec;
2906
2907         spec->autocfg.hp_pins[0] = 0x14;
2908         spec->autocfg.speaker_pins[0] = 0x15;
2909         spec->autocfg.speaker_pins[0] = 0x16;
2910 }
2911
2912 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2913 {
2914         alc_automute_amp(codec);
2915         alc880_uniwill_mic_automute(codec);
2916 }
2917
2918 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2919                                        unsigned int res)
2920 {
2921         /* Looks like the unsol event is incompatible with the standard
2922          * definition.  4bit tag is placed at 28 bit!
2923          */
2924         switch (res >> 28) {
2925         case ALC880_MIC_EVENT:
2926                 alc880_uniwill_mic_automute(codec);
2927                 break;
2928         default:
2929                 alc_automute_amp_unsol_event(codec, res);
2930                 break;
2931         }
2932 }
2933
2934 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2935 {
2936         struct alc_spec *spec = codec->spec;
2937
2938         spec->autocfg.hp_pins[0] = 0x14;
2939         spec->autocfg.speaker_pins[0] = 0x15;
2940 }
2941
2942 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2943 {
2944         unsigned int present;
2945
2946         present = snd_hda_codec_read(codec, 0x21, 0,
2947                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2948         present &= HDA_AMP_VOLMASK;
2949         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2950                                  HDA_AMP_VOLMASK, present);
2951         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2952                                  HDA_AMP_VOLMASK, present);
2953 }
2954
2955 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2956                                            unsigned int res)
2957 {
2958         /* Looks like the unsol event is incompatible with the standard
2959          * definition.  4bit tag is placed at 28 bit!
2960          */
2961         if ((res >> 28) == ALC880_DCVOL_EVENT)
2962                 alc880_uniwill_p53_dcvol_automute(codec);
2963         else
2964                 alc_automute_amp_unsol_event(codec, res);
2965 }
2966
2967 /*
2968  * F1734 pin configuration:
2969  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2970  */
2971 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2972         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2973         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2974         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2975         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2976         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2977
2978         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2979         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2980         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2981         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2982
2983         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2984         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2985         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2986         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2987         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2988         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2989         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2990         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2991         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2992
2993         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2994         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2995
2996         { }
2997 };
2998
2999 /*
3000  * ASUS pin configuration:
3001  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3002  */
3003 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3004         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3005         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3006         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3007         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3008
3009         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3010         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3011         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3012         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3013         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3014         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3015         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3016         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3017
3018         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3019         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3020         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3021         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3022         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3023         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3024         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3025         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3026         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3027
3028         { }
3029 };
3030
3031 /* Enable GPIO mask and set output */
3032 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3033 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3034 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3035
3036 /* Clevo m520g init */
3037 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3038         /* headphone output */
3039         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3040         /* line-out */
3041         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3042         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3043         /* Line-in */
3044         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3045         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3046         /* CD */
3047         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3048         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3049         /* Mic1 (rear panel) */
3050         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3051         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3052         /* Mic2 (front panel) */
3053         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3054         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3055         /* headphone */
3056         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3057         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3058         /* change to EAPD mode */
3059         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3060         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3061
3062         { }
3063 };
3064
3065 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3066         /* change to EAPD mode */
3067         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3068         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3069
3070         /* Headphone output */
3071         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3072         /* Front output*/
3073         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3074         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3075
3076         /* Line In pin widget for input */
3077         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3078         /* CD pin widget for input */
3079         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3080         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3081         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3082
3083         /* change to EAPD mode */
3084         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3085         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3086
3087         { }
3088 };
3089
3090 /*
3091  * LG m1 express dual
3092  *
3093  * Pin assignment:
3094  *   Rear Line-In/Out (blue): 0x14
3095  *   Build-in Mic-In: 0x15
3096  *   Speaker-out: 0x17
3097  *   HP-Out (green): 0x1b
3098  *   Mic-In/Out (red): 0x19
3099  *   SPDIF-Out: 0x1e
3100  */
3101
3102 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3103 static hda_nid_t alc880_lg_dac_nids[3] = {
3104         0x05, 0x02, 0x03
3105 };
3106
3107 /* seems analog CD is not working */
3108 static struct hda_input_mux alc880_lg_capture_source = {
3109         .num_items = 3,
3110         .items = {
3111                 { "Mic", 0x1 },
3112                 { "Line", 0x5 },
3113                 { "Internal Mic", 0x6 },
3114         },
3115 };
3116
3117 /* 2,4,6 channel modes */
3118 static struct hda_verb alc880_lg_ch2_init[] = {
3119         /* set line-in and mic-in to input */
3120         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3121         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3122         { }
3123 };
3124
3125 static struct hda_verb alc880_lg_ch4_init[] = {
3126         /* set line-in to out and mic-in to input */
3127         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3128         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3129         { }
3130 };
3131
3132 static struct hda_verb alc880_lg_ch6_init[] = {
3133         /* set line-in and mic-in to output */
3134         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3135         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3136         { }
3137 };
3138
3139 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3140         { 2, alc880_lg_ch2_init },
3141         { 4, alc880_lg_ch4_init },
3142         { 6, alc880_lg_ch6_init },
3143 };
3144
3145 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3146         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3147         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3148         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3149         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3150         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3151         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3152         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3153         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3154         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3155         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3156         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3157         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3158         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3159         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3160         {
3161                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3162                 .name = "Channel Mode",
3163                 .info = alc_ch_mode_info,
3164                 .get = alc_ch_mode_get,
3165                 .put = alc_ch_mode_put,
3166         },
3167         { } /* end */
3168 };
3169
3170 static struct hda_verb alc880_lg_init_verbs[] = {
3171         /* set capture source to mic-in */
3172         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3173         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3174         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3175         /* mute all amp mixer inputs */
3176         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3177         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3178         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3179         /* line-in to input */
3180         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3181         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3182         /* built-in mic */
3183         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3184         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3185         /* speaker-out */
3186         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3187         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3188         /* mic-in to input */
3189         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3190         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3191         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3192         /* HP-out */
3193         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3194         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3195         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3196         /* jack sense */
3197         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3198         { }
3199 };
3200
3201 /* toggle speaker-output according to the hp-jack state */
3202 static void alc880_lg_setup(struct hda_codec *codec)
3203 {
3204         struct alc_spec *spec = codec->spec;
3205
3206         spec->autocfg.hp_pins[0] = 0x1b;
3207         spec->autocfg.speaker_pins[0] = 0x17;
3208 }
3209
3210 /*
3211  * LG LW20
3212  *
3213  * Pin assignment:
3214  *   Speaker-out: 0x14
3215  *   Mic-In: 0x18
3216  *   Built-in Mic-In: 0x19
3217  *   Line-In: 0x1b
3218  *   HP-Out: 0x1a
3219  *   SPDIF-Out: 0x1e
3220  */
3221
3222 static struct hda_input_mux alc880_lg_lw_capture_source = {
3223         .num_items = 3,
3224         .items = {
3225                 { "Mic", 0x0 },
3226                 { "Internal Mic", 0x1 },
3227                 { "Line In", 0x2 },
3228         },
3229 };
3230
3231 #define alc880_lg_lw_modes alc880_threestack_modes
3232
3233 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3234         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3235         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3236         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3237         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3238         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3239         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3240         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3241         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3242         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3243         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3244         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3245         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3246         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3247         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3248         {
3249                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3250                 .name = "Channel Mode",
3251                 .info = alc_ch_mode_info,
3252                 .get = alc_ch_mode_get,
3253                 .put = alc_ch_mode_put,
3254         },
3255         { } /* end */
3256 };
3257
3258 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3259         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3260         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3261         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3262
3263         /* set capture source to mic-in */
3264         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3265         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3266         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3267         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3268         /* speaker-out */
3269         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3270         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3271         /* HP-out */
3272         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3273         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3274         /* mic-in to input */
3275         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3276         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3277         /* built-in mic */
3278         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3279         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3280         /* jack sense */
3281         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3282         { }
3283 };
3284
3285 /* toggle speaker-output according to the hp-jack state */
3286 static void alc880_lg_lw_setup(struct hda_codec *codec)
3287 {
3288         struct alc_spec *spec = codec->spec;
3289
3290         spec->autocfg.hp_pins[0] = 0x1b;
3291         spec->autocfg.speaker_pins[0] = 0x14;
3292 }
3293
3294 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3295         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3296         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3297         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3298         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3299         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3300         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3301         { } /* end */
3302 };
3303
3304 static struct hda_input_mux alc880_medion_rim_capture_source = {
3305         .num_items = 2,
3306         .items = {
3307                 { "Mic", 0x0 },
3308                 { "Internal Mic", 0x1 },
3309         },
3310 };
3311
3312 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3313         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3314
3315         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3316         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3317
3318         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3319         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3320         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3321         /* Mic2 (as headphone out) for HP output */
3322         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3323         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3324         /* Internal Speaker */
3325         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3326         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3327
3328         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3329         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3330
3331         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3332         { }
3333 };
3334
3335 /* toggle speaker-output according to the hp-jack state */
3336 static void alc880_medion_rim_automute(struct hda_codec *codec)
3337 {
3338         struct alc_spec *spec = codec->spec;
3339         alc_automute_amp(codec);
3340         /* toggle EAPD */
3341         if (spec->jack_present)
3342                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3343         else
3344                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3345 }
3346
3347 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3348                                           unsigned int res)
3349 {
3350         /* Looks like the unsol event is incompatible with the standard
3351          * definition.  4bit tag is placed at 28 bit!
3352          */
3353         if ((res >> 28) == ALC880_HP_EVENT)
3354                 alc880_medion_rim_automute(codec);
3355 }
3356
3357 static void alc880_medion_rim_setup(struct hda_codec *codec)
3358 {
3359         struct alc_spec *spec = codec->spec;
3360
3361         spec->autocfg.hp_pins[0] = 0x14;
3362         spec->autocfg.speaker_pins[0] = 0x1b;
3363 }
3364
3365 #ifdef CONFIG_SND_HDA_POWER_SAVE
3366 static struct hda_amp_list alc880_loopbacks[] = {
3367         { 0x0b, HDA_INPUT, 0 },
3368         { 0x0b, HDA_INPUT, 1 },
3369         { 0x0b, HDA_INPUT, 2 },
3370         { 0x0b, HDA_INPUT, 3 },
3371         { 0x0b, HDA_INPUT, 4 },
3372         { } /* end */
3373 };
3374
3375 static struct hda_amp_list alc880_lg_loopbacks[] = {
3376         { 0x0b, HDA_INPUT, 1 },
3377         { 0x0b, HDA_INPUT, 6 },
3378         { 0x0b, HDA_INPUT, 7 },
3379         { } /* end */
3380 };
3381 #endif
3382
3383 /*
3384  * Common callbacks
3385  */
3386
3387 static int alc_init(struct hda_codec *codec)
3388 {
3389         struct alc_spec *spec = codec->spec;
3390         unsigned int i;
3391
3392         alc_fix_pll(codec);
3393         alc_auto_init_amp(codec, spec->init_amp);
3394
3395         for (i = 0; i < spec->num_init_verbs; i++)
3396                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3397
3398         if (spec->init_hook)
3399                 spec->init_hook(codec);
3400
3401         return 0;
3402 }
3403
3404 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3405 {
3406         struct alc_spec *spec = codec->spec;
3407
3408         if (spec->unsol_event)
3409                 spec->unsol_event(codec, res);
3410 }
3411
3412 #ifdef CONFIG_SND_HDA_POWER_SAVE
3413 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3414 {
3415         struct alc_spec *spec = codec->spec;
3416         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3417 }
3418 #endif
3419
3420 /*
3421  * Analog playback callbacks
3422  */
3423 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3424                                     struct hda_codec *codec,
3425                                     struct snd_pcm_substream *substream)
3426 {
3427         struct alc_spec *spec = codec->spec;
3428         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3429                                              hinfo);
3430 }
3431
3432 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3433                                        struct hda_codec *codec,
3434                                        unsigned int stream_tag,
3435                                        unsigned int format,
3436                                        struct snd_pcm_substream *substream)
3437 {
3438         struct alc_spec *spec = codec->spec;
3439         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3440                                                 stream_tag, format, substream);
3441 }
3442
3443 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3444                                        struct hda_codec *codec,
3445                                        struct snd_pcm_substream *substream)
3446 {
3447         struct alc_spec *spec = codec->spec;
3448         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3449 }
3450
3451 /*
3452  * Digital out
3453  */
3454 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3455                                         struct hda_codec *codec,
3456                                         struct snd_pcm_substream *substream)
3457 {
3458         struct alc_spec *spec = codec->spec;
3459         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3460 }
3461
3462 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3463                                            struct hda_codec *codec,
3464                                            unsigned int stream_tag,
3465                                            unsigned int format,
3466                                            struct snd_pcm_substream *substream)
3467 {
3468         struct alc_spec *spec = codec->spec;
3469         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3470                                              stream_tag, format, substream);
3471 }
3472
3473 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3474                                            struct hda_codec *codec,
3475                                            struct snd_pcm_substream *substream)
3476 {
3477         struct alc_spec *spec = codec->spec;
3478         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3479 }
3480
3481 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3482                                          struct hda_codec *codec,
3483                                          struct snd_pcm_substream *substream)
3484 {
3485         struct alc_spec *spec = codec->spec;
3486         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3487 }
3488
3489 /*
3490  * Analog capture
3491  */
3492 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3493                                       struct hda_codec *codec,
3494                                       unsigned int stream_tag,
3495                                       unsigned int format,
3496                                       struct snd_pcm_substream *substream)
3497 {
3498         struct alc_spec *spec = codec->spec;
3499
3500         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3501                                    stream_tag, 0, format);
3502         return 0;
3503 }
3504
3505 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3506                                       struct hda_codec *codec,
3507                                       struct snd_pcm_substream *substream)
3508 {
3509         struct alc_spec *spec = codec->spec;
3510
3511         snd_hda_codec_cleanup_stream(codec,
3512                                      spec->adc_nids[substream->number + 1]);
3513         return 0;
3514 }
3515
3516
3517 /*
3518  */
3519 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3520         .substreams = 1,
3521         .channels_min = 2,
3522         .channels_max = 8,
3523         /* NID is set in alc_build_pcms */
3524         .ops = {
3525                 .open = alc880_playback_pcm_open,
3526                 .prepare = alc880_playback_pcm_prepare,
3527                 .cleanup = alc880_playback_pcm_cleanup
3528         },
3529 };
3530
3531 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3532         .substreams = 1,
3533         .channels_min = 2,
3534         .channels_max = 2,
3535         /* NID is set in alc_build_pcms */
3536 };
3537
3538 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3539         .substreams = 1,
3540         .channels_min = 2,
3541         .channels_max = 2,
3542         /* NID is set in alc_build_pcms */
3543 };
3544
3545 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3546         .substreams = 2, /* can be overridden */
3547         .channels_min = 2,
3548         .channels_max = 2,
3549         /* NID is set in alc_build_pcms */
3550         .ops = {
3551                 .prepare = alc880_alt_capture_pcm_prepare,
3552                 .cleanup = alc880_alt_capture_pcm_cleanup
3553         },
3554 };
3555
3556 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3557         .substreams = 1,
3558         .channels_min = 2,
3559         .channels_max = 2,
3560         /* NID is set in alc_build_pcms */
3561         .ops = {
3562                 .open = alc880_dig_playback_pcm_open,
3563                 .close = alc880_dig_playback_pcm_close,
3564                 .prepare = alc880_dig_playback_pcm_prepare,
3565                 .cleanup = alc880_dig_playback_pcm_cleanup
3566         },
3567 };
3568
3569 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3570         .substreams = 1,
3571         .channels_min = 2,
3572         .channels_max = 2,
3573         /* NID is set in alc_build_pcms */
3574 };
3575
3576 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3577 static struct hda_pcm_stream alc_pcm_null_stream = {
3578         .substreams = 0,
3579         .channels_min = 0,
3580         .channels_max = 0,
3581 };
3582
3583 static int alc_build_pcms(struct hda_codec *codec)
3584 {
3585         struct alc_spec *spec = codec->spec;
3586         struct hda_pcm *info = spec->pcm_rec;
3587         int i;
3588
3589         codec->num_pcms = 1;
3590         codec->pcm_info = info;
3591
3592         if (spec->no_analog)
3593                 goto skip_analog;
3594
3595         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3596                  "%s Analog", codec->chip_name);
3597         info->name = spec->stream_name_analog;
3598
3599         if (spec->stream_analog_playback) {
3600                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3601                         return -EINVAL;
3602                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3603                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3604         }
3605         if (spec->stream_analog_capture) {
3606                 if (snd_BUG_ON(!spec->adc_nids))
3607                         return -EINVAL;
3608                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3609                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3610         }
3611
3612         if (spec->channel_mode) {
3613                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3614                 for (i = 0; i < spec->num_channel_mode; i++) {
3615                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3616                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3617                         }
3618                 }
3619         }
3620
3621  skip_analog:
3622         /* SPDIF for stream index #1 */
3623         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3624                 snprintf(spec->stream_name_digital,
3625                          sizeof(spec->stream_name_digital),
3626                          "%s Digital", codec->chip_name);
3627                 codec->num_pcms = 2;
3628                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3629                 info = spec->pcm_rec + 1;
3630                 info->name = spec->stream_name_digital;
3631                 if (spec->dig_out_type)
3632                         info->pcm_type = spec->dig_out_type;
3633                 else
3634                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3635                 if (spec->multiout.dig_out_nid &&
3636                     spec->stream_digital_playback) {
3637                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3638                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3639                 }
3640                 if (spec->dig_in_nid &&
3641                     spec->stream_digital_capture) {
3642                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3643                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3644                 }
3645                 /* FIXME: do we need this for all Realtek codec models? */
3646                 codec->spdif_status_reset = 1;
3647         }
3648
3649         if (spec->no_analog)
3650                 return 0;
3651
3652         /* If the use of more than one ADC is requested for the current
3653          * model, configure a second analog capture-only PCM.
3654          */
3655         /* Additional Analaog capture for index #2 */
3656         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3657             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3658                 codec->num_pcms = 3;
3659                 info = spec->pcm_rec + 2;
3660                 info->name = spec->stream_name_analog;
3661                 if (spec->alt_dac_nid) {
3662                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3663                                 *spec->stream_analog_alt_playback;
3664                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3665                                 spec->alt_dac_nid;
3666                 } else {
3667                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3668                                 alc_pcm_null_stream;
3669                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3670                 }
3671                 if (spec->num_adc_nids > 1) {
3672                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3673                                 *spec->stream_analog_alt_capture;
3674                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3675                                 spec->adc_nids[1];
3676                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3677                                 spec->num_adc_nids - 1;
3678                 } else {
3679                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3680                                 alc_pcm_null_stream;
3681                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3682                 }
3683         }
3684
3685         return 0;
3686 }
3687
3688 static inline void alc_shutup(struct hda_codec *codec)
3689 {
3690         snd_hda_shutup_pins(codec);
3691 }
3692
3693 static void alc_free_kctls(struct hda_codec *codec)
3694 {
3695         struct alc_spec *spec = codec->spec;
3696
3697         if (spec->kctls.list) {
3698                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3699                 int i;
3700                 for (i = 0; i < spec->kctls.used; i++)
3701                         kfree(kctl[i].name);
3702         }
3703         snd_array_free(&spec->kctls);
3704 }
3705
3706 static void alc_free(struct hda_codec *codec)
3707 {
3708         struct alc_spec *spec = codec->spec;
3709
3710         if (!spec)
3711                 return;
3712
3713         alc_shutup(codec);
3714         alc_free_kctls(codec);
3715         kfree(spec);
3716         snd_hda_detach_beep_device(codec);
3717 }
3718
3719 #ifdef CONFIG_SND_HDA_POWER_SAVE
3720 static void alc_power_eapd(struct hda_codec *codec)
3721 {
3722         /* We currently only handle front, HP */
3723         switch (codec->vendor_id) {
3724         case 0x10ec0260:
3725                 set_eapd(codec, 0x0f, 0);
3726                 set_eapd(codec, 0x10, 0);
3727                 break;
3728         case 0x10ec0262:
3729         case 0x10ec0267:
3730         case 0x10ec0268:
3731         case 0x10ec0269:
3732         case 0x10ec0270:
3733         case 0x10ec0272:
3734         case 0x10ec0660:
3735         case 0x10ec0662:
3736         case 0x10ec0663:
3737         case 0x10ec0862:
3738         case 0x10ec0889:
3739                 set_eapd(codec, 0x14, 0);
3740                 set_eapd(codec, 0x15, 0);
3741                 break;
3742         }
3743 }
3744
3745 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3746 {
3747         struct alc_spec *spec = codec->spec;
3748         alc_shutup(codec);
3749         if (spec && spec->power_hook)
3750                 spec->power_hook(codec);
3751         return 0;
3752 }
3753 #endif
3754
3755 #ifdef SND_HDA_NEEDS_RESUME
3756 static int alc_resume(struct hda_codec *codec)
3757 {
3758         codec->patch_ops.init(codec);
3759         snd_hda_codec_resume_amp(codec);
3760         snd_hda_codec_resume_cache(codec);
3761         return 0;
3762 }
3763 #endif
3764
3765 /*
3766  */
3767 static struct hda_codec_ops alc_patch_ops = {
3768         .build_controls = alc_build_controls,
3769         .build_pcms = alc_build_pcms,
3770         .init = alc_init,
3771         .free = alc_free,
3772         .unsol_event = alc_unsol_event,
3773 #ifdef SND_HDA_NEEDS_RESUME
3774         .resume = alc_resume,
3775 #endif
3776 #ifdef CONFIG_SND_HDA_POWER_SAVE
3777         .suspend = alc_suspend,
3778         .check_power_status = alc_check_power_status,
3779 #endif
3780         .reboot_notify = alc_shutup,
3781 };
3782
3783
3784 /*
3785  * Test configuration for debugging
3786  *
3787  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3788  * enum controls.
3789  */
3790 #ifdef CONFIG_SND_DEBUG
3791 static hda_nid_t alc880_test_dac_nids[4] = {
3792         0x02, 0x03, 0x04, 0x05
3793 };
3794
3795 static struct hda_input_mux alc880_test_capture_source = {
3796         .num_items = 7,
3797         .items = {
3798                 { "In-1", 0x0 },
3799                 { "In-2", 0x1 },
3800                 { "In-3", 0x2 },
3801                 { "In-4", 0x3 },
3802                 { "CD", 0x4 },
3803                 { "Front", 0x5 },
3804                 { "Surround", 0x6 },
3805         },
3806 };
3807
3808 static struct hda_channel_mode alc880_test_modes[4] = {
3809         { 2, NULL },
3810         { 4, NULL },
3811         { 6, NULL },
3812         { 8, NULL },
3813 };
3814
3815 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3816                                  struct snd_ctl_elem_info *uinfo)
3817 {
3818         static char *texts[] = {
3819                 "N/A", "Line Out", "HP Out",
3820                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3821         };
3822         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3823         uinfo->count = 1;
3824         uinfo->value.enumerated.items = 8;
3825         if (uinfo->value.enumerated.item >= 8)
3826                 uinfo->value.enumerated.item = 7;
3827         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3828         return 0;
3829 }
3830
3831 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3832                                 struct snd_ctl_elem_value *ucontrol)
3833 {
3834         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3835         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3836         unsigned int pin_ctl, item = 0;
3837
3838         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3839                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3840         if (pin_ctl & AC_PINCTL_OUT_EN) {
3841                 if (pin_ctl & AC_PINCTL_HP_EN)
3842                         item = 2;
3843                 else
3844                         item = 1;
3845         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3846                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3847                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3848                 case AC_PINCTL_VREF_50:  item = 4; break;
3849                 case AC_PINCTL_VREF_GRD: item = 5; break;
3850                 case AC_PINCTL_VREF_80:  item = 6; break;
3851                 case AC_PINCTL_VREF_100: item = 7; break;
3852                 }
3853         }
3854         ucontrol->value.enumerated.item[0] = item;
3855         return 0;
3856 }
3857
3858 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3859                                 struct snd_ctl_elem_value *ucontrol)
3860 {
3861         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3862         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3863         static unsigned int ctls[] = {
3864                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3865                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3866                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3867                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3868                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3869                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3870         };
3871         unsigned int old_ctl, new_ctl;
3872
3873         old_ctl = snd_hda_codec_read(codec, nid, 0,
3874                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3875         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3876         if (old_ctl != new_ctl) {
3877                 int val;
3878                 snd_hda_codec_write_cache(codec, nid, 0,
3879                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3880                                           new_ctl);
3881                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3882                         HDA_AMP_MUTE : 0;
3883                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3884                                          HDA_AMP_MUTE, val);
3885                 return 1;
3886         }
3887         return 0;
3888 }
3889
3890 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3891                                  struct snd_ctl_elem_info *uinfo)
3892 {
3893         static char *texts[] = {
3894                 "Front", "Surround", "CLFE", "Side"
3895         };
3896         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3897         uinfo->count = 1;
3898         uinfo->value.enumerated.items = 4;
3899         if (uinfo->value.enumerated.item >= 4)
3900                 uinfo->value.enumerated.item = 3;
3901         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3902         return 0;
3903 }
3904
3905 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3906                                 struct snd_ctl_elem_value *ucontrol)
3907 {
3908         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3909         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3910         unsigned int sel;
3911
3912         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3913         ucontrol->value.enumerated.item[0] = sel & 3;
3914         return 0;
3915 }
3916
3917 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3918                                 struct snd_ctl_elem_value *ucontrol)
3919 {
3920         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3921         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3922         unsigned int sel;
3923
3924         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3925         if (ucontrol->value.enumerated.item[0] != sel) {
3926                 sel = ucontrol->value.enumerated.item[0] & 3;
3927                 snd_hda_codec_write_cache(codec, nid, 0,
3928                                           AC_VERB_SET_CONNECT_SEL, sel);
3929                 return 1;
3930         }
3931         return 0;
3932 }
3933
3934 #define PIN_CTL_TEST(xname,nid) {                       \
3935                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3936                         .name = xname,                 \
3937                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3938                         .info = alc_test_pin_ctl_info, \
3939                         .get = alc_test_pin_ctl_get,   \
3940                         .put = alc_test_pin_ctl_put,   \
3941                         .private_value = nid           \
3942                         }
3943
3944 #define PIN_SRC_TEST(xname,nid) {                       \
3945                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3946                         .name = xname,                 \
3947                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3948                         .info = alc_test_pin_src_info, \
3949                         .get = alc_test_pin_src_get,   \
3950                         .put = alc_test_pin_src_put,   \
3951                         .private_value = nid           \
3952                         }
3953
3954 static struct snd_kcontrol_new alc880_test_mixer[] = {
3955         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3956         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3957         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3958         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3959         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3960         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3961         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3962         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3963         PIN_CTL_TEST("Front Pin Mode", 0x14),
3964         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3965         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3966         PIN_CTL_TEST("Side Pin Mode", 0x17),
3967         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3968         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3969         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3970         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3971         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3972         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3973         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3974         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3975         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3976         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3977         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3978         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3979         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3980         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3981         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3982         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3983         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3984         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3985         {
3986                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3987                 .name = "Channel Mode",
3988                 .info = alc_ch_mode_info,
3989                 .get = alc_ch_mode_get,
3990                 .put = alc_ch_mode_put,
3991         },
3992         { } /* end */
3993 };
3994
3995 static struct hda_verb alc880_test_init_verbs[] = {
3996         /* Unmute inputs of 0x0c - 0x0f */
3997         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3998         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3999         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4000         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4001         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4002         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4003         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4004         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4005         /* Vol output for 0x0c-0x0f */
4006         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4007         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4008         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4009         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4010         /* Set output pins 0x14-0x17 */
4011         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4012         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4013         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4014         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4015         /* Unmute output pins 0x14-0x17 */
4016         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4017         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4018         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4019         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4020         /* Set input pins 0x18-0x1c */
4021         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4022         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4023         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4024         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4025         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4026         /* Mute input pins 0x18-0x1b */
4027         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4028         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4029         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4030         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4031         /* ADC set up */
4032         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4033         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4034         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4035         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4036         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4037         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4038         /* Analog input/passthru */
4039         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4040         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4041         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4042         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4043         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4044         { }
4045 };
4046 #endif
4047
4048 /*
4049  */
4050
4051 static const char *alc880_models[ALC880_MODEL_LAST] = {
4052         [ALC880_3ST]            = "3stack",
4053         [ALC880_TCL_S700]       = "tcl",
4054         [ALC880_3ST_DIG]        = "3stack-digout",
4055         [ALC880_CLEVO]          = "clevo",
4056         [ALC880_5ST]            = "5stack",
4057         [ALC880_5ST_DIG]        = "5stack-digout",
4058         [ALC880_W810]           = "w810",
4059         [ALC880_Z71V]           = "z71v",
4060         [ALC880_6ST]            = "6stack",
4061         [ALC880_6ST_DIG]        = "6stack-digout",
4062         [ALC880_ASUS]           = "asus",
4063         [ALC880_ASUS_W1V]       = "asus-w1v",
4064         [ALC880_ASUS_DIG]       = "asus-dig",
4065         [ALC880_ASUS_DIG2]      = "asus-dig2",
4066         [ALC880_UNIWILL_DIG]    = "uniwill",
4067         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4068         [ALC880_FUJITSU]        = "fujitsu",
4069         [ALC880_F1734]          = "F1734",
4070         [ALC880_LG]             = "lg",
4071         [ALC880_LG_LW]          = "lg-lw",
4072         [ALC880_MEDION_RIM]     = "medion",
4073 #ifdef CONFIG_SND_DEBUG
4074         [ALC880_TEST]           = "test",
4075 #endif
4076         [ALC880_AUTO]           = "auto",
4077 };
4078
4079 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4080         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4081         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4082         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4083         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4084         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4085         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4086         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4087         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4088         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4089         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4090         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4091         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4092         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4093         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4094         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4095         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4096         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4097         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4098         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4099         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4100         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4101         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4102         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4103         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4104         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4105         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4106         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4107         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4108         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4109         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4110         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4111         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4112         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4113         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4114         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4115         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4116         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4117         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4118         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4119         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4120         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4121         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4122         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4123         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4124         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4125         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4126         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4127         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4128         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4129         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4130         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4131         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4132         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4133         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4134         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4135         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4136         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4137         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4138         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4139         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4140         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4141         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4142         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4143         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4144         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4145         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4146         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4147         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4148         /* default Intel */
4149         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4150         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4151         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4152         {}
4153 };
4154
4155 /*
4156  * ALC880 codec presets
4157  */
4158 static struct alc_config_preset alc880_presets[] = {
4159         [ALC880_3ST] = {
4160                 .mixers = { alc880_three_stack_mixer },
4161                 .init_verbs = { alc880_volume_init_verbs,
4162                                 alc880_pin_3stack_init_verbs },
4163                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4164                 .dac_nids = alc880_dac_nids,
4165                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4166                 .channel_mode = alc880_threestack_modes,
4167                 .need_dac_fix = 1,
4168                 .input_mux = &alc880_capture_source,
4169         },
4170         [ALC880_3ST_DIG] = {
4171                 .mixers = { alc880_three_stack_mixer },
4172                 .init_verbs = { alc880_volume_init_verbs,
4173                                 alc880_pin_3stack_init_verbs },
4174                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4175                 .dac_nids = alc880_dac_nids,
4176                 .dig_out_nid = ALC880_DIGOUT_NID,
4177                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4178                 .channel_mode = alc880_threestack_modes,
4179                 .need_dac_fix = 1,
4180                 .input_mux = &alc880_capture_source,
4181         },
4182         [ALC880_TCL_S700] = {
4183                 .mixers = { alc880_tcl_s700_mixer },
4184                 .init_verbs = { alc880_volume_init_verbs,
4185                                 alc880_pin_tcl_S700_init_verbs,
4186                                 alc880_gpio2_init_verbs },
4187                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4188                 .dac_nids = alc880_dac_nids,
4189                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4190                 .num_adc_nids = 1, /* single ADC */
4191                 .hp_nid = 0x03,
4192                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4193                 .channel_mode = alc880_2_jack_modes,
4194                 .input_mux = &alc880_capture_source,
4195         },
4196         [ALC880_5ST] = {
4197                 .mixers = { alc880_three_stack_mixer,
4198                             alc880_five_stack_mixer},
4199                 .init_verbs = { alc880_volume_init_verbs,
4200                                 alc880_pin_5stack_init_verbs },
4201                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4202                 .dac_nids = alc880_dac_nids,
4203                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4204                 .channel_mode = alc880_fivestack_modes,
4205                 .input_mux = &alc880_capture_source,
4206         },
4207         [ALC880_5ST_DIG] = {
4208                 .mixers = { alc880_three_stack_mixer,
4209                             alc880_five_stack_mixer },
4210                 .init_verbs = { alc880_volume_init_verbs,
4211                                 alc880_pin_5stack_init_verbs },
4212                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4213                 .dac_nids = alc880_dac_nids,
4214                 .dig_out_nid = ALC880_DIGOUT_NID,
4215                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4216                 .channel_mode = alc880_fivestack_modes,
4217                 .input_mux = &alc880_capture_source,
4218         },
4219         [ALC880_6ST] = {
4220                 .mixers = { alc880_six_stack_mixer },
4221                 .init_verbs = { alc880_volume_init_verbs,
4222                                 alc880_pin_6stack_init_verbs },
4223                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4224                 .dac_nids = alc880_6st_dac_nids,
4225                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4226                 .channel_mode = alc880_sixstack_modes,
4227                 .input_mux = &alc880_6stack_capture_source,
4228         },
4229         [ALC880_6ST_DIG] = {
4230                 .mixers = { alc880_six_stack_mixer },
4231                 .init_verbs = { alc880_volume_init_verbs,
4232                                 alc880_pin_6stack_init_verbs },
4233                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4234                 .dac_nids = alc880_6st_dac_nids,
4235                 .dig_out_nid = ALC880_DIGOUT_NID,
4236                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4237                 .channel_mode = alc880_sixstack_modes,
4238                 .input_mux = &alc880_6stack_capture_source,
4239         },
4240         [ALC880_W810] = {
4241                 .mixers = { alc880_w810_base_mixer },
4242                 .init_verbs = { alc880_volume_init_verbs,
4243                                 alc880_pin_w810_init_verbs,
4244                                 alc880_gpio2_init_verbs },
4245                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4246                 .dac_nids = alc880_w810_dac_nids,
4247                 .dig_out_nid = ALC880_DIGOUT_NID,
4248                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4249                 .channel_mode = alc880_w810_modes,
4250                 .input_mux = &alc880_capture_source,
4251         },
4252         [ALC880_Z71V] = {
4253                 .mixers = { alc880_z71v_mixer },
4254                 .init_verbs = { alc880_volume_init_verbs,
4255                                 alc880_pin_z71v_init_verbs },
4256                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4257                 .dac_nids = alc880_z71v_dac_nids,
4258                 .dig_out_nid = ALC880_DIGOUT_NID,
4259                 .hp_nid = 0x03,
4260                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4261                 .channel_mode = alc880_2_jack_modes,
4262                 .input_mux = &alc880_capture_source,
4263         },
4264         [ALC880_F1734] = {
4265                 .mixers = { alc880_f1734_mixer },
4266                 .init_verbs = { alc880_volume_init_verbs,
4267                                 alc880_pin_f1734_init_verbs },
4268                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4269                 .dac_nids = alc880_f1734_dac_nids,
4270                 .hp_nid = 0x02,
4271                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4272                 .channel_mode = alc880_2_jack_modes,
4273                 .input_mux = &alc880_f1734_capture_source,
4274                 .unsol_event = alc880_uniwill_p53_unsol_event,
4275                 .setup = alc880_uniwill_p53_setup,
4276                 .init_hook = alc_automute_amp,
4277         },
4278         [ALC880_ASUS] = {
4279                 .mixers = { alc880_asus_mixer },
4280                 .init_verbs = { alc880_volume_init_verbs,
4281                                 alc880_pin_asus_init_verbs,
4282                                 alc880_gpio1_init_verbs },
4283                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4284                 .dac_nids = alc880_asus_dac_nids,
4285                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4286                 .channel_mode = alc880_asus_modes,
4287                 .need_dac_fix = 1,
4288                 .input_mux = &alc880_capture_source,
4289         },
4290         [ALC880_ASUS_DIG] = {
4291                 .mixers = { alc880_asus_mixer },
4292                 .init_verbs = { alc880_volume_init_verbs,
4293                                 alc880_pin_asus_init_verbs,
4294                                 alc880_gpio1_init_verbs },
4295                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4296                 .dac_nids = alc880_asus_dac_nids,
4297                 .dig_out_nid = ALC880_DIGOUT_NID,
4298                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4299                 .channel_mode = alc880_asus_modes,
4300                 .need_dac_fix = 1,
4301                 .input_mux = &alc880_capture_source,
4302         },
4303         [ALC880_ASUS_DIG2] = {
4304                 .mixers = { alc880_asus_mixer },
4305                 .init_verbs = { alc880_volume_init_verbs,
4306                                 alc880_pin_asus_init_verbs,
4307                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4308                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4309                 .dac_nids = alc880_asus_dac_nids,
4310                 .dig_out_nid = ALC880_DIGOUT_NID,
4311                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4312                 .channel_mode = alc880_asus_modes,
4313                 .need_dac_fix = 1,
4314                 .input_mux = &alc880_capture_source,
4315         },
4316         [ALC880_ASUS_W1V] = {
4317                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4318                 .init_verbs = { alc880_volume_init_verbs,
4319                                 alc880_pin_asus_init_verbs,
4320                                 alc880_gpio1_init_verbs },
4321                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4322                 .dac_nids = alc880_asus_dac_nids,
4323                 .dig_out_nid = ALC880_DIGOUT_NID,
4324                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4325                 .channel_mode = alc880_asus_modes,
4326                 .need_dac_fix = 1,
4327                 .input_mux = &alc880_capture_source,
4328         },
4329         [ALC880_UNIWILL_DIG] = {
4330                 .mixers = { alc880_asus_mixer },
4331                 .init_verbs = { alc880_volume_init_verbs,
4332                                 alc880_pin_asus_init_verbs },
4333                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4334                 .dac_nids = alc880_asus_dac_nids,
4335                 .dig_out_nid = ALC880_DIGOUT_NID,
4336                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4337                 .channel_mode = alc880_asus_modes,
4338                 .need_dac_fix = 1,
4339                 .input_mux = &alc880_capture_source,
4340         },
4341         [ALC880_UNIWILL] = {
4342                 .mixers = { alc880_uniwill_mixer },
4343                 .init_verbs = { alc880_volume_init_verbs,
4344                                 alc880_uniwill_init_verbs },
4345                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4346                 .dac_nids = alc880_asus_dac_nids,
4347                 .dig_out_nid = ALC880_DIGOUT_NID,
4348                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4349                 .channel_mode = alc880_threestack_modes,
4350                 .need_dac_fix = 1,
4351                 .input_mux = &alc880_capture_source,
4352                 .unsol_event = alc880_uniwill_unsol_event,
4353                 .setup = alc880_uniwill_setup,
4354                 .init_hook = alc880_uniwill_init_hook,
4355         },
4356         [ALC880_UNIWILL_P53] = {
4357                 .mixers = { alc880_uniwill_p53_mixer },
4358                 .init_verbs = { alc880_volume_init_verbs,
4359                                 alc880_uniwill_p53_init_verbs },
4360                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4361                 .dac_nids = alc880_asus_dac_nids,
4362                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4363                 .channel_mode = alc880_threestack_modes,
4364                 .input_mux = &alc880_capture_source,
4365                 .unsol_event = alc880_uniwill_p53_unsol_event,
4366                 .setup = alc880_uniwill_p53_setup,
4367                 .init_hook = alc_automute_amp,
4368         },
4369         [ALC880_FUJITSU] = {
4370                 .mixers = { alc880_fujitsu_mixer },
4371                 .init_verbs = { alc880_volume_init_verbs,
4372                                 alc880_uniwill_p53_init_verbs,
4373                                 alc880_beep_init_verbs },
4374                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4375                 .dac_nids = alc880_dac_nids,
4376                 .dig_out_nid = ALC880_DIGOUT_NID,
4377                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4378                 .channel_mode = alc880_2_jack_modes,
4379                 .input_mux = &alc880_capture_source,
4380                 .unsol_event = alc880_uniwill_p53_unsol_event,
4381                 .setup = alc880_uniwill_p53_setup,
4382                 .init_hook = alc_automute_amp,
4383         },
4384         [ALC880_CLEVO] = {
4385                 .mixers = { alc880_three_stack_mixer },
4386                 .init_verbs = { alc880_volume_init_verbs,
4387                                 alc880_pin_clevo_init_verbs },
4388                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4389                 .dac_nids = alc880_dac_nids,
4390                 .hp_nid = 0x03,
4391                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4392                 .channel_mode = alc880_threestack_modes,
4393                 .need_dac_fix = 1,
4394                 .input_mux = &alc880_capture_source,
4395         },
4396         [ALC880_LG] = {
4397                 .mixers = { alc880_lg_mixer },
4398                 .init_verbs = { alc880_volume_init_verbs,
4399                                 alc880_lg_init_verbs },
4400                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4401                 .dac_nids = alc880_lg_dac_nids,
4402                 .dig_out_nid = ALC880_DIGOUT_NID,
4403                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4404                 .channel_mode = alc880_lg_ch_modes,
4405                 .need_dac_fix = 1,
4406                 .input_mux = &alc880_lg_capture_source,
4407                 .unsol_event = alc_automute_amp_unsol_event,
4408                 .setup = alc880_lg_setup,
4409                 .init_hook = alc_automute_amp,
4410 #ifdef CONFIG_SND_HDA_POWER_SAVE
4411                 .loopbacks = alc880_lg_loopbacks,
4412 #endif
4413         },
4414         [ALC880_LG_LW] = {
4415                 .mixers = { alc880_lg_lw_mixer },
4416                 .init_verbs = { alc880_volume_init_verbs,
4417                                 alc880_lg_lw_init_verbs },
4418                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4419                 .dac_nids = alc880_dac_nids,
4420                 .dig_out_nid = ALC880_DIGOUT_NID,
4421                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4422                 .channel_mode = alc880_lg_lw_modes,
4423                 .input_mux = &alc880_lg_lw_capture_source,
4424                 .unsol_event = alc_automute_amp_unsol_event,
4425                 .setup = alc880_lg_lw_setup,
4426                 .init_hook = alc_automute_amp,
4427         },
4428         [ALC880_MEDION_RIM] = {
4429                 .mixers = { alc880_medion_rim_mixer },
4430                 .init_verbs = { alc880_volume_init_verbs,
4431                                 alc880_medion_rim_init_verbs,
4432                                 alc_gpio2_init_verbs },
4433                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4434                 .dac_nids = alc880_dac_nids,
4435                 .dig_out_nid = ALC880_DIGOUT_NID,
4436                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4437                 .channel_mode = alc880_2_jack_modes,
4438                 .input_mux = &alc880_medion_rim_capture_source,
4439                 .unsol_event = alc880_medion_rim_unsol_event,
4440                 .setup = alc880_medion_rim_setup,
4441                 .init_hook = alc880_medion_rim_automute,
4442         },
4443 #ifdef CONFIG_SND_DEBUG
4444         [ALC880_TEST] = {
4445                 .mixers = { alc880_test_mixer },
4446                 .init_verbs = { alc880_test_init_verbs },
4447                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4448                 .dac_nids = alc880_test_dac_nids,
4449                 .dig_out_nid = ALC880_DIGOUT_NID,
4450                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4451                 .channel_mode = alc880_test_modes,
4452                 .input_mux = &alc880_test_capture_source,
4453         },
4454 #endif
4455 };
4456
4457 /*
4458  * Automatic parse of I/O pins from the BIOS configuration
4459  */
4460
4461 enum {
4462         ALC_CTL_WIDGET_VOL,
4463         ALC_CTL_WIDGET_MUTE,
4464         ALC_CTL_BIND_MUTE,
4465 };
4466 static struct snd_kcontrol_new alc880_control_templates[] = {
4467         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4468         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4469         HDA_BIND_MUTE(NULL, 0, 0, 0),
4470 };
4471
4472 /* add dynamic controls */
4473 static int add_control(struct alc_spec *spec, int type, const char *name,
4474                        unsigned long val)
4475 {
4476         struct snd_kcontrol_new *knew;
4477
4478         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4479         knew = snd_array_new(&spec->kctls);
4480         if (!knew)
4481                 return -ENOMEM;
4482         *knew = alc880_control_templates[type];
4483         knew->name = kstrdup(name, GFP_KERNEL);
4484         if (!knew->name)
4485                 return -ENOMEM;
4486         if (get_amp_nid_(val))
4487                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4488         knew->private_value = val;
4489         return 0;
4490 }
4491
4492 static int add_control_with_pfx(struct alc_spec *spec, int type,
4493                                 const char *pfx, const char *dir,
4494                                 const char *sfx, unsigned long val)
4495 {
4496         char name[32];
4497         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4498         return add_control(spec, type, name, val);
4499 }
4500
4501 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4502         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4503 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4504         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4505
4506 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4507 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4508 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4509 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4510 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4511 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4512 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4513 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4514 #define ALC880_PIN_CD_NID               0x1c
4515
4516 /* fill in the dac_nids table from the parsed pin configuration */
4517 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4518                                      const struct auto_pin_cfg *cfg)
4519 {
4520         hda_nid_t nid;
4521         int assigned[4];
4522         int i, j;
4523
4524         memset(assigned, 0, sizeof(assigned));
4525         spec->multiout.dac_nids = spec->private_dac_nids;
4526
4527         /* check the pins hardwired to audio widget */
4528         for (i = 0; i < cfg->line_outs; i++) {
4529                 nid = cfg->line_out_pins[i];
4530                 if (alc880_is_fixed_pin(nid)) {
4531                         int idx = alc880_fixed_pin_idx(nid);
4532                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4533                         assigned[idx] = 1;
4534                 }
4535         }
4536         /* left pins can be connect to any audio widget */
4537         for (i = 0; i < cfg->line_outs; i++) {
4538                 nid = cfg->line_out_pins[i];
4539                 if (alc880_is_fixed_pin(nid))
4540                         continue;
4541                 /* search for an empty channel */
4542                 for (j = 0; j < cfg->line_outs; j++) {
4543                         if (!assigned[j]) {
4544                                 spec->multiout.dac_nids[i] =
4545                                         alc880_idx_to_dac(j);
4546                                 assigned[j] = 1;
4547                                 break;
4548                         }
4549                 }
4550         }
4551         spec->multiout.num_dacs = cfg->line_outs;
4552         return 0;
4553 }
4554
4555 /* add playback controls from the parsed DAC table */
4556 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4557                                              const struct auto_pin_cfg *cfg)
4558 {
4559         static const char *chname[4] = {
4560                 "Front", "Surround", NULL /*CLFE*/, "Side"
4561         };
4562         hda_nid_t nid;
4563         int i, err;
4564
4565         for (i = 0; i < cfg->line_outs; i++) {
4566                 if (!spec->multiout.dac_nids[i])
4567                         continue;
4568                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4569                 if (i == 2) {
4570                         /* Center/LFE */
4571                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4572                                               "Center",
4573                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4574                                                               HDA_OUTPUT));
4575                         if (err < 0)
4576                                 return err;
4577                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4578                                               "LFE",
4579                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4580                                                               HDA_OUTPUT));
4581                         if (err < 0)
4582                                 return err;
4583                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4584                                              "Center",
4585                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4586                                                               HDA_INPUT));
4587                         if (err < 0)
4588                                 return err;
4589                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4590                                              "LFE",
4591                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4592                                                               HDA_INPUT));
4593                         if (err < 0)
4594                                 return err;
4595                 } else {
4596                         const char *pfx;
4597                         if (cfg->line_outs == 1 &&
4598                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4599                                 pfx = "Speaker";
4600                         else
4601                                 pfx = chname[i];
4602                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4603                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4604                                                               HDA_OUTPUT));
4605                         if (err < 0)
4606                                 return err;
4607                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4608                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4609                                                               HDA_INPUT));
4610                         if (err < 0)
4611                                 return err;
4612                 }
4613         }
4614         return 0;
4615 }
4616
4617 /* add playback controls for speaker and HP outputs */
4618 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4619                                         const char *pfx)
4620 {
4621         hda_nid_t nid;
4622         int err;
4623
4624         if (!pin)
4625                 return 0;
4626
4627         if (alc880_is_fixed_pin(pin)) {
4628                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4629                 /* specify the DAC as the extra output */
4630                 if (!spec->multiout.hp_nid)
4631                         spec->multiout.hp_nid = nid;
4632                 else
4633                         spec->multiout.extra_out_nid[0] = nid;
4634                 /* control HP volume/switch on the output mixer amp */
4635                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4636                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4637                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4638                 if (err < 0)
4639                         return err;
4640                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4641                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4642                 if (err < 0)
4643                         return err;
4644         } else if (alc880_is_multi_pin(pin)) {
4645                 /* set manual connection */
4646                 /* we have only a switch on HP-out PIN */
4647                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4648                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4649                 if (err < 0)
4650                         return err;
4651         }
4652         return 0;
4653 }
4654
4655 /* create input playback/capture controls for the given pin */
4656 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4657                             const char *ctlname,
4658                             int idx, hda_nid_t mix_nid)
4659 {
4660         int err;
4661
4662         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4663                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4664         if (err < 0)
4665                 return err;
4666         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4667                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4668         if (err < 0)
4669                 return err;
4670         return 0;
4671 }
4672
4673 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4674 {
4675         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4676         return (pincap & AC_PINCAP_IN) != 0;
4677 }
4678
4679 /* create playback/capture controls for input pins */
4680 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4681                                       const struct auto_pin_cfg *cfg,
4682                                       hda_nid_t mixer,
4683                                       hda_nid_t cap1, hda_nid_t cap2)
4684 {
4685         struct alc_spec *spec = codec->spec;
4686         struct hda_input_mux *imux = &spec->private_imux[0];
4687         int i, err, idx;
4688
4689         for (i = 0; i < AUTO_PIN_LAST; i++) {
4690                 hda_nid_t pin;
4691
4692                 pin = cfg->input_pins[i];
4693                 if (!alc_is_input_pin(codec, pin))
4694                         continue;
4695
4696                 if (mixer) {
4697                         idx = get_connection_index(codec, mixer, pin);
4698                         if (idx >= 0) {
4699                                 err = new_analog_input(spec, pin,
4700                                                        auto_pin_cfg_labels[i],
4701                                                        idx, mixer);
4702                                 if (err < 0)
4703                                         return err;
4704                         }
4705                 }
4706
4707                 if (!cap1)
4708                         continue;
4709                 idx = get_connection_index(codec, cap1, pin);
4710                 if (idx < 0 && cap2)
4711                         idx = get_connection_index(codec, cap2, pin);
4712                 if (idx >= 0) {
4713                         imux->items[imux->num_items].label =
4714                                 auto_pin_cfg_labels[i];
4715                         imux->items[imux->num_items].index = idx;
4716                         imux->num_items++;
4717                 }
4718         }
4719         return 0;
4720 }
4721
4722 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4723                                                 const struct auto_pin_cfg *cfg)
4724 {
4725         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4726 }
4727
4728 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4729                                unsigned int pin_type)
4730 {
4731         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4732                             pin_type);
4733         /* unmute pin */
4734         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4735                             AMP_OUT_UNMUTE);
4736 }
4737
4738 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4739                                               hda_nid_t nid, int pin_type,
4740                                               int dac_idx)
4741 {
4742         alc_set_pin_output(codec, nid, pin_type);
4743         /* need the manual connection? */
4744         if (alc880_is_multi_pin(nid)) {
4745                 struct alc_spec *spec = codec->spec;
4746                 int idx = alc880_multi_pin_idx(nid);
4747                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4748                                     AC_VERB_SET_CONNECT_SEL,
4749                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4750         }
4751 }
4752
4753 static int get_pin_type(int line_out_type)
4754 {
4755         if (line_out_type == AUTO_PIN_HP_OUT)
4756                 return PIN_HP;
4757         else
4758                 return PIN_OUT;
4759 }
4760
4761 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4762 {
4763         struct alc_spec *spec = codec->spec;
4764         int i;
4765
4766         for (i = 0; i < spec->autocfg.line_outs; i++) {
4767                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4768                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4769                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4770         }
4771 }
4772
4773 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4774 {
4775         struct alc_spec *spec = codec->spec;
4776         hda_nid_t pin;
4777
4778         pin = spec->autocfg.speaker_pins[0];
4779         if (pin) /* connect to front */
4780                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4781         pin = spec->autocfg.hp_pins[0];
4782         if (pin) /* connect to front */
4783                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4784 }
4785
4786 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4787 {
4788         struct alc_spec *spec = codec->spec;
4789         int i;
4790
4791         for (i = 0; i < AUTO_PIN_LAST; i++) {
4792                 hda_nid_t nid = spec->autocfg.input_pins[i];
4793                 if (alc_is_input_pin(codec, nid)) {
4794                         alc_set_input_pin(codec, nid, i);
4795                         if (nid != ALC880_PIN_CD_NID &&
4796                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4797                                 snd_hda_codec_write(codec, nid, 0,
4798                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4799                                                     AMP_OUT_MUTE);
4800                 }
4801         }
4802 }
4803
4804 /* parse the BIOS configuration and set up the alc_spec */
4805 /* return 1 if successful, 0 if the proper config is not found,
4806  * or a negative error code
4807  */
4808 static int alc880_parse_auto_config(struct hda_codec *codec)
4809 {
4810         struct alc_spec *spec = codec->spec;
4811         int i, err;
4812         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4813
4814         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4815                                            alc880_ignore);
4816         if (err < 0)
4817                 return err;
4818         if (!spec->autocfg.line_outs)
4819                 return 0; /* can't find valid BIOS pin config */
4820
4821         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4822         if (err < 0)
4823                 return err;
4824         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4825         if (err < 0)
4826                 return err;
4827         err = alc880_auto_create_extra_out(spec,
4828                                            spec->autocfg.speaker_pins[0],
4829                                            "Speaker");
4830         if (err < 0)
4831                 return err;
4832         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4833                                            "Headphone");
4834         if (err < 0)
4835                 return err;
4836         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4837         if (err < 0)
4838                 return err;
4839
4840         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4841
4842         /* check multiple SPDIF-out (for recent codecs) */
4843         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4844                 hda_nid_t dig_nid;
4845                 err = snd_hda_get_connections(codec,
4846                                               spec->autocfg.dig_out_pins[i],
4847                                               &dig_nid, 1);
4848                 if (err < 0)
4849                         continue;
4850                 if (!i)
4851                         spec->multiout.dig_out_nid = dig_nid;
4852                 else {
4853                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4854                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4855                                 break;
4856                         spec->slave_dig_outs[i - 1] = dig_nid;
4857                 }
4858         }
4859         if (spec->autocfg.dig_in_pin)
4860                 spec->dig_in_nid = ALC880_DIGIN_NID;
4861
4862         if (spec->kctls.list)
4863                 add_mixer(spec, spec->kctls.list);
4864
4865         add_verb(spec, alc880_volume_init_verbs);
4866
4867         spec->num_mux_defs = 1;
4868         spec->input_mux = &spec->private_imux[0];
4869
4870         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
4871
4872         return 1;
4873 }
4874
4875 /* additional initialization for auto-configuration model */
4876 static void alc880_auto_init(struct hda_codec *codec)
4877 {
4878         struct alc_spec *spec = codec->spec;
4879         alc880_auto_init_multi_out(codec);
4880         alc880_auto_init_extra_out(codec);
4881         alc880_auto_init_analog_input(codec);
4882         if (spec->unsol_event)
4883                 alc_inithook(codec);
4884 }
4885
4886 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4887  * one of two digital mic pins, e.g. on ALC272
4888  */
4889 static void fixup_automic_adc(struct hda_codec *codec)
4890 {
4891         struct alc_spec *spec = codec->spec;
4892         int i;
4893
4894         for (i = 0; i < spec->num_adc_nids; i++) {
4895                 hda_nid_t cap = spec->capsrc_nids ?
4896                         spec->capsrc_nids[i] : spec->adc_nids[i];
4897                 int iidx, eidx;
4898
4899                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4900                 if (iidx < 0)
4901                         continue;
4902                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4903                 if (eidx < 0)
4904                         continue;
4905                 spec->int_mic.mux_idx = iidx;
4906                 spec->ext_mic.mux_idx = eidx;
4907                 if (spec->capsrc_nids)
4908                         spec->capsrc_nids += i;
4909                 spec->adc_nids += i;
4910                 spec->num_adc_nids = 1;
4911                 return;
4912         }
4913         snd_printd(KERN_INFO "hda_codec: %s: "
4914                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4915                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4916         spec->auto_mic = 0; /* disable auto-mic to be sure */
4917 }
4918
4919 /* choose the ADC/MUX containing the input pin and initialize the setup */
4920 static void fixup_single_adc(struct hda_codec *codec)
4921 {
4922         struct alc_spec *spec = codec->spec;
4923         hda_nid_t pin = 0;
4924         int i;
4925
4926         /* search for the input pin; there must be only one */
4927         for (i = 0; i < AUTO_PIN_LAST; i++) {
4928                 if (spec->autocfg.input_pins[i]) {
4929                         pin = spec->autocfg.input_pins[i];
4930                         break;
4931                 }
4932         }
4933         if (!pin)
4934                 return;
4935
4936         /* set the default connection to that pin */
4937         for (i = 0; i < spec->num_adc_nids; i++) {
4938                 hda_nid_t cap = spec->capsrc_nids ?
4939                         spec->capsrc_nids[i] : spec->adc_nids[i];
4940                 int idx;
4941
4942                 idx = get_connection_index(codec, cap, pin);
4943                 if (idx < 0)
4944                         continue;
4945                 /* use only this ADC */
4946                 if (spec->capsrc_nids)
4947                         spec->capsrc_nids += i;
4948                 spec->adc_nids += i;
4949                 spec->num_adc_nids = 1;
4950                 /* select or unmute this route */
4951                 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
4952                         snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
4953                                                  HDA_AMP_MUTE, 0);
4954                 } else {
4955                         snd_hda_codec_write_cache(codec, cap, 0,
4956                                           AC_VERB_SET_CONNECT_SEL, idx);
4957                 }
4958                 return;
4959         }
4960 }
4961
4962 static void set_capture_mixer(struct hda_codec *codec)
4963 {
4964         struct alc_spec *spec = codec->spec;
4965         static struct snd_kcontrol_new *caps[2][3] = {
4966                 { alc_capture_mixer_nosrc1,
4967                   alc_capture_mixer_nosrc2,
4968                   alc_capture_mixer_nosrc3 },
4969                 { alc_capture_mixer1,
4970                   alc_capture_mixer2,
4971                   alc_capture_mixer3 },
4972         };
4973         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4974                 int mux = 0;
4975                 if (spec->auto_mic)
4976                         fixup_automic_adc(codec);
4977                 else if (spec->input_mux) {
4978                         if (spec->input_mux->num_items > 1)
4979                                 mux = 1;
4980                         else if (spec->input_mux->num_items == 1)
4981                                 fixup_single_adc(codec);
4982                 }
4983                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4984         }
4985 }
4986
4987 /* fill adc_nids (and capsrc_nids) containing all active input pins */
4988 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
4989                                  int num_nids)
4990 {
4991         struct alc_spec *spec = codec->spec;
4992         int n;
4993         hda_nid_t fallback_adc = 0, fallback_cap = 0;
4994
4995         for (n = 0; n < num_nids; n++) {
4996                 hda_nid_t adc, cap;
4997                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
4998                 int nconns, i, j;
4999
5000                 adc = nids[n];
5001                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5002                         continue;
5003                 cap = adc;
5004                 nconns = snd_hda_get_connections(codec, cap, conn,
5005                                                  ARRAY_SIZE(conn));
5006                 if (nconns == 1) {
5007                         cap = conn[0];
5008                         nconns = snd_hda_get_connections(codec, cap, conn,
5009                                                          ARRAY_SIZE(conn));
5010                 }
5011                 if (nconns <= 0)
5012                         continue;
5013                 if (!fallback_adc) {
5014                         fallback_adc = adc;
5015                         fallback_cap = cap;
5016                 }
5017                 for (i = 0; i < AUTO_PIN_LAST; i++) {
5018                         hda_nid_t nid = spec->autocfg.input_pins[i];
5019                         if (!nid)
5020                                 continue;
5021                         for (j = 0; j < nconns; j++) {
5022                                 if (conn[j] == nid)
5023                                         break;
5024                         }
5025                         if (j >= nconns)
5026                                 break;
5027                 }
5028                 if (i >= AUTO_PIN_LAST) {
5029                         int num_adcs = spec->num_adc_nids;
5030                         spec->private_adc_nids[num_adcs] = adc;
5031                         spec->private_capsrc_nids[num_adcs] = cap;
5032                         spec->num_adc_nids++;
5033                         spec->adc_nids = spec->private_adc_nids;
5034                         if (adc != cap)
5035                                 spec->capsrc_nids = spec->private_capsrc_nids;
5036                 }
5037         }
5038         if (!spec->num_adc_nids) {
5039                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5040                        " using fallback 0x%x\n",
5041                        codec->chip_name, fallback_adc);
5042                 spec->private_adc_nids[0] = fallback_adc;
5043                 spec->adc_nids = spec->private_adc_nids;
5044                 if (fallback_adc != fallback_cap) {
5045                         spec->private_capsrc_nids[0] = fallback_cap;
5046                         spec->capsrc_nids = spec->private_adc_nids;
5047                 }
5048         }
5049 }
5050
5051 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5052 #define set_beep_amp(spec, nid, idx, dir) \
5053         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5054 #else
5055 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5056 #endif
5057
5058 /*
5059  * OK, here we have finally the patch for ALC880
5060  */
5061
5062 static int patch_alc880(struct hda_codec *codec)
5063 {
5064         struct alc_spec *spec;
5065         int board_config;
5066         int err;
5067
5068         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5069         if (spec == NULL)
5070                 return -ENOMEM;
5071
5072         codec->spec = spec;
5073
5074         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5075                                                   alc880_models,
5076                                                   alc880_cfg_tbl);
5077         if (board_config < 0) {
5078                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5079                        codec->chip_name);
5080                 board_config = ALC880_AUTO;
5081         }
5082
5083         if (board_config == ALC880_AUTO) {
5084                 /* automatic parse from the BIOS config */
5085                 err = alc880_parse_auto_config(codec);
5086                 if (err < 0) {
5087                         alc_free(codec);
5088                         return err;
5089                 } else if (!err) {
5090                         printk(KERN_INFO
5091                                "hda_codec: Cannot set up configuration "
5092                                "from BIOS.  Using 3-stack mode...\n");
5093                         board_config = ALC880_3ST;
5094                 }
5095         }
5096
5097         err = snd_hda_attach_beep_device(codec, 0x1);
5098         if (err < 0) {
5099                 alc_free(codec);
5100                 return err;
5101         }
5102
5103         if (board_config != ALC880_AUTO)
5104                 setup_preset(codec, &alc880_presets[board_config]);
5105
5106         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5107         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5108         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5109
5110         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5111         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5112
5113         if (!spec->adc_nids && spec->input_mux) {
5114                 /* check whether NID 0x07 is valid */
5115                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5116                 /* get type */
5117                 wcap = get_wcaps_type(wcap);
5118                 if (wcap != AC_WID_AUD_IN) {
5119                         spec->adc_nids = alc880_adc_nids_alt;
5120                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5121                 } else {
5122                         spec->adc_nids = alc880_adc_nids;
5123                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5124                 }
5125         }
5126         set_capture_mixer(codec);
5127         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5128
5129         spec->vmaster_nid = 0x0c;
5130
5131         codec->patch_ops = alc_patch_ops;
5132         if (board_config == ALC880_AUTO)
5133                 spec->init_hook = alc880_auto_init;
5134 #ifdef CONFIG_SND_HDA_POWER_SAVE
5135         if (!spec->loopback.amplist)
5136                 spec->loopback.amplist = alc880_loopbacks;
5137 #endif
5138
5139         return 0;
5140 }
5141
5142
5143 /*
5144  * ALC260 support
5145  */
5146
5147 static hda_nid_t alc260_dac_nids[1] = {
5148         /* front */
5149         0x02,
5150 };
5151
5152 static hda_nid_t alc260_adc_nids[1] = {
5153         /* ADC0 */
5154         0x04,
5155 };
5156
5157 static hda_nid_t alc260_adc_nids_alt[1] = {
5158         /* ADC1 */
5159         0x05,
5160 };
5161
5162 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5163  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5164  */
5165 static hda_nid_t alc260_dual_adc_nids[2] = {
5166         /* ADC0, ADC1 */
5167         0x04, 0x05
5168 };
5169
5170 #define ALC260_DIGOUT_NID       0x03
5171 #define ALC260_DIGIN_NID        0x06
5172
5173 static struct hda_input_mux alc260_capture_source = {
5174         .num_items = 4,
5175         .items = {
5176                 { "Mic", 0x0 },
5177                 { "Front Mic", 0x1 },
5178                 { "Line", 0x2 },
5179                 { "CD", 0x4 },
5180         },
5181 };
5182
5183 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5184  * headphone jack and the internal CD lines since these are the only pins at
5185  * which audio can appear.  For flexibility, also allow the option of
5186  * recording the mixer output on the second ADC (ADC0 doesn't have a
5187  * connection to the mixer output).
5188  */
5189 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5190         {
5191                 .num_items = 3,
5192                 .items = {
5193                         { "Mic/Line", 0x0 },
5194                         { "CD", 0x4 },
5195                         { "Headphone", 0x2 },
5196                 },
5197         },
5198         {
5199                 .num_items = 4,
5200                 .items = {
5201                         { "Mic/Line", 0x0 },
5202                         { "CD", 0x4 },
5203                         { "Headphone", 0x2 },
5204                         { "Mixer", 0x5 },
5205                 },
5206         },
5207
5208 };
5209
5210 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5211  * the Fujitsu S702x, but jacks are marked differently.
5212  */
5213 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5214         {
5215                 .num_items = 4,
5216                 .items = {
5217                         { "Mic", 0x0 },
5218                         { "Line", 0x2 },
5219                         { "CD", 0x4 },
5220                         { "Headphone", 0x5 },
5221                 },
5222         },
5223         {
5224                 .num_items = 5,
5225                 .items = {
5226                         { "Mic", 0x0 },
5227                         { "Line", 0x2 },
5228                         { "CD", 0x4 },
5229                         { "Headphone", 0x6 },
5230                         { "Mixer", 0x5 },
5231                 },
5232         },
5233 };
5234
5235 /* Maxdata Favorit 100XS */
5236 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5237         {
5238                 .num_items = 2,
5239                 .items = {
5240                         { "Line/Mic", 0x0 },
5241                         { "CD", 0x4 },
5242                 },
5243         },
5244         {
5245                 .num_items = 3,
5246                 .items = {
5247                         { "Line/Mic", 0x0 },
5248                         { "CD", 0x4 },
5249                         { "Mixer", 0x5 },
5250                 },
5251         },
5252 };
5253
5254 /*
5255  * This is just place-holder, so there's something for alc_build_pcms to look
5256  * at when it calculates the maximum number of channels. ALC260 has no mixer
5257  * element which allows changing the channel mode, so the verb list is
5258  * never used.
5259  */
5260 static struct hda_channel_mode alc260_modes[1] = {
5261         { 2, NULL },
5262 };
5263
5264
5265 /* Mixer combinations
5266  *
5267  * basic: base_output + input + pc_beep + capture
5268  * HP: base_output + input + capture_alt
5269  * HP_3013: hp_3013 + input + capture
5270  * fujitsu: fujitsu + capture
5271  * acer: acer + capture
5272  */
5273
5274 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5275         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5276         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5277         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5278         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5279         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5280         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5281         { } /* end */
5282 };
5283
5284 static struct snd_kcontrol_new alc260_input_mixer[] = {
5285         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5286         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5287         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5288         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5290         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5291         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5292         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5293         { } /* end */
5294 };
5295
5296 /* update HP, line and mono out pins according to the master switch */
5297 static void alc260_hp_master_update(struct hda_codec *codec,
5298                                     hda_nid_t hp, hda_nid_t line,
5299                                     hda_nid_t mono)
5300 {
5301         struct alc_spec *spec = codec->spec;
5302         unsigned int val = spec->master_sw ? PIN_HP : 0;
5303         /* change HP and line-out pins */
5304         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5305                             val);
5306         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5307                             val);
5308         /* mono (speaker) depending on the HP jack sense */
5309         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5310         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5311                             val);
5312 }
5313
5314 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5315                                    struct snd_ctl_elem_value *ucontrol)
5316 {
5317         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5318         struct alc_spec *spec = codec->spec;
5319         *ucontrol->value.integer.value = spec->master_sw;
5320         return 0;
5321 }
5322
5323 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5324                                    struct snd_ctl_elem_value *ucontrol)
5325 {
5326         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5327         struct alc_spec *spec = codec->spec;
5328         int val = !!*ucontrol->value.integer.value;
5329         hda_nid_t hp, line, mono;
5330
5331         if (val == spec->master_sw)
5332                 return 0;
5333         spec->master_sw = val;
5334         hp = (kcontrol->private_value >> 16) & 0xff;
5335         line = (kcontrol->private_value >> 8) & 0xff;
5336         mono = kcontrol->private_value & 0xff;
5337         alc260_hp_master_update(codec, hp, line, mono);
5338         return 1;
5339 }
5340
5341 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5342         {
5343                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5344                 .name = "Master Playback Switch",
5345                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5346                 .info = snd_ctl_boolean_mono_info,
5347                 .get = alc260_hp_master_sw_get,
5348                 .put = alc260_hp_master_sw_put,
5349                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5350         },
5351         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5352         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5353         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5354         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5355         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5356                               HDA_OUTPUT),
5357         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5358         { } /* end */
5359 };
5360
5361 static struct hda_verb alc260_hp_unsol_verbs[] = {
5362         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5363         {},
5364 };
5365
5366 static void alc260_hp_automute(struct hda_codec *codec)
5367 {
5368         struct alc_spec *spec = codec->spec;
5369
5370         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5371         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5372 }
5373
5374 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5375 {
5376         if ((res >> 26) == ALC880_HP_EVENT)
5377                 alc260_hp_automute(codec);
5378 }
5379
5380 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5381         {
5382                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5383                 .name = "Master Playback Switch",
5384                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5385                 .info = snd_ctl_boolean_mono_info,
5386                 .get = alc260_hp_master_sw_get,
5387                 .put = alc260_hp_master_sw_put,
5388                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5389         },
5390         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5391         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5392         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5393         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5394         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5395         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5396         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5397         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5398         { } /* end */
5399 };
5400
5401 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5402         .ops = &snd_hda_bind_vol,
5403         .values = {
5404                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5405                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5406                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5407                 0
5408         },
5409 };
5410
5411 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5412         .ops = &snd_hda_bind_sw,
5413         .values = {
5414                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5415                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5416                 0
5417         },
5418 };
5419
5420 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5421         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5422         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5423         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5424         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5425         { } /* end */
5426 };
5427
5428 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5429         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5430         {},
5431 };
5432
5433 static void alc260_hp_3013_automute(struct hda_codec *codec)
5434 {
5435         struct alc_spec *spec = codec->spec;
5436
5437         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5438         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5439 }
5440
5441 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5442                                        unsigned int res)
5443 {
5444         if ((res >> 26) == ALC880_HP_EVENT)
5445                 alc260_hp_3013_automute(codec);
5446 }
5447
5448 static void alc260_hp_3012_automute(struct hda_codec *codec)
5449 {
5450         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5451
5452         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5453                             bits);
5454         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5455                             bits);
5456         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5457                             bits);
5458 }
5459
5460 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5461                                        unsigned int res)
5462 {
5463         if ((res >> 26) == ALC880_HP_EVENT)
5464                 alc260_hp_3012_automute(codec);
5465 }
5466
5467 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5468  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5469  */
5470 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5471         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5472         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5473         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5474         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5475         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5476         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5477         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5478         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5479         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5480         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5481         { } /* end */
5482 };
5483
5484 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5485  * versions of the ALC260 don't act on requests to enable mic bias from NID
5486  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5487  * datasheet doesn't mention this restriction.  At this stage it's not clear
5488  * whether this behaviour is intentional or is a hardware bug in chip
5489  * revisions available in early 2006.  Therefore for now allow the
5490  * "Headphone Jack Mode" control to span all choices, but if it turns out
5491  * that the lack of mic bias for this NID is intentional we could change the
5492  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5493  *
5494  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5495  * don't appear to make the mic bias available from the "line" jack, even
5496  * though the NID used for this jack (0x14) can supply it.  The theory is
5497  * that perhaps Acer have included blocking capacitors between the ALC260
5498  * and the output jack.  If this turns out to be the case for all such
5499  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5500  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5501  *
5502  * The C20x Tablet series have a mono internal speaker which is controlled
5503  * via the chip's Mono sum widget and pin complex, so include the necessary
5504  * controls for such models.  On models without a "mono speaker" the control
5505  * won't do anything.
5506  */
5507 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5508         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5509         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5510         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5511         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5512                               HDA_OUTPUT),
5513         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5514                            HDA_INPUT),
5515         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5516         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5517         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5518         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5519         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5520         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5521         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5522         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5523         { } /* end */
5524 };
5525
5526 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5527  */
5528 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5529         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5530         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5531         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5532         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5533         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5534         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5535         { } /* end */
5536 };
5537
5538 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5539  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5540  */
5541 static struct snd_kcontrol_new alc260_will_mixer[] = {
5542         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5543         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5544         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5545         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5546         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5547         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5548         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5549         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5550         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5551         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5552         { } /* end */
5553 };
5554
5555 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5556  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5557  */
5558 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5559         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5560         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5561         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5562         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5563         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5564         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5565         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5566         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5567         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5568         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5569         { } /* end */
5570 };
5571
5572 /*
5573  * initialization verbs
5574  */
5575 static struct hda_verb alc260_init_verbs[] = {
5576         /* Line In pin widget for input */
5577         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5578         /* CD pin widget for input */
5579         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5580         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5581         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5582         /* Mic2 (front panel) pin widget for input and vref at 80% */
5583         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5584         /* LINE-2 is used for line-out in rear */
5585         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5586         /* select line-out */
5587         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5588         /* LINE-OUT pin */
5589         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5590         /* enable HP */
5591         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5592         /* enable Mono */
5593         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5594         /* mute capture amp left and right */
5595         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5596         /* set connection select to line in (default select for this ADC) */
5597         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5598         /* mute capture amp left and right */
5599         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5600         /* set connection select to line in (default select for this ADC) */
5601         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5602         /* set vol=0 Line-Out mixer amp left and right */
5603         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5604         /* unmute pin widget amp left and right (no gain on this amp) */
5605         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5606         /* set vol=0 HP mixer amp left and right */
5607         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5608         /* unmute pin widget amp left and right (no gain on this amp) */
5609         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5610         /* set vol=0 Mono mixer amp left and right */
5611         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5612         /* unmute pin widget amp left and right (no gain on this amp) */
5613         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5614         /* unmute LINE-2 out pin */
5615         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5616         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5617          * Line In 2 = 0x03
5618          */
5619         /* mute analog inputs */
5620         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5621         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5622         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5623         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5624         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5625         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5626         /* mute Front out path */
5627         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5628         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5629         /* mute Headphone out path */
5630         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5631         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5632         /* mute Mono out path */
5633         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5634         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5635         { }
5636 };
5637
5638 #if 0 /* should be identical with alc260_init_verbs? */
5639 static struct hda_verb alc260_hp_init_verbs[] = {
5640         /* Headphone and output */
5641         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5642         /* mono output */
5643         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5644         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5645         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5646         /* Mic2 (front panel) pin widget for input and vref at 80% */
5647         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5648         /* Line In pin widget for input */
5649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5650         /* Line-2 pin widget for output */
5651         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5652         /* CD pin widget for input */
5653         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5654         /* unmute amp left and right */
5655         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5656         /* set connection select to line in (default select for this ADC) */
5657         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5658         /* unmute Line-Out mixer amp left and right (volume = 0) */
5659         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5660         /* mute pin widget amp left and right (no gain on this amp) */
5661         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5662         /* unmute HP mixer amp left and right (volume = 0) */
5663         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5664         /* mute pin widget amp left and right (no gain on this amp) */
5665         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5666         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5667          * Line In 2 = 0x03
5668          */
5669         /* mute analog inputs */
5670         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5671         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5672         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5673         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5674         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5675         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5676         /* Unmute Front out path */
5677         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5678         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5679         /* Unmute Headphone out path */
5680         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5681         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5682         /* Unmute Mono out path */
5683         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5684         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5685         { }
5686 };
5687 #endif
5688
5689 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5690         /* Line out and output */
5691         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5692         /* mono output */
5693         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5694         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5695         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5696         /* Mic2 (front panel) pin widget for input and vref at 80% */
5697         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5698         /* Line In pin widget for input */
5699         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5700         /* Headphone pin widget for output */
5701         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5702         /* CD pin widget for input */
5703         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5704         /* unmute amp left and right */
5705         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5706         /* set connection select to line in (default select for this ADC) */
5707         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5708         /* unmute Line-Out mixer amp left and right (volume = 0) */
5709         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5710         /* mute pin widget amp left and right (no gain on this amp) */
5711         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5712         /* unmute HP mixer amp left and right (volume = 0) */
5713         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5714         /* mute pin widget amp left and right (no gain on this amp) */
5715         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5716         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5717          * Line In 2 = 0x03
5718          */
5719         /* mute analog inputs */
5720         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5721         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5722         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5723         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5724         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5725         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5726         /* Unmute Front out path */
5727         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5728         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5729         /* Unmute Headphone out path */
5730         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5731         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5732         /* Unmute Mono out path */
5733         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5734         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5735         { }
5736 };
5737
5738 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5739  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5740  * audio = 0x16, internal speaker = 0x10.
5741  */
5742 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5743         /* Disable all GPIOs */
5744         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5745         /* Internal speaker is connected to headphone pin */
5746         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5747         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5748         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5749         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5750         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5751         /* Ensure all other unused pins are disabled and muted. */
5752         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5753         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5754         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5755         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5756         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5757         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5758         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5759         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5760
5761         /* Disable digital (SPDIF) pins */
5762         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5763         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5764
5765         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5766          * when acting as an output.
5767          */
5768         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5769
5770         /* Start with output sum widgets muted and their output gains at min */
5771         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5772         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5773         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5774         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5775         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5776         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5777         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5778         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5779         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5780
5781         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5782         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5783         /* Unmute Line1 pin widget output buffer since it starts as an output.
5784          * If the pin mode is changed by the user the pin mode control will
5785          * take care of enabling the pin's input/output buffers as needed.
5786          * Therefore there's no need to enable the input buffer at this
5787          * stage.
5788          */
5789         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5790         /* Unmute input buffer of pin widget used for Line-in (no equiv
5791          * mixer ctrl)
5792          */
5793         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5794
5795         /* Mute capture amp left and right */
5796         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5797         /* Set ADC connection select to match default mixer setting - line
5798          * in (on mic1 pin)
5799          */
5800         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5801
5802         /* Do the same for the second ADC: mute capture input amp and
5803          * set ADC connection to line in (on mic1 pin)
5804          */
5805         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5806         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5807
5808         /* Mute all inputs to mixer widget (even unconnected ones) */
5809         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5810         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5811         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5812         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5813         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5814         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5815         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5816         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5817
5818         { }
5819 };
5820
5821 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5822  * similar laptops (adapted from Fujitsu init verbs).
5823  */
5824 static struct hda_verb alc260_acer_init_verbs[] = {
5825         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5826          * the headphone jack.  Turn this on and rely on the standard mute
5827          * methods whenever the user wants to turn these outputs off.
5828          */
5829         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5830         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5831         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5832         /* Internal speaker/Headphone jack is connected to Line-out pin */
5833         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5834         /* Internal microphone/Mic jack is connected to Mic1 pin */
5835         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5836         /* Line In jack is connected to Line1 pin */
5837         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5838         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5839         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5840         /* Ensure all other unused pins are disabled and muted. */
5841         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5842         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5843         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5844         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5845         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5846         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5847         /* Disable digital (SPDIF) pins */
5848         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5849         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5850
5851         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5852          * bus when acting as outputs.
5853          */
5854         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5855         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5856
5857         /* Start with output sum widgets muted and their output gains at min */
5858         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5859         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5860         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5861         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5862         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5863         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5864         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5865         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5866         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5867
5868         /* Unmute Line-out pin widget amp left and right
5869          * (no equiv mixer ctrl)
5870          */
5871         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5872         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5873         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5874         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5875          * inputs. If the pin mode is changed by the user the pin mode control
5876          * will take care of enabling the pin's input/output buffers as needed.
5877          * Therefore there's no need to enable the input buffer at this
5878          * stage.
5879          */
5880         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5881         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5882
5883         /* Mute capture amp left and right */
5884         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5885         /* Set ADC connection select to match default mixer setting - mic
5886          * (on mic1 pin)
5887          */
5888         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5889
5890         /* Do similar with the second ADC: mute capture input amp and
5891          * set ADC connection to mic to match ALSA's default state.
5892          */
5893         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5894         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5895
5896         /* Mute all inputs to mixer widget (even unconnected ones) */
5897         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5898         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5899         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5900         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5901         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5902         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5903         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5904         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5905
5906         { }
5907 };
5908
5909 /* Initialisation sequence for Maxdata Favorit 100XS
5910  * (adapted from Acer init verbs).
5911  */
5912 static struct hda_verb alc260_favorit100_init_verbs[] = {
5913         /* GPIO 0 enables the output jack.
5914          * Turn this on and rely on the standard mute
5915          * methods whenever the user wants to turn these outputs off.
5916          */
5917         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5918         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5919         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5920         /* Line/Mic input jack is connected to Mic1 pin */
5921         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5922         /* Ensure all other unused pins are disabled and muted. */
5923         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5924         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5925         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5926         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5927         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5928         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5929         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5930         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5931         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5932         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5933         /* Disable digital (SPDIF) pins */
5934         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5935         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5936
5937         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5938          * bus when acting as outputs.
5939          */
5940         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5941         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5942
5943         /* Start with output sum widgets muted and their output gains at min */
5944         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5945         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5946         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5947         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5948         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5949         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5950         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5951         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5952         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5953
5954         /* Unmute Line-out pin widget amp left and right
5955          * (no equiv mixer ctrl)
5956          */
5957         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5958         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5959          * inputs. If the pin mode is changed by the user the pin mode control
5960          * will take care of enabling the pin's input/output buffers as needed.
5961          * Therefore there's no need to enable the input buffer at this
5962          * stage.
5963          */
5964         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5965
5966         /* Mute capture amp left and right */
5967         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5968         /* Set ADC connection select to match default mixer setting - mic
5969          * (on mic1 pin)
5970          */
5971         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5972
5973         /* Do similar with the second ADC: mute capture input amp and
5974          * set ADC connection to mic to match ALSA's default state.
5975          */
5976         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5977         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5978
5979         /* Mute all inputs to mixer widget (even unconnected ones) */
5980         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5981         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5982         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5983         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5984         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5985         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5986         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5987         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5988
5989         { }
5990 };
5991
5992 static struct hda_verb alc260_will_verbs[] = {
5993         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5994         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5995         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5996         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5997         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5998         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5999         {}
6000 };
6001
6002 static struct hda_verb alc260_replacer_672v_verbs[] = {
6003         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6004         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6005         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6006
6007         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6008         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6009         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6010
6011         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6012         {}
6013 };
6014
6015 /* toggle speaker-output according to the hp-jack state */
6016 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6017 {
6018         unsigned int present;
6019
6020         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6021         present = snd_hda_jack_detect(codec, 0x0f);
6022         if (present) {
6023                 snd_hda_codec_write_cache(codec, 0x01, 0,
6024                                           AC_VERB_SET_GPIO_DATA, 1);
6025                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6026                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6027                                           PIN_HP);
6028         } else {
6029                 snd_hda_codec_write_cache(codec, 0x01, 0,
6030                                           AC_VERB_SET_GPIO_DATA, 0);
6031                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6032                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6033                                           PIN_OUT);
6034         }
6035 }
6036
6037 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6038                                        unsigned int res)
6039 {
6040         if ((res >> 26) == ALC880_HP_EVENT)
6041                 alc260_replacer_672v_automute(codec);
6042 }
6043
6044 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6045         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6046         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6047         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6048         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6049         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6050         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6051         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6052         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6053         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6054         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6055         {}
6056 };
6057
6058 /* Test configuration for debugging, modelled after the ALC880 test
6059  * configuration.
6060  */
6061 #ifdef CONFIG_SND_DEBUG
6062 static hda_nid_t alc260_test_dac_nids[1] = {
6063         0x02,
6064 };
6065 static hda_nid_t alc260_test_adc_nids[2] = {
6066         0x04, 0x05,
6067 };
6068 /* For testing the ALC260, each input MUX needs its own definition since
6069  * the signal assignments are different.  This assumes that the first ADC
6070  * is NID 0x04.
6071  */
6072 static struct hda_input_mux alc260_test_capture_sources[2] = {
6073         {
6074                 .num_items = 7,
6075                 .items = {
6076                         { "MIC1 pin", 0x0 },
6077                         { "MIC2 pin", 0x1 },
6078                         { "LINE1 pin", 0x2 },
6079                         { "LINE2 pin", 0x3 },
6080                         { "CD pin", 0x4 },
6081                         { "LINE-OUT pin", 0x5 },
6082                         { "HP-OUT pin", 0x6 },
6083                 },
6084         },
6085         {
6086                 .num_items = 8,
6087                 .items = {
6088                         { "MIC1 pin", 0x0 },
6089                         { "MIC2 pin", 0x1 },
6090                         { "LINE1 pin", 0x2 },
6091                         { "LINE2 pin", 0x3 },
6092                         { "CD pin", 0x4 },
6093                         { "Mixer", 0x5 },
6094                         { "LINE-OUT pin", 0x6 },
6095                         { "HP-OUT pin", 0x7 },
6096                 },
6097         },
6098 };
6099 static struct snd_kcontrol_new alc260_test_mixer[] = {
6100         /* Output driver widgets */
6101         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6102         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6103         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6104         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6105         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6106         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6107
6108         /* Modes for retasking pin widgets
6109          * Note: the ALC260 doesn't seem to act on requests to enable mic
6110          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6111          * mention this restriction.  At this stage it's not clear whether
6112          * this behaviour is intentional or is a hardware bug in chip
6113          * revisions available at least up until early 2006.  Therefore for
6114          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6115          * choices, but if it turns out that the lack of mic bias for these
6116          * NIDs is intentional we could change their modes from
6117          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6118          */
6119         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6120         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6121         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6122         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6123         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6124         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6125
6126         /* Loopback mixer controls */
6127         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6128         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6129         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6130         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6131         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6132         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6133         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6134         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6135         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6136         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6137         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6138         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6139         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6140         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6141
6142         /* Controls for GPIO pins, assuming they are configured as outputs */
6143         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6144         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6145         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6146         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6147
6148         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6149          * is ambigious as to which NID is which; testing on laptops which
6150          * make this output available should provide clarification.
6151          */
6152         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6153         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6154
6155         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6156          * this output to turn on an external amplifier.
6157          */
6158         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6159         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6160
6161         { } /* end */
6162 };
6163 static struct hda_verb alc260_test_init_verbs[] = {
6164         /* Enable all GPIOs as outputs with an initial value of 0 */
6165         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6166         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6167         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6168
6169         /* Enable retasking pins as output, initially without power amp */
6170         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6171         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6172         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6173         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6174         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6175         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6176
6177         /* Disable digital (SPDIF) pins initially, but users can enable
6178          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6179          * payload also sets the generation to 0, output to be in "consumer"
6180          * PCM format, copyright asserted, no pre-emphasis and no validity
6181          * control.
6182          */
6183         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6184         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6185
6186         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6187          * OUT1 sum bus when acting as an output.
6188          */
6189         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6190         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6191         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6192         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6193
6194         /* Start with output sum widgets muted and their output gains at min */
6195         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6196         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6197         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6198         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6199         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6200         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6201         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6202         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6203         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6204
6205         /* Unmute retasking pin widget output buffers since the default
6206          * state appears to be output.  As the pin mode is changed by the
6207          * user the pin mode control will take care of enabling the pin's
6208          * input/output buffers as needed.
6209          */
6210         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6211         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6212         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6213         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6214         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6215         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6216         /* Also unmute the mono-out pin widget */
6217         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6218
6219         /* Mute capture amp left and right */
6220         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6221         /* Set ADC connection select to match default mixer setting (mic1
6222          * pin)
6223          */
6224         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6225
6226         /* Do the same for the second ADC: mute capture input amp and
6227          * set ADC connection to mic1 pin
6228          */
6229         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6230         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6231
6232         /* Mute all inputs to mixer widget (even unconnected ones) */
6233         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6234         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6235         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6236         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6237         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6238         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6239         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6240         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6241
6242         { }
6243 };
6244 #endif
6245
6246 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6247 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6248
6249 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6250 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6251
6252 /*
6253  * for BIOS auto-configuration
6254  */
6255
6256 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6257                                         const char *pfx, int *vol_bits)
6258 {
6259         hda_nid_t nid_vol;
6260         unsigned long vol_val, sw_val;
6261         int err;
6262
6263         if (nid >= 0x0f && nid < 0x11) {
6264                 nid_vol = nid - 0x7;
6265                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6266                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6267         } else if (nid == 0x11) {
6268                 nid_vol = nid - 0x7;
6269                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6270                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6271         } else if (nid >= 0x12 && nid <= 0x15) {
6272                 nid_vol = 0x08;
6273                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6274                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6275         } else
6276                 return 0; /* N/A */
6277
6278         if (!(*vol_bits & (1 << nid_vol))) {
6279                 /* first control for the volume widget */
6280                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6281                 if (err < 0)
6282                         return err;
6283                 *vol_bits |= (1 << nid_vol);
6284         }
6285         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6286         if (err < 0)
6287                 return err;
6288         return 1;
6289 }
6290
6291 /* add playback controls from the parsed DAC table */
6292 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6293                                              const struct auto_pin_cfg *cfg)
6294 {
6295         hda_nid_t nid;
6296         int err;
6297         int vols = 0;
6298
6299         spec->multiout.num_dacs = 1;
6300         spec->multiout.dac_nids = spec->private_dac_nids;
6301         spec->multiout.dac_nids[0] = 0x02;
6302
6303         nid = cfg->line_out_pins[0];
6304         if (nid) {
6305                 const char *pfx;
6306                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6307                         pfx = "Master";
6308                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6309                         pfx = "Speaker";
6310                 else
6311                         pfx = "Front";
6312                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6313                 if (err < 0)
6314                         return err;
6315         }
6316
6317         nid = cfg->speaker_pins[0];
6318         if (nid) {
6319                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6320                 if (err < 0)
6321                         return err;
6322         }
6323
6324         nid = cfg->hp_pins[0];
6325         if (nid) {
6326                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6327                                                    &vols);
6328                 if (err < 0)
6329                         return err;
6330         }
6331         return 0;
6332 }
6333
6334 /* create playback/capture controls for input pins */
6335 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6336                                                 const struct auto_pin_cfg *cfg)
6337 {
6338         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6339 }
6340
6341 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6342                                               hda_nid_t nid, int pin_type,
6343                                               int sel_idx)
6344 {
6345         alc_set_pin_output(codec, nid, pin_type);
6346         /* need the manual connection? */
6347         if (nid >= 0x12) {
6348                 int idx = nid - 0x12;
6349                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6350                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6351         }
6352 }
6353
6354 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6355 {
6356         struct alc_spec *spec = codec->spec;
6357         hda_nid_t nid;
6358
6359         nid = spec->autocfg.line_out_pins[0];
6360         if (nid) {
6361                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6362                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6363         }
6364
6365         nid = spec->autocfg.speaker_pins[0];
6366         if (nid)
6367                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6368
6369         nid = spec->autocfg.hp_pins[0];
6370         if (nid)
6371                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6372 }
6373
6374 #define ALC260_PIN_CD_NID               0x16
6375 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6376 {
6377         struct alc_spec *spec = codec->spec;
6378         int i;
6379
6380         for (i = 0; i < AUTO_PIN_LAST; i++) {
6381                 hda_nid_t nid = spec->autocfg.input_pins[i];
6382                 if (nid >= 0x12) {
6383                         alc_set_input_pin(codec, nid, i);
6384                         if (nid != ALC260_PIN_CD_NID &&
6385                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6386                                 snd_hda_codec_write(codec, nid, 0,
6387                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6388                                                     AMP_OUT_MUTE);
6389                 }
6390         }
6391 }
6392
6393 /*
6394  * generic initialization of ADC, input mixers and output mixers
6395  */
6396 static struct hda_verb alc260_volume_init_verbs[] = {
6397         /*
6398          * Unmute ADC0-1 and set the default input to mic-in
6399          */
6400         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6401         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6402         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6403         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6404
6405         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6406          * mixer widget
6407          * Note: PASD motherboards uses the Line In 2 as the input for
6408          * front panel mic (mic 2)
6409          */
6410         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6411         /* mute analog inputs */
6412         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6413         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6414         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6415         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6416         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6417
6418         /*
6419          * Set up output mixers (0x08 - 0x0a)
6420          */
6421         /* set vol=0 to output mixers */
6422         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6423         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6424         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6425         /* set up input amps for analog loopback */
6426         /* Amp Indices: DAC = 0, mixer = 1 */
6427         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6428         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6429         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6430         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6431         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6432         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6433
6434         { }
6435 };
6436
6437 static int alc260_parse_auto_config(struct hda_codec *codec)
6438 {
6439         struct alc_spec *spec = codec->spec;
6440         int err;
6441         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6442
6443         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6444                                            alc260_ignore);
6445         if (err < 0)
6446                 return err;
6447         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6448         if (err < 0)
6449                 return err;
6450         if (!spec->kctls.list)
6451                 return 0; /* can't find valid BIOS pin config */
6452         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6453         if (err < 0)
6454                 return err;
6455
6456         spec->multiout.max_channels = 2;
6457
6458         if (spec->autocfg.dig_outs)
6459                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6460         if (spec->kctls.list)
6461                 add_mixer(spec, spec->kctls.list);
6462
6463         add_verb(spec, alc260_volume_init_verbs);
6464
6465         spec->num_mux_defs = 1;
6466         spec->input_mux = &spec->private_imux[0];
6467
6468         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6469
6470         return 1;
6471 }
6472
6473 /* additional initialization for auto-configuration model */
6474 static void alc260_auto_init(struct hda_codec *codec)
6475 {
6476         struct alc_spec *spec = codec->spec;
6477         alc260_auto_init_multi_out(codec);
6478         alc260_auto_init_analog_input(codec);
6479         if (spec->unsol_event)
6480                 alc_inithook(codec);
6481 }
6482
6483 #ifdef CONFIG_SND_HDA_POWER_SAVE
6484 static struct hda_amp_list alc260_loopbacks[] = {
6485         { 0x07, HDA_INPUT, 0 },
6486         { 0x07, HDA_INPUT, 1 },
6487         { 0x07, HDA_INPUT, 2 },
6488         { 0x07, HDA_INPUT, 3 },
6489         { 0x07, HDA_INPUT, 4 },
6490         { } /* end */
6491 };
6492 #endif
6493
6494 /*
6495  * ALC260 configurations
6496  */
6497 static const char *alc260_models[ALC260_MODEL_LAST] = {
6498         [ALC260_BASIC]          = "basic",
6499         [ALC260_HP]             = "hp",
6500         [ALC260_HP_3013]        = "hp-3013",
6501         [ALC260_HP_DC7600]      = "hp-dc7600",
6502         [ALC260_FUJITSU_S702X]  = "fujitsu",
6503         [ALC260_ACER]           = "acer",
6504         [ALC260_WILL]           = "will",
6505         [ALC260_REPLACER_672V]  = "replacer",
6506         [ALC260_FAVORIT100]     = "favorit100",
6507 #ifdef CONFIG_SND_DEBUG
6508         [ALC260_TEST]           = "test",
6509 #endif
6510         [ALC260_AUTO]           = "auto",
6511 };
6512
6513 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6514         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6515         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6516         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6517         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6518         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6519         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6520         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6521         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6522         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6523         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6524         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6525         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6526         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6527         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6528         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6529         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6530         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6531         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6532         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6533         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6534         {}
6535 };
6536
6537 static struct alc_config_preset alc260_presets[] = {
6538         [ALC260_BASIC] = {
6539                 .mixers = { alc260_base_output_mixer,
6540                             alc260_input_mixer },
6541                 .init_verbs = { alc260_init_verbs },
6542                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6543                 .dac_nids = alc260_dac_nids,
6544                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6545                 .adc_nids = alc260_dual_adc_nids,
6546                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6547                 .channel_mode = alc260_modes,
6548                 .input_mux = &alc260_capture_source,
6549         },
6550         [ALC260_HP] = {
6551                 .mixers = { alc260_hp_output_mixer,
6552                             alc260_input_mixer },
6553                 .init_verbs = { alc260_init_verbs,
6554                                 alc260_hp_unsol_verbs },
6555                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6556                 .dac_nids = alc260_dac_nids,
6557                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6558                 .adc_nids = alc260_adc_nids_alt,
6559                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6560                 .channel_mode = alc260_modes,
6561                 .input_mux = &alc260_capture_source,
6562                 .unsol_event = alc260_hp_unsol_event,
6563                 .init_hook = alc260_hp_automute,
6564         },
6565         [ALC260_HP_DC7600] = {
6566                 .mixers = { alc260_hp_dc7600_mixer,
6567                             alc260_input_mixer },
6568                 .init_verbs = { alc260_init_verbs,
6569                                 alc260_hp_dc7600_verbs },
6570                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6571                 .dac_nids = alc260_dac_nids,
6572                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6573                 .adc_nids = alc260_adc_nids_alt,
6574                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6575                 .channel_mode = alc260_modes,
6576                 .input_mux = &alc260_capture_source,
6577                 .unsol_event = alc260_hp_3012_unsol_event,
6578                 .init_hook = alc260_hp_3012_automute,
6579         },
6580         [ALC260_HP_3013] = {
6581                 .mixers = { alc260_hp_3013_mixer,
6582                             alc260_input_mixer },
6583                 .init_verbs = { alc260_hp_3013_init_verbs,
6584                                 alc260_hp_3013_unsol_verbs },
6585                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6586                 .dac_nids = alc260_dac_nids,
6587                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6588                 .adc_nids = alc260_adc_nids_alt,
6589                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6590                 .channel_mode = alc260_modes,
6591                 .input_mux = &alc260_capture_source,
6592                 .unsol_event = alc260_hp_3013_unsol_event,
6593                 .init_hook = alc260_hp_3013_automute,
6594         },
6595         [ALC260_FUJITSU_S702X] = {
6596                 .mixers = { alc260_fujitsu_mixer },
6597                 .init_verbs = { alc260_fujitsu_init_verbs },
6598                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6599                 .dac_nids = alc260_dac_nids,
6600                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6601                 .adc_nids = alc260_dual_adc_nids,
6602                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6603                 .channel_mode = alc260_modes,
6604                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6605                 .input_mux = alc260_fujitsu_capture_sources,
6606         },
6607         [ALC260_ACER] = {
6608                 .mixers = { alc260_acer_mixer },
6609                 .init_verbs = { alc260_acer_init_verbs },
6610                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6611                 .dac_nids = alc260_dac_nids,
6612                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6613                 .adc_nids = alc260_dual_adc_nids,
6614                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6615                 .channel_mode = alc260_modes,
6616                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6617                 .input_mux = alc260_acer_capture_sources,
6618         },
6619         [ALC260_FAVORIT100] = {
6620                 .mixers = { alc260_favorit100_mixer },
6621                 .init_verbs = { alc260_favorit100_init_verbs },
6622                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6623                 .dac_nids = alc260_dac_nids,
6624                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6625                 .adc_nids = alc260_dual_adc_nids,
6626                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6627                 .channel_mode = alc260_modes,
6628                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6629                 .input_mux = alc260_favorit100_capture_sources,
6630         },
6631         [ALC260_WILL] = {
6632                 .mixers = { alc260_will_mixer },
6633                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6634                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6635                 .dac_nids = alc260_dac_nids,
6636                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6637                 .adc_nids = alc260_adc_nids,
6638                 .dig_out_nid = ALC260_DIGOUT_NID,
6639                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6640                 .channel_mode = alc260_modes,
6641                 .input_mux = &alc260_capture_source,
6642         },
6643         [ALC260_REPLACER_672V] = {
6644                 .mixers = { alc260_replacer_672v_mixer },
6645                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6646                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6647                 .dac_nids = alc260_dac_nids,
6648                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6649                 .adc_nids = alc260_adc_nids,
6650                 .dig_out_nid = ALC260_DIGOUT_NID,
6651                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6652                 .channel_mode = alc260_modes,
6653                 .input_mux = &alc260_capture_source,
6654                 .unsol_event = alc260_replacer_672v_unsol_event,
6655                 .init_hook = alc260_replacer_672v_automute,
6656         },
6657 #ifdef CONFIG_SND_DEBUG
6658         [ALC260_TEST] = {
6659                 .mixers = { alc260_test_mixer },
6660                 .init_verbs = { alc260_test_init_verbs },
6661                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6662                 .dac_nids = alc260_test_dac_nids,
6663                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6664                 .adc_nids = alc260_test_adc_nids,
6665                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6666                 .channel_mode = alc260_modes,
6667                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6668                 .input_mux = alc260_test_capture_sources,
6669         },
6670 #endif
6671 };
6672
6673 static int patch_alc260(struct hda_codec *codec)
6674 {
6675         struct alc_spec *spec;
6676         int err, board_config;
6677
6678         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6679         if (spec == NULL)
6680                 return -ENOMEM;
6681
6682         codec->spec = spec;
6683
6684         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6685                                                   alc260_models,
6686                                                   alc260_cfg_tbl);
6687         if (board_config < 0) {
6688                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6689                            codec->chip_name);
6690                 board_config = ALC260_AUTO;
6691         }
6692
6693         if (board_config == ALC260_AUTO) {
6694                 /* automatic parse from the BIOS config */
6695                 err = alc260_parse_auto_config(codec);
6696                 if (err < 0) {
6697                         alc_free(codec);
6698                         return err;
6699                 } else if (!err) {
6700                         printk(KERN_INFO
6701                                "hda_codec: Cannot set up configuration "
6702                                "from BIOS.  Using base mode...\n");
6703                         board_config = ALC260_BASIC;
6704                 }
6705         }
6706
6707         err = snd_hda_attach_beep_device(codec, 0x1);
6708         if (err < 0) {
6709                 alc_free(codec);
6710                 return err;
6711         }
6712
6713         if (board_config != ALC260_AUTO)
6714                 setup_preset(codec, &alc260_presets[board_config]);
6715
6716         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6717         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6718
6719         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6720         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6721
6722         if (!spec->adc_nids && spec->input_mux) {
6723                 /* check whether NID 0x04 is valid */
6724                 unsigned int wcap = get_wcaps(codec, 0x04);
6725                 wcap = get_wcaps_type(wcap);
6726                 /* get type */
6727                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6728                         spec->adc_nids = alc260_adc_nids_alt;
6729                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6730                 } else {
6731                         spec->adc_nids = alc260_adc_nids;
6732                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6733                 }
6734         }
6735         set_capture_mixer(codec);
6736         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6737
6738         spec->vmaster_nid = 0x08;
6739
6740         codec->patch_ops = alc_patch_ops;
6741         if (board_config == ALC260_AUTO)
6742                 spec->init_hook = alc260_auto_init;
6743 #ifdef CONFIG_SND_HDA_POWER_SAVE
6744         if (!spec->loopback.amplist)
6745                 spec->loopback.amplist = alc260_loopbacks;
6746 #endif
6747
6748         return 0;
6749 }
6750
6751
6752 /*
6753  * ALC882/883/885/888/889 support
6754  *
6755  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6756  * configuration.  Each pin widget can choose any input DACs and a mixer.
6757  * Each ADC is connected from a mixer of all inputs.  This makes possible
6758  * 6-channel independent captures.
6759  *
6760  * In addition, an independent DAC for the multi-playback (not used in this
6761  * driver yet).
6762  */
6763 #define ALC882_DIGOUT_NID       0x06
6764 #define ALC882_DIGIN_NID        0x0a
6765 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6766 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6767 #define ALC1200_DIGOUT_NID      0x10
6768
6769
6770 static struct hda_channel_mode alc882_ch_modes[1] = {
6771         { 8, NULL }
6772 };
6773
6774 /* DACs */
6775 static hda_nid_t alc882_dac_nids[4] = {
6776         /* front, rear, clfe, rear_surr */
6777         0x02, 0x03, 0x04, 0x05
6778 };
6779 #define alc883_dac_nids         alc882_dac_nids
6780
6781 /* ADCs */
6782 #define alc882_adc_nids         alc880_adc_nids
6783 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6784 #define alc883_adc_nids         alc882_adc_nids_alt
6785 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6786 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6787 #define alc889_adc_nids         alc880_adc_nids
6788
6789 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6790 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6791 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6792 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6793 #define alc889_capsrc_nids      alc882_capsrc_nids
6794
6795 /* input MUX */
6796 /* FIXME: should be a matrix-type input source selection */
6797
6798 static struct hda_input_mux alc882_capture_source = {
6799         .num_items = 4,
6800         .items = {
6801                 { "Mic", 0x0 },
6802                 { "Front Mic", 0x1 },
6803                 { "Line", 0x2 },
6804                 { "CD", 0x4 },
6805         },
6806 };
6807
6808 #define alc883_capture_source   alc882_capture_source
6809
6810 static struct hda_input_mux alc889_capture_source = {
6811         .num_items = 3,
6812         .items = {
6813                 { "Front Mic", 0x0 },
6814                 { "Mic", 0x3 },
6815                 { "Line", 0x2 },
6816         },
6817 };
6818
6819 static struct hda_input_mux mb5_capture_source = {
6820         .num_items = 3,
6821         .items = {
6822                 { "Mic", 0x1 },
6823                 { "Line", 0x2 },
6824                 { "CD", 0x4 },
6825         },
6826 };
6827
6828 static struct hda_input_mux macmini3_capture_source = {
6829         .num_items = 2,
6830         .items = {
6831                 { "Line", 0x2 },
6832                 { "CD", 0x4 },
6833         },
6834 };
6835
6836 static struct hda_input_mux alc883_3stack_6ch_intel = {
6837         .num_items = 4,
6838         .items = {
6839                 { "Mic", 0x1 },
6840                 { "Front Mic", 0x0 },
6841                 { "Line", 0x2 },
6842                 { "CD", 0x4 },
6843         },
6844 };
6845
6846 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6847         .num_items = 2,
6848         .items = {
6849                 { "Mic", 0x1 },
6850                 { "Line", 0x2 },
6851         },
6852 };
6853
6854 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6855         .num_items = 4,
6856         .items = {
6857                 { "Mic", 0x0 },
6858                 { "iMic", 0x1 },
6859                 { "Line", 0x2 },
6860                 { "CD", 0x4 },
6861         },
6862 };
6863
6864 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6865         .num_items = 2,
6866         .items = {
6867                 { "Mic", 0x0 },
6868                 { "Int Mic", 0x1 },
6869         },
6870 };
6871
6872 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6873         .num_items = 3,
6874         .items = {
6875                 { "Mic", 0x0 },
6876                 { "Front Mic", 0x1 },
6877                 { "Line", 0x4 },
6878         },
6879 };
6880
6881 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6882         .num_items = 2,
6883         .items = {
6884                 { "Mic", 0x0 },
6885                 { "Line", 0x2 },
6886         },
6887 };
6888
6889 static struct hda_input_mux alc889A_mb31_capture_source = {
6890         .num_items = 2,
6891         .items = {
6892                 { "Mic", 0x0 },
6893                 /* Front Mic (0x01) unused */
6894                 { "Line", 0x2 },
6895                 /* Line 2 (0x03) unused */
6896                 /* CD (0x04) unused? */
6897         },
6898 };
6899
6900 /*
6901  * 2ch mode
6902  */
6903 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6904         { 2, NULL }
6905 };
6906
6907 /*
6908  * 2ch mode
6909  */
6910 static struct hda_verb alc882_3ST_ch2_init[] = {
6911         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6912         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6913         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6914         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6915         { } /* end */
6916 };
6917
6918 /*
6919  * 4ch mode
6920  */
6921 static struct hda_verb alc882_3ST_ch4_init[] = {
6922         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6923         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6924         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6925         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6926         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6927         { } /* end */
6928 };
6929
6930 /*
6931  * 6ch mode
6932  */
6933 static struct hda_verb alc882_3ST_ch6_init[] = {
6934         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6935         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6936         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6937         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6938         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6939         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6940         { } /* end */
6941 };
6942
6943 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6944         { 2, alc882_3ST_ch2_init },
6945         { 4, alc882_3ST_ch4_init },
6946         { 6, alc882_3ST_ch6_init },
6947 };
6948
6949 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6950
6951 /*
6952  * 2ch mode
6953  */
6954 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6955         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6956         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6957         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6958         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6959         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6960         { } /* end */
6961 };
6962
6963 /*
6964  * 4ch mode
6965  */
6966 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6967         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6968         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6969         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6970         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6971         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6972         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6973         { } /* end */
6974 };
6975
6976 /*
6977  * 6ch mode
6978  */
6979 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6980         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6981         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6982         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6983         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6984         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6985         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6986         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6987         { } /* end */
6988 };
6989
6990 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6991         { 2, alc883_3ST_ch2_clevo_init },
6992         { 4, alc883_3ST_ch4_clevo_init },
6993         { 6, alc883_3ST_ch6_clevo_init },
6994 };
6995
6996
6997 /*
6998  * 6ch mode
6999  */
7000 static struct hda_verb alc882_sixstack_ch6_init[] = {
7001         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7002         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7003         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7004         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7005         { } /* end */
7006 };
7007
7008 /*
7009  * 8ch mode
7010  */
7011 static struct hda_verb alc882_sixstack_ch8_init[] = {
7012         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7013         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7014         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7015         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7016         { } /* end */
7017 };
7018
7019 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7020         { 6, alc882_sixstack_ch6_init },
7021         { 8, alc882_sixstack_ch8_init },
7022 };
7023
7024
7025 /* Macbook Air 2,1 */
7026
7027 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7028       { 2, NULL },
7029 };
7030
7031 /*
7032  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7033  */
7034
7035 /*
7036  * 2ch mode
7037  */
7038 static struct hda_verb alc885_mbp_ch2_init[] = {
7039         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7040         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7041         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7042         { } /* end */
7043 };
7044
7045 /*
7046  * 4ch mode
7047  */
7048 static struct hda_verb alc885_mbp_ch4_init[] = {
7049         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7050         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7051         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7052         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7053         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7054         { } /* end */
7055 };
7056
7057 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7058         { 2, alc885_mbp_ch2_init },
7059         { 4, alc885_mbp_ch4_init },
7060 };
7061
7062 /*
7063  * 2ch
7064  * Speakers/Woofer/HP = Front
7065  * LineIn = Input
7066  */
7067 static struct hda_verb alc885_mb5_ch2_init[] = {
7068         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7069         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7070         { } /* end */
7071 };
7072
7073 /*
7074  * 6ch mode
7075  * Speakers/HP = Front
7076  * Woofer = LFE
7077  * LineIn = Surround
7078  */
7079 static struct hda_verb alc885_mb5_ch6_init[] = {
7080         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7081         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7083         { } /* end */
7084 };
7085
7086 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7087         { 2, alc885_mb5_ch2_init },
7088         { 6, alc885_mb5_ch6_init },
7089 };
7090
7091 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7092
7093 /*
7094  * 2ch mode
7095  */
7096 static struct hda_verb alc883_4ST_ch2_init[] = {
7097         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7098         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7099         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7100         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7101         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7102         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7103         { } /* end */
7104 };
7105
7106 /*
7107  * 4ch mode
7108  */
7109 static struct hda_verb alc883_4ST_ch4_init[] = {
7110         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7111         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7112         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7113         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7114         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7115         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7116         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7117         { } /* end */
7118 };
7119
7120 /*
7121  * 6ch mode
7122  */
7123 static struct hda_verb alc883_4ST_ch6_init[] = {
7124         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7125         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7126         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7127         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7128         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7129         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7130         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7131         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7132         { } /* end */
7133 };
7134
7135 /*
7136  * 8ch mode
7137  */
7138 static struct hda_verb alc883_4ST_ch8_init[] = {
7139         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7140         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7141         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7142         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7143         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7144         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7145         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7146         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7147         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7148         { } /* end */
7149 };
7150
7151 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7152         { 2, alc883_4ST_ch2_init },
7153         { 4, alc883_4ST_ch4_init },
7154         { 6, alc883_4ST_ch6_init },
7155         { 8, alc883_4ST_ch8_init },
7156 };
7157
7158
7159 /*
7160  * 2ch mode
7161  */
7162 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7163         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7164         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7165         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7166         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7167         { } /* end */
7168 };
7169
7170 /*
7171  * 4ch mode
7172  */
7173 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7174         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7175         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7176         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7177         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7178         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7179         { } /* end */
7180 };
7181
7182 /*
7183  * 6ch mode
7184  */
7185 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7186         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7187         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7188         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7189         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7190         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7191         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7192         { } /* end */
7193 };
7194
7195 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7196         { 2, alc883_3ST_ch2_intel_init },
7197         { 4, alc883_3ST_ch4_intel_init },
7198         { 6, alc883_3ST_ch6_intel_init },
7199 };
7200
7201 /*
7202  * 2ch mode
7203  */
7204 static struct hda_verb alc889_ch2_intel_init[] = {
7205         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7206         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7207         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7208         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7209         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7210         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7211         { } /* end */
7212 };
7213
7214 /*
7215  * 6ch mode
7216  */
7217 static struct hda_verb alc889_ch6_intel_init[] = {
7218         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7219         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7220         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7221         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7222         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7223         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7224         { } /* end */
7225 };
7226
7227 /*
7228  * 8ch mode
7229  */
7230 static struct hda_verb alc889_ch8_intel_init[] = {
7231         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7232         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7233         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7234         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7235         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7236         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7237         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7238         { } /* end */
7239 };
7240
7241 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7242         { 2, alc889_ch2_intel_init },
7243         { 6, alc889_ch6_intel_init },
7244         { 8, alc889_ch8_intel_init },
7245 };
7246
7247 /*
7248  * 6ch mode
7249  */
7250 static struct hda_verb alc883_sixstack_ch6_init[] = {
7251         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7252         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7253         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7254         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7255         { } /* end */
7256 };
7257
7258 /*
7259  * 8ch mode
7260  */
7261 static struct hda_verb alc883_sixstack_ch8_init[] = {
7262         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7263         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7264         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7265         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7266         { } /* end */
7267 };
7268
7269 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7270         { 6, alc883_sixstack_ch6_init },
7271         { 8, alc883_sixstack_ch8_init },
7272 };
7273
7274
7275 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7276  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7277  */
7278 static struct snd_kcontrol_new alc882_base_mixer[] = {
7279         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7280         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7281         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7282         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7283         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7284         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7285         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7286         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7287         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7288         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7289         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7290         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7291         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7292         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7293         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7294         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7295         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7296         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7297         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7298         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7299         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7300         { } /* end */
7301 };
7302
7303 /* Macbook Air 2,1 same control for HP and internal Speaker */
7304
7305 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7306       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7307       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7308      { }
7309 };
7310
7311
7312 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7313         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7314         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7315         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7316         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7317         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7318         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7319         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7320         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7321         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7322         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7323         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7324         { } /* end */
7325 };
7326
7327 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7328         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7329         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7330         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7331         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7332         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7333         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7334         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7335         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7336         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7337         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7338         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7339         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7340         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7341         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7342         { } /* end */
7343 };
7344
7345 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7346         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7347         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7348         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7349         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7350         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7351         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7352         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7353         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7354         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7355         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7356         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7357         { } /* end */
7358 };
7359
7360 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7361         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7362         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7363         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7364         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7365         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7366         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7367         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7368         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7369         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7370         { } /* end */
7371 };
7372
7373
7374 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7375         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7376         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7377         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7378         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7379         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7380         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7381         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7382         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7383         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7384         { } /* end */
7385 };
7386
7387 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7388         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7389         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7390         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7391         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7392         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7393         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7394         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7395         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7396         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7397         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7398         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7399         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7400         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7401         { } /* end */
7402 };
7403
7404 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7405  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7406  */
7407 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7408         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7409         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7410         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7411         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7412         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7413         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7414         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7415         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7416         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7417         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7418         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7419         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7420         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7421         { } /* end */
7422 };
7423
7424 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7425         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7426         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7427         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7428         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7429         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7430         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7431         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7432         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7433         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7434         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7435         { } /* end */
7436 };
7437
7438 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7439         {
7440                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7441                 .name = "Channel Mode",
7442                 .info = alc_ch_mode_info,
7443                 .get = alc_ch_mode_get,
7444                 .put = alc_ch_mode_put,
7445         },
7446         { } /* end */
7447 };
7448
7449 static struct hda_verb alc882_base_init_verbs[] = {
7450         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7451         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7452         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7453         /* Rear mixer */
7454         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7455         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7456         /* CLFE mixer */
7457         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7458         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7459         /* Side mixer */
7460         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7461         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7462
7463         /* Front Pin: output 0 (0x0c) */
7464         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7465         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7466         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7467         /* Rear Pin: output 1 (0x0d) */
7468         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7469         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7470         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7471         /* CLFE Pin: output 2 (0x0e) */
7472         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7473         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7474         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7475         /* Side Pin: output 3 (0x0f) */
7476         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7477         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7478         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7479         /* Mic (rear) pin: input vref at 80% */
7480         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7481         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7482         /* Front Mic pin: input vref at 80% */
7483         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7484         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7485         /* Line In pin: input */
7486         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7487         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7488         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7489         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7490         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7491         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7492         /* CD pin widget for input */
7493         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7494
7495         /* FIXME: use matrix-type input source selection */
7496         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7497         /* Input mixer2 */
7498         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7499         /* Input mixer3 */
7500         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7501         /* ADC2: mute amp left and right */
7502         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7503         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7504         /* ADC3: mute amp left and right */
7505         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7506         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7507
7508         { }
7509 };
7510
7511 static struct hda_verb alc882_adc1_init_verbs[] = {
7512         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7513         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7514         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7515         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7516         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7517         /* ADC1: mute amp left and right */
7518         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7519         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7520         { }
7521 };
7522
7523 static struct hda_verb alc882_eapd_verbs[] = {
7524         /* change to EAPD mode */
7525         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7526         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7527         { }
7528 };
7529
7530 static struct hda_verb alc889_eapd_verbs[] = {
7531         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7532         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7533         { }
7534 };
7535
7536 static struct hda_verb alc_hp15_unsol_verbs[] = {
7537         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7538         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7539         {}
7540 };
7541
7542 static struct hda_verb alc885_init_verbs[] = {
7543         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7544         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7545         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7546         /* Rear mixer */
7547         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7548         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7549         /* CLFE mixer */
7550         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7551         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7552         /* Side mixer */
7553         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7554         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7555
7556         /* Front HP Pin: output 0 (0x0c) */
7557         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7558         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7559         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7560         /* Front Pin: output 0 (0x0c) */
7561         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7562         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7563         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7564         /* Rear Pin: output 1 (0x0d) */
7565         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7566         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7567         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7568         /* CLFE Pin: output 2 (0x0e) */
7569         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7570         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7571         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7572         /* Side Pin: output 3 (0x0f) */
7573         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7574         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7575         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7576         /* Mic (rear) pin: input vref at 80% */
7577         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7578         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7579         /* Front Mic pin: input vref at 80% */
7580         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7581         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7582         /* Line In pin: input */
7583         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7584         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7585
7586         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7587         /* Input mixer1 */
7588         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7589         /* Input mixer2 */
7590         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7591         /* Input mixer3 */
7592         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7593         /* ADC2: mute amp left and right */
7594         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7595         /* ADC3: mute amp left and right */
7596         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7597
7598         { }
7599 };
7600
7601 static struct hda_verb alc885_init_input_verbs[] = {
7602         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7603         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7604         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7605         { }
7606 };
7607
7608
7609 /* Unmute Selector 24h and set the default input to front mic */
7610 static struct hda_verb alc889_init_input_verbs[] = {
7611         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7612         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7613         { }
7614 };
7615
7616
7617 #define alc883_init_verbs       alc882_base_init_verbs
7618
7619 /* Mac Pro test */
7620 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7621         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7622         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7623         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7624         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7625         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7626         /* FIXME: this looks suspicious...
7627         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7628         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7629         */
7630         { } /* end */
7631 };
7632
7633 static struct hda_verb alc882_macpro_init_verbs[] = {
7634         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7635         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7636         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7637         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7638         /* Front Pin: output 0 (0x0c) */
7639         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7640         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7641         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7642         /* Front Mic pin: input vref at 80% */
7643         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7644         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7645         /* Speaker:  output */
7646         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7647         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7648         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7649         /* Headphone output (output 0 - 0x0c) */
7650         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7651         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7652         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7653
7654         /* FIXME: use matrix-type input source selection */
7655         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7656         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7657         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7658         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7659         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7660         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7661         /* Input mixer2 */
7662         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7663         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7664         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7665         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7666         /* Input mixer3 */
7667         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7668         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7669         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7670         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7671         /* ADC1: mute amp left and right */
7672         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7673         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7674         /* ADC2: mute amp left and right */
7675         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7676         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7677         /* ADC3: mute amp left and right */
7678         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7679         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7680
7681         { }
7682 };
7683
7684 /* Macbook 5,1 */
7685 static struct hda_verb alc885_mb5_init_verbs[] = {
7686         /* DACs */
7687         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7688         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7689         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7690         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7691         /* Front mixer */
7692         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7693         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7694         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7695         /* Surround mixer */
7696         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7697         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7698         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7699         /* LFE mixer */
7700         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7701         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7702         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7703         /* HP mixer */
7704         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7705         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7706         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7707         /* Front Pin (0x0c) */
7708         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7709         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7710         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7711         /* LFE Pin (0x0e) */
7712         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7713         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7714         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7715         /* HP Pin (0x0f) */
7716         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7717         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7718         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7719         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7720         /* Front Mic pin: input vref at 80% */
7721         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7722         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7723         /* Line In pin */
7724         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7725         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7726
7727         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7728         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7729         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7730         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7731         { }
7732 };
7733
7734 /* Macmini 3,1 */
7735 static struct hda_verb alc885_macmini3_init_verbs[] = {
7736         /* DACs */
7737         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7738         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7739         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7740         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7741         /* Front mixer */
7742         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7744         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7745         /* Surround mixer */
7746         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7747         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7748         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7749         /* LFE mixer */
7750         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7751         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7752         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7753         /* HP mixer */
7754         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7755         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7756         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7757         /* Front Pin (0x0c) */
7758         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7759         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7760         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7761         /* LFE Pin (0x0e) */
7762         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7763         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7764         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7765         /* HP Pin (0x0f) */
7766         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7767         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7768         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7769         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7770         /* Line In pin */
7771         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7772         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7773
7774         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7775         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7776         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7777         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7778         { }
7779 };
7780
7781
7782 static struct hda_verb alc885_mba21_init_verbs[] = {
7783         /*Internal and HP Speaker Mixer*/
7784         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7785         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7786         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7787         /*Internal Speaker Pin (0x0c)*/
7788         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
7789         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7790         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7791         /* HP Pin: output 0 (0x0e) */
7792         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7793         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7794         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7795         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
7796         /* Line in (is hp when jack connected)*/
7797         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
7798         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7799
7800         { }
7801  };
7802
7803
7804 /* Macbook Pro rev3 */
7805 static struct hda_verb alc885_mbp3_init_verbs[] = {
7806         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7807         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7808         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7809         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7810         /* Rear mixer */
7811         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7812         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7813         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7814         /* HP mixer */
7815         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7816         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7817         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7818         /* Front Pin: output 0 (0x0c) */
7819         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7820         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7821         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7822         /* HP Pin: output 0 (0x0e) */
7823         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7824         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7825         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7826         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7827         /* Mic (rear) pin: input vref at 80% */
7828         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7829         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7830         /* Front Mic pin: input vref at 80% */
7831         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7832         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7833         /* Line In pin: use output 1 when in LineOut mode */
7834         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7835         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7836         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7837
7838         /* FIXME: use matrix-type input source selection */
7839         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7840         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7841         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7842         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7843         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7844         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7845         /* Input mixer2 */
7846         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7847         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7848         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7849         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7850         /* Input mixer3 */
7851         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7852         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7853         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7854         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7855         /* ADC1: mute amp left and right */
7856         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7857         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7858         /* ADC2: mute amp left and right */
7859         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7860         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7861         /* ADC3: mute amp left and right */
7862         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7863         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7864
7865         { }
7866 };
7867
7868 /* iMac 9,1 */
7869 static struct hda_verb alc885_imac91_init_verbs[] = {
7870         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7871         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7872         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7873         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7874         /* Rear mixer */
7875         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7876         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7877         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7878         /* HP Pin: output 0 (0x0c) */
7879         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7880         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7881         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7882         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7883         /* Internal Speakers: output 0 (0x0d) */
7884         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7885         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7886         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7887         /* Mic (rear) pin: input vref at 80% */
7888         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7889         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7890         /* Front Mic pin: input vref at 80% */
7891         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7892         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7893         /* Line In pin: use output 1 when in LineOut mode */
7894         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7895         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7896         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7897
7898         /* FIXME: use matrix-type input source selection */
7899         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7900         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7901         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7902         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7903         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7904         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7905         /* Input mixer2 */
7906         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7907         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7908         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7909         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7910         /* Input mixer3 */
7911         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7912         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7913         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7914         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7915         /* ADC1: mute amp left and right */
7916         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7917         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7918         /* ADC2: mute amp left and right */
7919         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7920         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7921         /* ADC3: mute amp left and right */
7922         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7923         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7924
7925         { }
7926 };
7927
7928 /* iMac 24 mixer. */
7929 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7930         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7931         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7932         { } /* end */
7933 };
7934
7935 /* iMac 24 init verbs. */
7936 static struct hda_verb alc885_imac24_init_verbs[] = {
7937         /* Internal speakers: output 0 (0x0c) */
7938         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7939         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7940         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7941         /* Internal speakers: output 0 (0x0c) */
7942         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7943         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7944         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7945         /* Headphone: output 0 (0x0c) */
7946         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7947         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7948         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7949         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7950         /* Front Mic: input vref at 80% */
7951         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7952         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7953         { }
7954 };
7955
7956 /* Toggle speaker-output according to the hp-jack state */
7957 static void alc885_imac24_setup(struct hda_codec *codec)
7958 {
7959         struct alc_spec *spec = codec->spec;
7960
7961         spec->autocfg.hp_pins[0] = 0x14;
7962         spec->autocfg.speaker_pins[0] = 0x18;
7963         spec->autocfg.speaker_pins[1] = 0x1a;
7964 }
7965
7966 #define alc885_mb5_setup        alc885_imac24_setup
7967 #define alc885_macmini3_setup   alc885_imac24_setup
7968
7969 /* Macbook Air 2,1 */
7970 static void alc885_mba21_setup(struct hda_codec *codec)
7971 {
7972        struct alc_spec *spec = codec->spec;
7973
7974        spec->autocfg.hp_pins[0] = 0x14;
7975        spec->autocfg.speaker_pins[0] = 0x18;
7976 }
7977
7978
7979
7980 static void alc885_mbp3_setup(struct hda_codec *codec)
7981 {
7982         struct alc_spec *spec = codec->spec;
7983
7984         spec->autocfg.hp_pins[0] = 0x15;
7985         spec->autocfg.speaker_pins[0] = 0x14;
7986 }
7987
7988 static void alc885_imac91_setup(struct hda_codec *codec)
7989 {
7990         struct alc_spec *spec = codec->spec;
7991
7992         spec->autocfg.hp_pins[0] = 0x14;
7993         spec->autocfg.speaker_pins[0] = 0x15;
7994         spec->autocfg.speaker_pins[1] = 0x1a;
7995 }
7996
7997 static struct hda_verb alc882_targa_verbs[] = {
7998         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7999         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8000
8001         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8002         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8003
8004         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8005         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8006         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8007
8008         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8009         { } /* end */
8010 };
8011
8012 /* toggle speaker-output according to the hp-jack state */
8013 static void alc882_targa_automute(struct hda_codec *codec)
8014 {
8015         struct alc_spec *spec = codec->spec;
8016         alc_automute_amp(codec);
8017         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8018                                   spec->jack_present ? 1 : 3);
8019 }
8020
8021 static void alc882_targa_setup(struct hda_codec *codec)
8022 {
8023         struct alc_spec *spec = codec->spec;
8024
8025         spec->autocfg.hp_pins[0] = 0x14;
8026         spec->autocfg.speaker_pins[0] = 0x1b;
8027 }
8028
8029 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8030 {
8031         if ((res >> 26) == ALC880_HP_EVENT)
8032                 alc882_targa_automute(codec);
8033 }
8034
8035 static struct hda_verb alc882_asus_a7j_verbs[] = {
8036         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8037         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8038
8039         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8040         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8041         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8042
8043         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8044         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8045         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8046
8047         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8048         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8049         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8050         { } /* end */
8051 };
8052
8053 static struct hda_verb alc882_asus_a7m_verbs[] = {
8054         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8055         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8056
8057         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8058         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8059         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8060
8061         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8062         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8063         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8064
8065         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8066         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8067         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8068         { } /* end */
8069 };
8070
8071 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8072 {
8073         unsigned int gpiostate, gpiomask, gpiodir;
8074
8075         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8076                                        AC_VERB_GET_GPIO_DATA, 0);
8077
8078         if (!muted)
8079                 gpiostate |= (1 << pin);
8080         else
8081                 gpiostate &= ~(1 << pin);
8082
8083         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8084                                       AC_VERB_GET_GPIO_MASK, 0);
8085         gpiomask |= (1 << pin);
8086
8087         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8088                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8089         gpiodir |= (1 << pin);
8090
8091
8092         snd_hda_codec_write(codec, codec->afg, 0,
8093                             AC_VERB_SET_GPIO_MASK, gpiomask);
8094         snd_hda_codec_write(codec, codec->afg, 0,
8095                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8096
8097         msleep(1);
8098
8099         snd_hda_codec_write(codec, codec->afg, 0,
8100                             AC_VERB_SET_GPIO_DATA, gpiostate);
8101 }
8102
8103 /* set up GPIO at initialization */
8104 static void alc885_macpro_init_hook(struct hda_codec *codec)
8105 {
8106         alc882_gpio_mute(codec, 0, 0);
8107         alc882_gpio_mute(codec, 1, 0);
8108 }
8109
8110 /* set up GPIO and update auto-muting at initialization */
8111 static void alc885_imac24_init_hook(struct hda_codec *codec)
8112 {
8113         alc885_macpro_init_hook(codec);
8114         alc_automute_amp(codec);
8115 }
8116
8117 /*
8118  * generic initialization of ADC, input mixers and output mixers
8119  */
8120 static struct hda_verb alc883_auto_init_verbs[] = {
8121         /*
8122          * Unmute ADC0-2 and set the default input to mic-in
8123          */
8124         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8125         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8126         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8127         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8128
8129         /*
8130          * Set up output mixers (0x0c - 0x0f)
8131          */
8132         /* set vol=0 to output mixers */
8133         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8134         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8135         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8136         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8137         /* set up input amps for analog loopback */
8138         /* Amp Indices: DAC = 0, mixer = 1 */
8139         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8140         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8141         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8142         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8143         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8144         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8145         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8146         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8147         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8148         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8149
8150         /* FIXME: use matrix-type input source selection */
8151         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8152         /* Input mixer2 */
8153         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8154         /* Input mixer3 */
8155         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8156         { }
8157 };
8158
8159 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8160 static struct hda_verb alc889A_mb31_ch2_init[] = {
8161         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8162         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8163         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8164         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8165         { } /* end */
8166 };
8167
8168 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8169 static struct hda_verb alc889A_mb31_ch4_init[] = {
8170         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8171         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8172         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8173         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8174         { } /* end */
8175 };
8176
8177 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8178 static struct hda_verb alc889A_mb31_ch5_init[] = {
8179         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8180         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8181         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8182         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8183         { } /* end */
8184 };
8185
8186 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8187 static struct hda_verb alc889A_mb31_ch6_init[] = {
8188         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8189         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8190         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8191         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8192         { } /* end */
8193 };
8194
8195 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8196         { 2, alc889A_mb31_ch2_init },
8197         { 4, alc889A_mb31_ch4_init },
8198         { 5, alc889A_mb31_ch5_init },
8199         { 6, alc889A_mb31_ch6_init },
8200 };
8201
8202 static struct hda_verb alc883_medion_eapd_verbs[] = {
8203         /* eanable EAPD on medion laptop */
8204         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8205         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8206         { }
8207 };
8208
8209 #define alc883_base_mixer       alc882_base_mixer
8210
8211 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8212         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8213         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8214         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8215         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8216         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8217         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8218         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8219         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8220         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8221         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8222         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8223         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8224         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8225         { } /* end */
8226 };
8227
8228 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8229         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8230         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8231         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8232         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8233         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8234         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8235         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8236         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8237         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8238         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8239         { } /* end */
8240 };
8241
8242 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8243         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8244         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8245         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8246         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8247         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8248         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8249         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8250         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8251         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8252         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8253         { } /* end */
8254 };
8255
8256 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8257         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8258         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8260         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8261         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8262         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8263         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8264         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8265         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8266         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8267         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8268         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8269         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8270         { } /* end */
8271 };
8272
8273 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8274         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8275         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8276         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8277         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8278         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8279         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8280         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8281         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8282         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8283         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8284         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8285         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8286         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8287         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8288         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8289         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8290         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8291         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8292         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8293         { } /* end */
8294 };
8295
8296 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8297         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8298         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8299         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8300         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8301         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8302                               HDA_OUTPUT),
8303         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8304         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8305         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8306         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8307         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8308         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8309         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8310         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8311         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8312         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8313         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8314         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8315         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8316         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8317         { } /* end */
8318 };
8319
8320 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8321         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8322         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8323         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8324         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8325         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8326                               HDA_OUTPUT),
8327         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8328         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8329         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8330         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8331         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8332         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8333         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8334         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8335         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8336         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8337         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8338         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8339         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8340         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8341         { } /* end */
8342 };
8343
8344 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8345         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8346         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8347         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8348         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8349         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8350         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8351         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8352         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8353         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8354         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8355         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8356         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8357         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8358         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8359         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8360         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8361         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8362         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8363         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8364         { } /* end */
8365 };
8366
8367 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8368         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8369         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8370         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8371         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8372         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8373         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8374         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8375         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8376         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8377         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8378         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8379         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8380         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8381         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8382         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8383         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8384         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8385         { } /* end */
8386 };
8387
8388 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8389         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8390         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8391         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8392         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8393         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8394         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8395         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8396         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8397         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8398         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8399         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8400         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8401         { } /* end */
8402 };
8403
8404 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8405         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8406         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8407         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8408         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8409         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8410         { } /* end */
8411 };
8412
8413 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8414         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8415         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8416         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8417         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8418         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8420         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8421         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8422         { } /* end */
8423 };
8424
8425 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8426         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8427         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8428         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8429         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8430         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8431         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8432         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8433         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8434         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8435         { } /* end */
8436 };
8437
8438 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8439         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8440         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8441         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8442         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8443         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8444         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8445         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8446         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8447         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8448         { } /* end */
8449 };
8450
8451 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8452         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8453         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8454         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8455         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8456         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8457         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8458         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8459         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8460         { } /* end */
8461 };
8462
8463 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8464         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8465         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8466         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8467         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8468         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8469         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8470         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8471         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8472         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8473         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8474         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8475         { } /* end */
8476 };
8477
8478 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8479         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8480         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8481         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8482         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8483         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8484                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8485         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8486         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8487         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8488         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8489         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8490         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8491         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8492         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8493         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8494         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8495         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8496         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8497         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8498         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8499         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8500         { } /* end */
8501 };
8502
8503 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8504         /* Output mixers */
8505         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8506         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8507         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8508         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8509         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8510                 HDA_OUTPUT),
8511         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8512         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8513         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8514         /* Output switches */
8515         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8516         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8517         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8518         /* Boost mixers */
8519         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8520         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8521         /* Input mixers */
8522         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8523         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8524         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8525         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8526         { } /* end */
8527 };
8528
8529 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8530         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8531         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8532         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8533         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8534         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8535         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8536         { } /* end */
8537 };
8538
8539 static struct hda_bind_ctls alc883_bind_cap_vol = {
8540         .ops = &snd_hda_bind_vol,
8541         .values = {
8542                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8543                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8544                 0
8545         },
8546 };
8547
8548 static struct hda_bind_ctls alc883_bind_cap_switch = {
8549         .ops = &snd_hda_bind_sw,
8550         .values = {
8551                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8552                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8553                 0
8554         },
8555 };
8556
8557 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8558         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8559         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8560         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8561         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8562         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8563         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8564         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8565         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8566         { } /* end */
8567 };
8568
8569 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8570         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8571         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8572         {
8573                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8574                 /* .name = "Capture Source", */
8575                 .name = "Input Source",
8576                 .count = 1,
8577                 .info = alc_mux_enum_info,
8578                 .get = alc_mux_enum_get,
8579                 .put = alc_mux_enum_put,
8580         },
8581         { } /* end */
8582 };
8583
8584 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8585         {
8586                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8587                 .name = "Channel Mode",
8588                 .info = alc_ch_mode_info,
8589                 .get = alc_ch_mode_get,
8590                 .put = alc_ch_mode_put,
8591         },
8592         { } /* end */
8593 };
8594
8595 /* toggle speaker-output according to the hp-jack state */
8596 static void alc883_mitac_setup(struct hda_codec *codec)
8597 {
8598         struct alc_spec *spec = codec->spec;
8599
8600         spec->autocfg.hp_pins[0] = 0x15;
8601         spec->autocfg.speaker_pins[0] = 0x14;
8602         spec->autocfg.speaker_pins[1] = 0x17;
8603 }
8604
8605 /* auto-toggle front mic */
8606 /*
8607 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8608 {
8609         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8610
8611         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8612 }
8613 */
8614
8615 static struct hda_verb alc883_mitac_verbs[] = {
8616         /* HP */
8617         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8618         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8619         /* Subwoofer */
8620         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8621         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8622
8623         /* enable unsolicited event */
8624         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8625         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8626
8627         { } /* end */
8628 };
8629
8630 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8631         /* HP */
8632         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8633         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8634         /* Int speaker */
8635         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8636
8637         /* enable unsolicited event */
8638         /*
8639         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8640         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8641         */
8642
8643         { } /* end */
8644 };
8645
8646 static struct hda_verb alc883_clevo_m720_verbs[] = {
8647         /* HP */
8648         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8649         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8650         /* Int speaker */
8651         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8652         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8653
8654         /* enable unsolicited event */
8655         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8656         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8657
8658         { } /* end */
8659 };
8660
8661 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8662         /* HP */
8663         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8664         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8665         /* Subwoofer */
8666         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8667         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8668
8669         /* enable unsolicited event */
8670         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8671
8672         { } /* end */
8673 };
8674
8675 static struct hda_verb alc883_targa_verbs[] = {
8676         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8677         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8678
8679         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8680         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8681
8682 /* Connect Line-Out side jack (SPDIF) to Side */
8683         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8684         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8685         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8686 /* Connect Mic jack to CLFE */
8687         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8688         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8689         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8690 /* Connect Line-in jack to Surround */
8691         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8692         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8693         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8694 /* Connect HP out jack to Front */
8695         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8696         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8697         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8698
8699         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8700
8701         { } /* end */
8702 };
8703
8704 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8705         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8706         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8707         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8708         { } /* end */
8709 };
8710
8711 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8712         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8713         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8714         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8715         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8716         { } /* end */
8717 };
8718
8719 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8720         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8721         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8722         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8723         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8724         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8725         { } /* end */
8726 };
8727
8728 static struct hda_verb alc883_haier_w66_verbs[] = {
8729         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8730         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8731
8732         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8733
8734         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8735         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8736         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8737         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8738         { } /* end */
8739 };
8740
8741 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8742         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8744         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8745         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8746         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8747         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8748         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8749         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8750         { } /* end */
8751 };
8752
8753 static struct hda_verb alc888_6st_dell_verbs[] = {
8754         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8755         { }
8756 };
8757
8758 static struct hda_verb alc883_vaiott_verbs[] = {
8759         /* HP */
8760         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8761         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8762
8763         /* enable unsolicited event */
8764         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8765
8766         { } /* end */
8767 };
8768
8769 static void alc888_3st_hp_setup(struct hda_codec *codec)
8770 {
8771         struct alc_spec *spec = codec->spec;
8772
8773         spec->autocfg.hp_pins[0] = 0x1b;
8774         spec->autocfg.speaker_pins[0] = 0x14;
8775         spec->autocfg.speaker_pins[1] = 0x16;
8776         spec->autocfg.speaker_pins[2] = 0x18;
8777 }
8778
8779 static struct hda_verb alc888_3st_hp_verbs[] = {
8780         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8781         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8782         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8783         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8784         { } /* end */
8785 };
8786
8787 /*
8788  * 2ch mode
8789  */
8790 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8791         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8792         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8793         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8794         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8795         { } /* end */
8796 };
8797
8798 /*
8799  * 4ch mode
8800  */
8801 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8802         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8803         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8804         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8805         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8806         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8807         { } /* end */
8808 };
8809
8810 /*
8811  * 6ch mode
8812  */
8813 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8814         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8815         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8816         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8817         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8818         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8819         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8820         { } /* end */
8821 };
8822
8823 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8824         { 2, alc888_3st_hp_2ch_init },
8825         { 4, alc888_3st_hp_4ch_init },
8826         { 6, alc888_3st_hp_6ch_init },
8827 };
8828
8829 /* toggle front-jack and RCA according to the hp-jack state */
8830 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8831 {
8832         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8833
8834         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8835                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8836         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8837                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8838 }
8839
8840 /* toggle RCA according to the front-jack state */
8841 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8842 {
8843         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8844
8845         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8846                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8847 }
8848
8849 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8850                                              unsigned int res)
8851 {
8852         if ((res >> 26) == ALC880_HP_EVENT)
8853                 alc888_lenovo_ms7195_front_automute(codec);
8854         if ((res >> 26) == ALC880_FRONT_EVENT)
8855                 alc888_lenovo_ms7195_rca_automute(codec);
8856 }
8857
8858 static struct hda_verb alc883_medion_md2_verbs[] = {
8859         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8860         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8861
8862         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8863
8864         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8865         { } /* end */
8866 };
8867
8868 /* toggle speaker-output according to the hp-jack state */
8869 static void alc883_medion_md2_setup(struct hda_codec *codec)
8870 {
8871         struct alc_spec *spec = codec->spec;
8872
8873         spec->autocfg.hp_pins[0] = 0x14;
8874         spec->autocfg.speaker_pins[0] = 0x15;
8875 }
8876
8877 /* toggle speaker-output according to the hp-jack state */
8878 #define alc883_targa_init_hook          alc882_targa_init_hook
8879 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8880
8881 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8882 {
8883         unsigned int present;
8884
8885         present = snd_hda_jack_detect(codec, 0x18);
8886         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8887                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8888 }
8889
8890 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8891 {
8892         struct alc_spec *spec = codec->spec;
8893
8894         spec->autocfg.hp_pins[0] = 0x15;
8895         spec->autocfg.speaker_pins[0] = 0x14;
8896 }
8897
8898 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8899 {
8900         alc_automute_amp(codec);
8901         alc883_clevo_m720_mic_automute(codec);
8902 }
8903
8904 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8905                                            unsigned int res)
8906 {
8907         switch (res >> 26) {
8908         case ALC880_MIC_EVENT:
8909                 alc883_clevo_m720_mic_automute(codec);
8910                 break;
8911         default:
8912                 alc_automute_amp_unsol_event(codec, res);
8913                 break;
8914         }
8915 }
8916
8917 /* toggle speaker-output according to the hp-jack state */
8918 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8919 {
8920         struct alc_spec *spec = codec->spec;
8921
8922         spec->autocfg.hp_pins[0] = 0x14;
8923         spec->autocfg.speaker_pins[0] = 0x15;
8924 }
8925
8926 static void alc883_haier_w66_setup(struct hda_codec *codec)
8927 {
8928         struct alc_spec *spec = codec->spec;
8929
8930         spec->autocfg.hp_pins[0] = 0x1b;
8931         spec->autocfg.speaker_pins[0] = 0x14;
8932 }
8933
8934 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8935 {
8936         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8937
8938         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8939                                  HDA_AMP_MUTE, bits);
8940 }
8941
8942 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8943 {
8944         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8945
8946         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8947                                  HDA_AMP_MUTE, bits);
8948         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8949                                  HDA_AMP_MUTE, bits);
8950 }
8951
8952 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8953                                            unsigned int res)
8954 {
8955         if ((res >> 26) == ALC880_HP_EVENT)
8956                 alc883_lenovo_101e_all_automute(codec);
8957         if ((res >> 26) == ALC880_FRONT_EVENT)
8958                 alc883_lenovo_101e_ispeaker_automute(codec);
8959 }
8960
8961 /* toggle speaker-output according to the hp-jack state */
8962 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8963 {
8964         struct alc_spec *spec = codec->spec;
8965
8966         spec->autocfg.hp_pins[0] = 0x14;
8967         spec->autocfg.speaker_pins[0] = 0x15;
8968         spec->autocfg.speaker_pins[1] = 0x16;
8969 }
8970
8971 static struct hda_verb alc883_acer_eapd_verbs[] = {
8972         /* HP Pin: output 0 (0x0c) */
8973         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8974         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8975         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8976         /* Front Pin: output 0 (0x0c) */
8977         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8978         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8979         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8980         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8981         /* eanable EAPD on medion laptop */
8982         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8983         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8984         /* enable unsolicited event */
8985         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8986         { }
8987 };
8988
8989 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8990         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8991         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8992         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8993         { } /* end */
8994 };
8995
8996 static void alc888_6st_dell_setup(struct hda_codec *codec)
8997 {
8998         struct alc_spec *spec = codec->spec;
8999
9000         spec->autocfg.hp_pins[0] = 0x1b;
9001         spec->autocfg.speaker_pins[0] = 0x14;
9002         spec->autocfg.speaker_pins[1] = 0x15;
9003         spec->autocfg.speaker_pins[2] = 0x16;
9004         spec->autocfg.speaker_pins[3] = 0x17;
9005 }
9006
9007 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9008 {
9009         struct alc_spec *spec = codec->spec;
9010
9011         spec->autocfg.hp_pins[0] = 0x1b;
9012         spec->autocfg.speaker_pins[0] = 0x14;
9013         spec->autocfg.speaker_pins[1] = 0x15;
9014         spec->autocfg.speaker_pins[2] = 0x16;
9015         spec->autocfg.speaker_pins[3] = 0x17;
9016         spec->autocfg.speaker_pins[4] = 0x1a;
9017 }
9018
9019 static void alc883_vaiott_setup(struct hda_codec *codec)
9020 {
9021         struct alc_spec *spec = codec->spec;
9022
9023         spec->autocfg.hp_pins[0] = 0x15;
9024         spec->autocfg.speaker_pins[0] = 0x14;
9025         spec->autocfg.speaker_pins[1] = 0x17;
9026 }
9027
9028 static struct hda_verb alc888_asus_m90v_verbs[] = {
9029         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9030         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9031         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9032         /* enable unsolicited event */
9033         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9034         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9035         { } /* end */
9036 };
9037
9038 static void alc883_mode2_setup(struct hda_codec *codec)
9039 {
9040         struct alc_spec *spec = codec->spec;
9041
9042         spec->autocfg.hp_pins[0] = 0x1b;
9043         spec->autocfg.speaker_pins[0] = 0x14;
9044         spec->autocfg.speaker_pins[1] = 0x15;
9045         spec->autocfg.speaker_pins[2] = 0x16;
9046         spec->ext_mic.pin = 0x18;
9047         spec->int_mic.pin = 0x19;
9048         spec->ext_mic.mux_idx = 0;
9049         spec->int_mic.mux_idx = 1;
9050         spec->auto_mic = 1;
9051 }
9052
9053 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9054         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9055         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9056         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9057         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9058         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9059         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9060         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9061         /* enable unsolicited event */
9062         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9063         { } /* end */
9064 };
9065
9066 static void alc883_eee1601_inithook(struct hda_codec *codec)
9067 {
9068         struct alc_spec *spec = codec->spec;
9069
9070         spec->autocfg.hp_pins[0] = 0x14;
9071         spec->autocfg.speaker_pins[0] = 0x1b;
9072         alc_automute_pin(codec);
9073 }
9074
9075 static struct hda_verb alc889A_mb31_verbs[] = {
9076         /* Init rear pin (used as headphone output) */
9077         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9078         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9079         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9080         /* Init line pin (used as output in 4ch and 6ch mode) */
9081         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9082         /* Init line 2 pin (used as headphone out by default) */
9083         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9084         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9085         { } /* end */
9086 };
9087
9088 /* Mute speakers according to the headphone jack state */
9089 static void alc889A_mb31_automute(struct hda_codec *codec)
9090 {
9091         unsigned int present;
9092
9093         /* Mute only in 2ch or 4ch mode */
9094         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9095             == 0x00) {
9096                 present = snd_hda_jack_detect(codec, 0x15);
9097                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9098                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9099                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9100                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9101         }
9102 }
9103
9104 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9105 {
9106         if ((res >> 26) == ALC880_HP_EVENT)
9107                 alc889A_mb31_automute(codec);
9108 }
9109
9110
9111 #ifdef CONFIG_SND_HDA_POWER_SAVE
9112 #define alc882_loopbacks        alc880_loopbacks
9113 #endif
9114
9115 /* pcm configuration: identical with ALC880 */
9116 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9117 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9118 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9119 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9120
9121 static hda_nid_t alc883_slave_dig_outs[] = {
9122         ALC1200_DIGOUT_NID, 0,
9123 };
9124
9125 static hda_nid_t alc1200_slave_dig_outs[] = {
9126         ALC883_DIGOUT_NID, 0,
9127 };
9128
9129 /*
9130  * configuration and preset
9131  */
9132 static const char *alc882_models[ALC882_MODEL_LAST] = {
9133         [ALC882_3ST_DIG]        = "3stack-dig",
9134         [ALC882_6ST_DIG]        = "6stack-dig",
9135         [ALC882_ARIMA]          = "arima",
9136         [ALC882_W2JC]           = "w2jc",
9137         [ALC882_TARGA]          = "targa",
9138         [ALC882_ASUS_A7J]       = "asus-a7j",
9139         [ALC882_ASUS_A7M]       = "asus-a7m",
9140         [ALC885_MACPRO]         = "macpro",
9141         [ALC885_MB5]            = "mb5",
9142         [ALC885_MACMINI3]       = "macmini3",
9143         [ALC885_MBA21]          = "mba21",
9144         [ALC885_MBP3]           = "mbp3",
9145         [ALC885_IMAC24]         = "imac24",
9146         [ALC885_IMAC91]         = "imac91",
9147         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9148         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9149         [ALC883_3ST_6ch]        = "3stack-6ch",
9150         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9151         [ALC883_TARGA_DIG]      = "targa-dig",
9152         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9153         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9154         [ALC883_ACER]           = "acer",
9155         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9156         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9157         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9158         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9159         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9160         [ALC883_MEDION]         = "medion",
9161         [ALC883_MEDION_MD2]     = "medion-md2",
9162         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9163         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9164         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9165         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9166         [ALC888_LENOVO_SKY] = "lenovo-sky",
9167         [ALC883_HAIER_W66]      = "haier-w66",
9168         [ALC888_3ST_HP]         = "3stack-hp",
9169         [ALC888_6ST_DELL]       = "6stack-dell",
9170         [ALC883_MITAC]          = "mitac",
9171         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9172         [ALC883_CLEVO_M720]     = "clevo-m720",
9173         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9174         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9175         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9176         [ALC889A_INTEL]         = "intel-alc889a",
9177         [ALC889_INTEL]          = "intel-x58",
9178         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9179         [ALC889A_MB31]          = "mb31",
9180         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9181         [ALC882_AUTO]           = "auto",
9182 };
9183
9184 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9185         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9186
9187         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9188         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9189         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9190         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9191         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9192         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9193         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9194                 ALC888_ACER_ASPIRE_4930G),
9195         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9196                 ALC888_ACER_ASPIRE_4930G),
9197         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9198                 ALC888_ACER_ASPIRE_8930G),
9199         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9200                 ALC888_ACER_ASPIRE_8930G),
9201         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9202         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9203         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9204                 ALC888_ACER_ASPIRE_6530G),
9205         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9206                 ALC888_ACER_ASPIRE_6530G),
9207         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9208                 ALC888_ACER_ASPIRE_7730G),
9209         /* default Acer -- disabled as it causes more problems.
9210          *    model=auto should work fine now
9211          */
9212         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9213
9214         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9215
9216         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9217         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9218         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9219         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9220         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9221         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9222
9223         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9224         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9225         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9226         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9227         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9228         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9229         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9230         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9231         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9232         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9233         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9234
9235         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9236         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9237         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9238         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9239         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9240         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9241         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9242         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9243         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9244
9245         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9246         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9247         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9248         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9249         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9250         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9251         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9252         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9253         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9254         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9255         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9256         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9257         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9258         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9259         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9260         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9261         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9262         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9263         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9264         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9265         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9266         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9267         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9268         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9269         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9270         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9271         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9272         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9273         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9274         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9275         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9276
9277         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9278         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9279         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9280         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9281         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9282         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9283         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9284         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9285         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9286                       ALC883_FUJITSU_PI2515),
9287         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9288                 ALC888_FUJITSU_XA3530),
9289         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9290         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9291         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9292         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9293         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9294         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9295         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9296         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9297         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9298
9299         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9300         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9301         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9302         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9303         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9304         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9305         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9306
9307         {}
9308 };
9309
9310 /* codec SSID table for Intel Mac */
9311 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9312         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9313         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9314         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9315         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9316         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9317         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9318         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9319         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9320         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9321         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9322         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9323         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9324         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9325          * so apparently no perfect solution yet
9326          */
9327         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9328         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9329         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9330         {} /* terminator */
9331 };
9332
9333 static struct alc_config_preset alc882_presets[] = {
9334         [ALC882_3ST_DIG] = {
9335                 .mixers = { alc882_base_mixer },
9336                 .init_verbs = { alc882_base_init_verbs,
9337                                 alc882_adc1_init_verbs },
9338                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9339                 .dac_nids = alc882_dac_nids,
9340                 .dig_out_nid = ALC882_DIGOUT_NID,
9341                 .dig_in_nid = ALC882_DIGIN_NID,
9342                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9343                 .channel_mode = alc882_ch_modes,
9344                 .need_dac_fix = 1,
9345                 .input_mux = &alc882_capture_source,
9346         },
9347         [ALC882_6ST_DIG] = {
9348                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9349                 .init_verbs = { alc882_base_init_verbs,
9350                                 alc882_adc1_init_verbs },
9351                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9352                 .dac_nids = alc882_dac_nids,
9353                 .dig_out_nid = ALC882_DIGOUT_NID,
9354                 .dig_in_nid = ALC882_DIGIN_NID,
9355                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9356                 .channel_mode = alc882_sixstack_modes,
9357                 .input_mux = &alc882_capture_source,
9358         },
9359         [ALC882_ARIMA] = {
9360                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9361                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9362                                 alc882_eapd_verbs },
9363                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9364                 .dac_nids = alc882_dac_nids,
9365                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9366                 .channel_mode = alc882_sixstack_modes,
9367                 .input_mux = &alc882_capture_source,
9368         },
9369         [ALC882_W2JC] = {
9370                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9371                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9372                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9373                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9374                 .dac_nids = alc882_dac_nids,
9375                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9376                 .channel_mode = alc880_threestack_modes,
9377                 .need_dac_fix = 1,
9378                 .input_mux = &alc882_capture_source,
9379                 .dig_out_nid = ALC882_DIGOUT_NID,
9380         },
9381            [ALC885_MBA21] = {
9382                         .mixers = { alc885_mba21_mixer },
9383                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9384                         .num_dacs = 2,
9385                         .dac_nids = alc882_dac_nids,
9386                         .channel_mode = alc885_mba21_ch_modes,
9387                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9388                         .input_mux = &alc882_capture_source,
9389                         .unsol_event = alc_automute_amp_unsol_event,
9390                         .setup = alc885_mba21_setup,
9391                         .init_hook = alc_automute_amp,
9392        },
9393         [ALC885_MBP3] = {
9394                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9395                 .init_verbs = { alc885_mbp3_init_verbs,
9396                                 alc880_gpio1_init_verbs },
9397                 .num_dacs = 2,
9398                 .dac_nids = alc882_dac_nids,
9399                 .hp_nid = 0x04,
9400                 .channel_mode = alc885_mbp_4ch_modes,
9401                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9402                 .input_mux = &alc882_capture_source,
9403                 .dig_out_nid = ALC882_DIGOUT_NID,
9404                 .dig_in_nid = ALC882_DIGIN_NID,
9405                 .unsol_event = alc_automute_amp_unsol_event,
9406                 .setup = alc885_mbp3_setup,
9407                 .init_hook = alc_automute_amp,
9408         },
9409         [ALC885_MB5] = {
9410                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9411                 .init_verbs = { alc885_mb5_init_verbs,
9412                                 alc880_gpio1_init_verbs },
9413                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9414                 .dac_nids = alc882_dac_nids,
9415                 .channel_mode = alc885_mb5_6ch_modes,
9416                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9417                 .input_mux = &mb5_capture_source,
9418                 .dig_out_nid = ALC882_DIGOUT_NID,
9419                 .dig_in_nid = ALC882_DIGIN_NID,
9420                 .unsol_event = alc_automute_amp_unsol_event,
9421                 .setup = alc885_mb5_setup,
9422                 .init_hook = alc_automute_amp,
9423         },
9424         [ALC885_MACMINI3] = {
9425                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9426                 .init_verbs = { alc885_macmini3_init_verbs,
9427                                 alc880_gpio1_init_verbs },
9428                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9429                 .dac_nids = alc882_dac_nids,
9430                 .channel_mode = alc885_macmini3_6ch_modes,
9431                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9432                 .input_mux = &macmini3_capture_source,
9433                 .dig_out_nid = ALC882_DIGOUT_NID,
9434                 .dig_in_nid = ALC882_DIGIN_NID,
9435                 .unsol_event = alc_automute_amp_unsol_event,
9436                 .setup = alc885_macmini3_setup,
9437                 .init_hook = alc_automute_amp,
9438         },
9439         [ALC885_MACPRO] = {
9440                 .mixers = { alc882_macpro_mixer },
9441                 .init_verbs = { alc882_macpro_init_verbs },
9442                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9443                 .dac_nids = alc882_dac_nids,
9444                 .dig_out_nid = ALC882_DIGOUT_NID,
9445                 .dig_in_nid = ALC882_DIGIN_NID,
9446                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9447                 .channel_mode = alc882_ch_modes,
9448                 .input_mux = &alc882_capture_source,
9449                 .init_hook = alc885_macpro_init_hook,
9450         },
9451         [ALC885_IMAC24] = {
9452                 .mixers = { alc885_imac24_mixer },
9453                 .init_verbs = { alc885_imac24_init_verbs },
9454                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9455                 .dac_nids = alc882_dac_nids,
9456                 .dig_out_nid = ALC882_DIGOUT_NID,
9457                 .dig_in_nid = ALC882_DIGIN_NID,
9458                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9459                 .channel_mode = alc882_ch_modes,
9460                 .input_mux = &alc882_capture_source,
9461                 .unsol_event = alc_automute_amp_unsol_event,
9462                 .setup = alc885_imac24_setup,
9463                 .init_hook = alc885_imac24_init_hook,
9464         },
9465         [ALC885_IMAC91] = {
9466                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9467                 .init_verbs = { alc885_imac91_init_verbs,
9468                                 alc880_gpio1_init_verbs },
9469                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9470                 .dac_nids = alc882_dac_nids,
9471                 .channel_mode = alc885_mbp_4ch_modes,
9472                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9473                 .input_mux = &alc882_capture_source,
9474                 .dig_out_nid = ALC882_DIGOUT_NID,
9475                 .dig_in_nid = ALC882_DIGIN_NID,
9476                 .unsol_event = alc_automute_amp_unsol_event,
9477                 .setup = alc885_imac91_setup,
9478                 .init_hook = alc_automute_amp,
9479         },
9480         [ALC882_TARGA] = {
9481                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9482                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9483                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9484                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9485                 .dac_nids = alc882_dac_nids,
9486                 .dig_out_nid = ALC882_DIGOUT_NID,
9487                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9488                 .adc_nids = alc882_adc_nids,
9489                 .capsrc_nids = alc882_capsrc_nids,
9490                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9491                 .channel_mode = alc882_3ST_6ch_modes,
9492                 .need_dac_fix = 1,
9493                 .input_mux = &alc882_capture_source,
9494                 .unsol_event = alc882_targa_unsol_event,
9495                 .setup = alc882_targa_setup,
9496                 .init_hook = alc882_targa_automute,
9497         },
9498         [ALC882_ASUS_A7J] = {
9499                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9500                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9501                                 alc882_asus_a7j_verbs},
9502                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9503                 .dac_nids = alc882_dac_nids,
9504                 .dig_out_nid = ALC882_DIGOUT_NID,
9505                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9506                 .adc_nids = alc882_adc_nids,
9507                 .capsrc_nids = alc882_capsrc_nids,
9508                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9509                 .channel_mode = alc882_3ST_6ch_modes,
9510                 .need_dac_fix = 1,
9511                 .input_mux = &alc882_capture_source,
9512         },
9513         [ALC882_ASUS_A7M] = {
9514                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9515                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9516                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9517                                 alc882_asus_a7m_verbs },
9518                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9519                 .dac_nids = alc882_dac_nids,
9520                 .dig_out_nid = ALC882_DIGOUT_NID,
9521                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9522                 .channel_mode = alc880_threestack_modes,
9523                 .need_dac_fix = 1,
9524                 .input_mux = &alc882_capture_source,
9525         },
9526         [ALC883_3ST_2ch_DIG] = {
9527                 .mixers = { alc883_3ST_2ch_mixer },
9528                 .init_verbs = { alc883_init_verbs },
9529                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9530                 .dac_nids = alc883_dac_nids,
9531                 .dig_out_nid = ALC883_DIGOUT_NID,
9532                 .dig_in_nid = ALC883_DIGIN_NID,
9533                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9534                 .channel_mode = alc883_3ST_2ch_modes,
9535                 .input_mux = &alc883_capture_source,
9536         },
9537         [ALC883_3ST_6ch_DIG] = {
9538                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9539                 .init_verbs = { alc883_init_verbs },
9540                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9541                 .dac_nids = alc883_dac_nids,
9542                 .dig_out_nid = ALC883_DIGOUT_NID,
9543                 .dig_in_nid = ALC883_DIGIN_NID,
9544                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9545                 .channel_mode = alc883_3ST_6ch_modes,
9546                 .need_dac_fix = 1,
9547                 .input_mux = &alc883_capture_source,
9548         },
9549         [ALC883_3ST_6ch] = {
9550                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9551                 .init_verbs = { alc883_init_verbs },
9552                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9553                 .dac_nids = alc883_dac_nids,
9554                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9555                 .channel_mode = alc883_3ST_6ch_modes,
9556                 .need_dac_fix = 1,
9557                 .input_mux = &alc883_capture_source,
9558         },
9559         [ALC883_3ST_6ch_INTEL] = {
9560                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9561                 .init_verbs = { alc883_init_verbs },
9562                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9563                 .dac_nids = alc883_dac_nids,
9564                 .dig_out_nid = ALC883_DIGOUT_NID,
9565                 .dig_in_nid = ALC883_DIGIN_NID,
9566                 .slave_dig_outs = alc883_slave_dig_outs,
9567                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9568                 .channel_mode = alc883_3ST_6ch_intel_modes,
9569                 .need_dac_fix = 1,
9570                 .input_mux = &alc883_3stack_6ch_intel,
9571         },
9572         [ALC889A_INTEL] = {
9573                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9574                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9575                                 alc_hp15_unsol_verbs },
9576                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9577                 .dac_nids = alc883_dac_nids,
9578                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9579                 .adc_nids = alc889_adc_nids,
9580                 .dig_out_nid = ALC883_DIGOUT_NID,
9581                 .dig_in_nid = ALC883_DIGIN_NID,
9582                 .slave_dig_outs = alc883_slave_dig_outs,
9583                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9584                 .channel_mode = alc889_8ch_intel_modes,
9585                 .capsrc_nids = alc889_capsrc_nids,
9586                 .input_mux = &alc889_capture_source,
9587                 .setup = alc889_automute_setup,
9588                 .init_hook = alc_automute_amp,
9589                 .unsol_event = alc_automute_amp_unsol_event,
9590                 .need_dac_fix = 1,
9591         },
9592         [ALC889_INTEL] = {
9593                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9594                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9595                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9596                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9597                 .dac_nids = alc883_dac_nids,
9598                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9599                 .adc_nids = alc889_adc_nids,
9600                 .dig_out_nid = ALC883_DIGOUT_NID,
9601                 .dig_in_nid = ALC883_DIGIN_NID,
9602                 .slave_dig_outs = alc883_slave_dig_outs,
9603                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9604                 .channel_mode = alc889_8ch_intel_modes,
9605                 .capsrc_nids = alc889_capsrc_nids,
9606                 .input_mux = &alc889_capture_source,
9607                 .setup = alc889_automute_setup,
9608                 .init_hook = alc889_intel_init_hook,
9609                 .unsol_event = alc_automute_amp_unsol_event,
9610                 .need_dac_fix = 1,
9611         },
9612         [ALC883_6ST_DIG] = {
9613                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9614                 .init_verbs = { alc883_init_verbs },
9615                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9616                 .dac_nids = alc883_dac_nids,
9617                 .dig_out_nid = ALC883_DIGOUT_NID,
9618                 .dig_in_nid = ALC883_DIGIN_NID,
9619                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9620                 .channel_mode = alc883_sixstack_modes,
9621                 .input_mux = &alc883_capture_source,
9622         },
9623         [ALC883_TARGA_DIG] = {
9624                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9625                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9626                                 alc883_targa_verbs},
9627                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9628                 .dac_nids = alc883_dac_nids,
9629                 .dig_out_nid = ALC883_DIGOUT_NID,
9630                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9631                 .channel_mode = alc883_3ST_6ch_modes,
9632                 .need_dac_fix = 1,
9633                 .input_mux = &alc883_capture_source,
9634                 .unsol_event = alc883_targa_unsol_event,
9635                 .setup = alc882_targa_setup,
9636                 .init_hook = alc882_targa_automute,
9637         },
9638         [ALC883_TARGA_2ch_DIG] = {
9639                 .mixers = { alc883_targa_2ch_mixer},
9640                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9641                                 alc883_targa_verbs},
9642                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9643                 .dac_nids = alc883_dac_nids,
9644                 .adc_nids = alc883_adc_nids_alt,
9645                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9646                 .capsrc_nids = alc883_capsrc_nids,
9647                 .dig_out_nid = ALC883_DIGOUT_NID,
9648                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9649                 .channel_mode = alc883_3ST_2ch_modes,
9650                 .input_mux = &alc883_capture_source,
9651                 .unsol_event = alc883_targa_unsol_event,
9652                 .setup = alc882_targa_setup,
9653                 .init_hook = alc882_targa_automute,
9654         },
9655         [ALC883_TARGA_8ch_DIG] = {
9656                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9657                             alc883_chmode_mixer },
9658                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9659                                 alc883_targa_verbs },
9660                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9661                 .dac_nids = alc883_dac_nids,
9662                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9663                 .adc_nids = alc883_adc_nids_rev,
9664                 .capsrc_nids = alc883_capsrc_nids_rev,
9665                 .dig_out_nid = ALC883_DIGOUT_NID,
9666                 .dig_in_nid = ALC883_DIGIN_NID,
9667                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9668                 .channel_mode = alc883_4ST_8ch_modes,
9669                 .need_dac_fix = 1,
9670                 .input_mux = &alc883_capture_source,
9671                 .unsol_event = alc883_targa_unsol_event,
9672                 .setup = alc882_targa_setup,
9673                 .init_hook = alc882_targa_automute,
9674         },
9675         [ALC883_ACER] = {
9676                 .mixers = { alc883_base_mixer },
9677                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9678                  * and the headphone jack.  Turn this on and rely on the
9679                  * standard mute methods whenever the user wants to turn
9680                  * these outputs off.
9681                  */
9682                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9683                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9684                 .dac_nids = alc883_dac_nids,
9685                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9686                 .channel_mode = alc883_3ST_2ch_modes,
9687                 .input_mux = &alc883_capture_source,
9688         },
9689         [ALC883_ACER_ASPIRE] = {
9690                 .mixers = { alc883_acer_aspire_mixer },
9691                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9692                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9693                 .dac_nids = alc883_dac_nids,
9694                 .dig_out_nid = ALC883_DIGOUT_NID,
9695                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9696                 .channel_mode = alc883_3ST_2ch_modes,
9697                 .input_mux = &alc883_capture_source,
9698                 .unsol_event = alc_automute_amp_unsol_event,
9699                 .setup = alc883_acer_aspire_setup,
9700                 .init_hook = alc_automute_amp,
9701         },
9702         [ALC888_ACER_ASPIRE_4930G] = {
9703                 .mixers = { alc888_base_mixer,
9704                                 alc883_chmode_mixer },
9705                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9706                                 alc888_acer_aspire_4930g_verbs },
9707                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9708                 .dac_nids = alc883_dac_nids,
9709                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9710                 .adc_nids = alc883_adc_nids_rev,
9711                 .capsrc_nids = alc883_capsrc_nids_rev,
9712                 .dig_out_nid = ALC883_DIGOUT_NID,
9713                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9714                 .channel_mode = alc883_3ST_6ch_modes,
9715                 .need_dac_fix = 1,
9716                 .const_channel_count = 6,
9717                 .num_mux_defs =
9718                         ARRAY_SIZE(alc888_2_capture_sources),
9719                 .input_mux = alc888_2_capture_sources,
9720                 .unsol_event = alc_automute_amp_unsol_event,
9721                 .setup = alc888_acer_aspire_4930g_setup,
9722                 .init_hook = alc_automute_amp,
9723         },
9724         [ALC888_ACER_ASPIRE_6530G] = {
9725                 .mixers = { alc888_acer_aspire_6530_mixer },
9726                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9727                                 alc888_acer_aspire_6530g_verbs },
9728                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9729                 .dac_nids = alc883_dac_nids,
9730                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9731                 .adc_nids = alc883_adc_nids_rev,
9732                 .capsrc_nids = alc883_capsrc_nids_rev,
9733                 .dig_out_nid = ALC883_DIGOUT_NID,
9734                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9735                 .channel_mode = alc883_3ST_2ch_modes,
9736                 .num_mux_defs =
9737                         ARRAY_SIZE(alc888_2_capture_sources),
9738                 .input_mux = alc888_acer_aspire_6530_sources,
9739                 .unsol_event = alc_automute_amp_unsol_event,
9740                 .setup = alc888_acer_aspire_6530g_setup,
9741                 .init_hook = alc_automute_amp,
9742         },
9743         [ALC888_ACER_ASPIRE_8930G] = {
9744                 .mixers = { alc889_acer_aspire_8930g_mixer,
9745                                 alc883_chmode_mixer },
9746                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9747                                 alc889_acer_aspire_8930g_verbs,
9748                                 alc889_eapd_verbs},
9749                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9750                 .dac_nids = alc883_dac_nids,
9751                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9752                 .adc_nids = alc889_adc_nids,
9753                 .capsrc_nids = alc889_capsrc_nids,
9754                 .dig_out_nid = ALC883_DIGOUT_NID,
9755                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9756                 .channel_mode = alc883_3ST_6ch_modes,
9757                 .need_dac_fix = 1,
9758                 .const_channel_count = 6,
9759                 .num_mux_defs =
9760                         ARRAY_SIZE(alc889_capture_sources),
9761                 .input_mux = alc889_capture_sources,
9762                 .unsol_event = alc_automute_amp_unsol_event,
9763                 .setup = alc889_acer_aspire_8930g_setup,
9764                 .init_hook = alc_automute_amp,
9765 #ifdef CONFIG_SND_HDA_POWER_SAVE
9766                 .power_hook = alc_power_eapd,
9767 #endif
9768         },
9769         [ALC888_ACER_ASPIRE_7730G] = {
9770                 .mixers = { alc883_3ST_6ch_mixer,
9771                                 alc883_chmode_mixer },
9772                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9773                                 alc888_acer_aspire_7730G_verbs },
9774                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9775                 .dac_nids = alc883_dac_nids,
9776                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9777                 .adc_nids = alc883_adc_nids_rev,
9778                 .capsrc_nids = alc883_capsrc_nids_rev,
9779                 .dig_out_nid = ALC883_DIGOUT_NID,
9780                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9781                 .channel_mode = alc883_3ST_6ch_modes,
9782                 .need_dac_fix = 1,
9783                 .const_channel_count = 6,
9784                 .input_mux = &alc883_capture_source,
9785                 .unsol_event = alc_automute_amp_unsol_event,
9786                 .setup = alc888_acer_aspire_6530g_setup,
9787                 .init_hook = alc_automute_amp,
9788         },
9789         [ALC883_MEDION] = {
9790                 .mixers = { alc883_fivestack_mixer,
9791                             alc883_chmode_mixer },
9792                 .init_verbs = { alc883_init_verbs,
9793                                 alc883_medion_eapd_verbs },
9794                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9795                 .dac_nids = alc883_dac_nids,
9796                 .adc_nids = alc883_adc_nids_alt,
9797                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9798                 .capsrc_nids = alc883_capsrc_nids,
9799                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9800                 .channel_mode = alc883_sixstack_modes,
9801                 .input_mux = &alc883_capture_source,
9802         },
9803         [ALC883_MEDION_MD2] = {
9804                 .mixers = { alc883_medion_md2_mixer},
9805                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9806                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9807                 .dac_nids = alc883_dac_nids,
9808                 .dig_out_nid = ALC883_DIGOUT_NID,
9809                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9810                 .channel_mode = alc883_3ST_2ch_modes,
9811                 .input_mux = &alc883_capture_source,
9812                 .unsol_event = alc_automute_amp_unsol_event,
9813                 .setup = alc883_medion_md2_setup,
9814                 .init_hook = alc_automute_amp,
9815         },
9816         [ALC883_LAPTOP_EAPD] = {
9817                 .mixers = { alc883_base_mixer },
9818                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9819                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9820                 .dac_nids = alc883_dac_nids,
9821                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9822                 .channel_mode = alc883_3ST_2ch_modes,
9823                 .input_mux = &alc883_capture_source,
9824         },
9825         [ALC883_CLEVO_M540R] = {
9826                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9827                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9828                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9829                 .dac_nids = alc883_dac_nids,
9830                 .dig_out_nid = ALC883_DIGOUT_NID,
9831                 .dig_in_nid = ALC883_DIGIN_NID,
9832                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9833                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9834                 .need_dac_fix = 1,
9835                 .input_mux = &alc883_capture_source,
9836                 /* This machine has the hardware HP auto-muting, thus
9837                  * we need no software mute via unsol event
9838                  */
9839         },
9840         [ALC883_CLEVO_M720] = {
9841                 .mixers = { alc883_clevo_m720_mixer },
9842                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9843                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9844                 .dac_nids = alc883_dac_nids,
9845                 .dig_out_nid = ALC883_DIGOUT_NID,
9846                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9847                 .channel_mode = alc883_3ST_2ch_modes,
9848                 .input_mux = &alc883_capture_source,
9849                 .unsol_event = alc883_clevo_m720_unsol_event,
9850                 .setup = alc883_clevo_m720_setup,
9851                 .init_hook = alc883_clevo_m720_init_hook,
9852         },
9853         [ALC883_LENOVO_101E_2ch] = {
9854                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9855                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9856                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9857                 .dac_nids = alc883_dac_nids,
9858                 .adc_nids = alc883_adc_nids_alt,
9859                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9860                 .capsrc_nids = alc883_capsrc_nids,
9861                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9862                 .channel_mode = alc883_3ST_2ch_modes,
9863                 .input_mux = &alc883_lenovo_101e_capture_source,
9864                 .unsol_event = alc883_lenovo_101e_unsol_event,
9865                 .init_hook = alc883_lenovo_101e_all_automute,
9866         },
9867         [ALC883_LENOVO_NB0763] = {
9868                 .mixers = { alc883_lenovo_nb0763_mixer },
9869                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9870                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9871                 .dac_nids = alc883_dac_nids,
9872                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9873                 .channel_mode = alc883_3ST_2ch_modes,
9874                 .need_dac_fix = 1,
9875                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9876                 .unsol_event = alc_automute_amp_unsol_event,
9877                 .setup = alc883_medion_md2_setup,
9878                 .init_hook = alc_automute_amp,
9879         },
9880         [ALC888_LENOVO_MS7195_DIG] = {
9881                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9882                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9883                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9884                 .dac_nids = alc883_dac_nids,
9885                 .dig_out_nid = ALC883_DIGOUT_NID,
9886                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9887                 .channel_mode = alc883_3ST_6ch_modes,
9888                 .need_dac_fix = 1,
9889                 .input_mux = &alc883_capture_source,
9890                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9891                 .init_hook = alc888_lenovo_ms7195_front_automute,
9892         },
9893         [ALC883_HAIER_W66] = {
9894                 .mixers = { alc883_targa_2ch_mixer},
9895                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9896                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9897                 .dac_nids = alc883_dac_nids,
9898                 .dig_out_nid = ALC883_DIGOUT_NID,
9899                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9900                 .channel_mode = alc883_3ST_2ch_modes,
9901                 .input_mux = &alc883_capture_source,
9902                 .unsol_event = alc_automute_amp_unsol_event,
9903                 .setup = alc883_haier_w66_setup,
9904                 .init_hook = alc_automute_amp,
9905         },
9906         [ALC888_3ST_HP] = {
9907                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9908                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9909                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9910                 .dac_nids = alc883_dac_nids,
9911                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9912                 .channel_mode = alc888_3st_hp_modes,
9913                 .need_dac_fix = 1,
9914                 .input_mux = &alc883_capture_source,
9915                 .unsol_event = alc_automute_amp_unsol_event,
9916                 .setup = alc888_3st_hp_setup,
9917                 .init_hook = alc_automute_amp,
9918         },
9919         [ALC888_6ST_DELL] = {
9920                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9921                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9922                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9923                 .dac_nids = alc883_dac_nids,
9924                 .dig_out_nid = ALC883_DIGOUT_NID,
9925                 .dig_in_nid = ALC883_DIGIN_NID,
9926                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9927                 .channel_mode = alc883_sixstack_modes,
9928                 .input_mux = &alc883_capture_source,
9929                 .unsol_event = alc_automute_amp_unsol_event,
9930                 .setup = alc888_6st_dell_setup,
9931                 .init_hook = alc_automute_amp,
9932         },
9933         [ALC883_MITAC] = {
9934                 .mixers = { alc883_mitac_mixer },
9935                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9936                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9937                 .dac_nids = alc883_dac_nids,
9938                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9939                 .channel_mode = alc883_3ST_2ch_modes,
9940                 .input_mux = &alc883_capture_source,
9941                 .unsol_event = alc_automute_amp_unsol_event,
9942                 .setup = alc883_mitac_setup,
9943                 .init_hook = alc_automute_amp,
9944         },
9945         [ALC883_FUJITSU_PI2515] = {
9946                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9947                 .init_verbs = { alc883_init_verbs,
9948                                 alc883_2ch_fujitsu_pi2515_verbs},
9949                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9950                 .dac_nids = alc883_dac_nids,
9951                 .dig_out_nid = ALC883_DIGOUT_NID,
9952                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9953                 .channel_mode = alc883_3ST_2ch_modes,
9954                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9955                 .unsol_event = alc_automute_amp_unsol_event,
9956                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9957                 .init_hook = alc_automute_amp,
9958         },
9959         [ALC888_FUJITSU_XA3530] = {
9960                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9961                 .init_verbs = { alc883_init_verbs,
9962                         alc888_fujitsu_xa3530_verbs },
9963                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9964                 .dac_nids = alc883_dac_nids,
9965                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9966                 .adc_nids = alc883_adc_nids_rev,
9967                 .capsrc_nids = alc883_capsrc_nids_rev,
9968                 .dig_out_nid = ALC883_DIGOUT_NID,
9969                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9970                 .channel_mode = alc888_4ST_8ch_intel_modes,
9971                 .num_mux_defs =
9972                         ARRAY_SIZE(alc888_2_capture_sources),
9973                 .input_mux = alc888_2_capture_sources,
9974                 .unsol_event = alc_automute_amp_unsol_event,
9975                 .setup = alc888_fujitsu_xa3530_setup,
9976                 .init_hook = alc_automute_amp,
9977         },
9978         [ALC888_LENOVO_SKY] = {
9979                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9980                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9981                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9982                 .dac_nids = alc883_dac_nids,
9983                 .dig_out_nid = ALC883_DIGOUT_NID,
9984                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9985                 .channel_mode = alc883_sixstack_modes,
9986                 .need_dac_fix = 1,
9987                 .input_mux = &alc883_lenovo_sky_capture_source,
9988                 .unsol_event = alc_automute_amp_unsol_event,
9989                 .setup = alc888_lenovo_sky_setup,
9990                 .init_hook = alc_automute_amp,
9991         },
9992         [ALC888_ASUS_M90V] = {
9993                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9994                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9995                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9996                 .dac_nids = alc883_dac_nids,
9997                 .dig_out_nid = ALC883_DIGOUT_NID,
9998                 .dig_in_nid = ALC883_DIGIN_NID,
9999                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10000                 .channel_mode = alc883_3ST_6ch_modes,
10001                 .need_dac_fix = 1,
10002                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10003                 .unsol_event = alc_sku_unsol_event,
10004                 .setup = alc883_mode2_setup,
10005                 .init_hook = alc_inithook,
10006         },
10007         [ALC888_ASUS_EEE1601] = {
10008                 .mixers = { alc883_asus_eee1601_mixer },
10009                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10010                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10011                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10012                 .dac_nids = alc883_dac_nids,
10013                 .dig_out_nid = ALC883_DIGOUT_NID,
10014                 .dig_in_nid = ALC883_DIGIN_NID,
10015                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10016                 .channel_mode = alc883_3ST_2ch_modes,
10017                 .need_dac_fix = 1,
10018                 .input_mux = &alc883_asus_eee1601_capture_source,
10019                 .unsol_event = alc_sku_unsol_event,
10020                 .init_hook = alc883_eee1601_inithook,
10021         },
10022         [ALC1200_ASUS_P5Q] = {
10023                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10024                 .init_verbs = { alc883_init_verbs },
10025                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10026                 .dac_nids = alc883_dac_nids,
10027                 .dig_out_nid = ALC1200_DIGOUT_NID,
10028                 .dig_in_nid = ALC883_DIGIN_NID,
10029                 .slave_dig_outs = alc1200_slave_dig_outs,
10030                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10031                 .channel_mode = alc883_sixstack_modes,
10032                 .input_mux = &alc883_capture_source,
10033         },
10034         [ALC889A_MB31] = {
10035                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10036                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10037                         alc880_gpio1_init_verbs },
10038                 .adc_nids = alc883_adc_nids,
10039                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10040                 .capsrc_nids = alc883_capsrc_nids,
10041                 .dac_nids = alc883_dac_nids,
10042                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10043                 .channel_mode = alc889A_mb31_6ch_modes,
10044                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10045                 .input_mux = &alc889A_mb31_capture_source,
10046                 .dig_out_nid = ALC883_DIGOUT_NID,
10047                 .unsol_event = alc889A_mb31_unsol_event,
10048                 .init_hook = alc889A_mb31_automute,
10049         },
10050         [ALC883_SONY_VAIO_TT] = {
10051                 .mixers = { alc883_vaiott_mixer },
10052                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10053                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10054                 .dac_nids = alc883_dac_nids,
10055                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10056                 .channel_mode = alc883_3ST_2ch_modes,
10057                 .input_mux = &alc883_capture_source,
10058                 .unsol_event = alc_automute_amp_unsol_event,
10059                 .setup = alc883_vaiott_setup,
10060                 .init_hook = alc_automute_amp,
10061         },
10062 };
10063
10064
10065 /*
10066  * Pin config fixes
10067  */
10068 enum {
10069         PINFIX_ABIT_AW9D_MAX
10070 };
10071
10072 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
10073         { 0x15, 0x01080104 }, /* side */
10074         { 0x16, 0x01011012 }, /* rear */
10075         { 0x17, 0x01016011 }, /* clfe */
10076         { }
10077 };
10078
10079 static const struct alc_fixup alc882_fixups[] = {
10080         [PINFIX_ABIT_AW9D_MAX] = {
10081                 .pins = alc882_abit_aw9d_pinfix
10082         },
10083 };
10084
10085 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10086         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10087         {}
10088 };
10089
10090 /*
10091  * BIOS auto configuration
10092  */
10093 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10094                                                 const struct auto_pin_cfg *cfg)
10095 {
10096         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10097 }
10098
10099 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10100                                               hda_nid_t nid, int pin_type,
10101                                               int dac_idx)
10102 {
10103         /* set as output */
10104         struct alc_spec *spec = codec->spec;
10105         int idx;
10106
10107         alc_set_pin_output(codec, nid, pin_type);
10108         if (spec->multiout.dac_nids[dac_idx] == 0x25)
10109                 idx = 4;
10110         else {
10111                 if (spec->multiout.num_dacs >= dac_idx)
10112                         return;
10113                 idx = spec->multiout.dac_nids[dac_idx] - 2;
10114         }
10115         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10116
10117 }
10118
10119 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10120 {
10121         struct alc_spec *spec = codec->spec;
10122         int i;
10123
10124         for (i = 0; i <= HDA_SIDE; i++) {
10125                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10126                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10127                 if (nid)
10128                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10129                                                           i);
10130         }
10131 }
10132
10133 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10134 {
10135         struct alc_spec *spec = codec->spec;
10136         hda_nid_t pin;
10137
10138         pin = spec->autocfg.hp_pins[0];
10139         if (pin) /* connect to front */
10140                 /* use dac 0 */
10141                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
10142         pin = spec->autocfg.speaker_pins[0];
10143         if (pin)
10144                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
10145 }
10146
10147 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10148 {
10149         struct alc_spec *spec = codec->spec;
10150         int i;
10151
10152         for (i = 0; i < AUTO_PIN_LAST; i++) {
10153                 hda_nid_t nid = spec->autocfg.input_pins[i];
10154                 if (!nid)
10155                         continue;
10156                 alc_set_input_pin(codec, nid, i);
10157                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10158                         snd_hda_codec_write(codec, nid, 0,
10159                                             AC_VERB_SET_AMP_GAIN_MUTE,
10160                                             AMP_OUT_MUTE);
10161         }
10162 }
10163
10164 static void alc882_auto_init_input_src(struct hda_codec *codec)
10165 {
10166         struct alc_spec *spec = codec->spec;
10167         int c;
10168
10169         for (c = 0; c < spec->num_adc_nids; c++) {
10170                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10171                 hda_nid_t nid = spec->capsrc_nids[c];
10172                 unsigned int mux_idx;
10173                 const struct hda_input_mux *imux;
10174                 int conns, mute, idx, item;
10175
10176                 conns = snd_hda_get_connections(codec, nid, conn_list,
10177                                                 ARRAY_SIZE(conn_list));
10178                 if (conns < 0)
10179                         continue;
10180                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10181                 imux = &spec->input_mux[mux_idx];
10182                 if (!imux->num_items && mux_idx > 0)
10183                         imux = &spec->input_mux[0];
10184                 for (idx = 0; idx < conns; idx++) {
10185                         /* if the current connection is the selected one,
10186                          * unmute it as default - otherwise mute it
10187                          */
10188                         mute = AMP_IN_MUTE(idx);
10189                         for (item = 0; item < imux->num_items; item++) {
10190                                 if (imux->items[item].index == idx) {
10191                                         if (spec->cur_mux[c] == item)
10192                                                 mute = AMP_IN_UNMUTE(idx);
10193                                         break;
10194                                 }
10195                         }
10196                         /* check if we have a selector or mixer
10197                          * we could check for the widget type instead, but
10198                          * just check for Amp-In presence (in case of mixer
10199                          * without amp-in there is something wrong, this
10200                          * function shouldn't be used or capsrc nid is wrong)
10201                          */
10202                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10203                                 snd_hda_codec_write(codec, nid, 0,
10204                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10205                                                     mute);
10206                         else if (mute != AMP_IN_MUTE(idx))
10207                                 snd_hda_codec_write(codec, nid, 0,
10208                                                     AC_VERB_SET_CONNECT_SEL,
10209                                                     idx);
10210                 }
10211         }
10212 }
10213
10214 /* add mic boosts if needed */
10215 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10216 {
10217         struct alc_spec *spec = codec->spec;
10218         int err;
10219         hda_nid_t nid;
10220
10221         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
10222         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10223                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10224                                   "Mic Boost",
10225                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10226                 if (err < 0)
10227                         return err;
10228         }
10229         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
10230         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10231                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10232                                   "Front Mic Boost",
10233                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10234                 if (err < 0)
10235                         return err;
10236         }
10237         return 0;
10238 }
10239
10240 /* almost identical with ALC880 parser... */
10241 static int alc882_parse_auto_config(struct hda_codec *codec)
10242 {
10243         struct alc_spec *spec = codec->spec;
10244         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10245         int i, err;
10246
10247         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10248                                            alc882_ignore);
10249         if (err < 0)
10250                 return err;
10251         if (!spec->autocfg.line_outs)
10252                 return 0; /* can't find valid BIOS pin config */
10253
10254         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10255         if (err < 0)
10256                 return err;
10257         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10258         if (err < 0)
10259                 return err;
10260         err = alc880_auto_create_extra_out(spec,
10261                                            spec->autocfg.speaker_pins[0],
10262                                            "Speaker");
10263         if (err < 0)
10264                 return err;
10265         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10266                                            "Headphone");
10267         if (err < 0)
10268                 return err;
10269         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10270         if (err < 0)
10271                 return err;
10272
10273         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10274
10275         /* check multiple SPDIF-out (for recent codecs) */
10276         for (i = 0; i < spec->autocfg.dig_outs; i++) {
10277                 hda_nid_t dig_nid;
10278                 err = snd_hda_get_connections(codec,
10279                                               spec->autocfg.dig_out_pins[i],
10280                                               &dig_nid, 1);
10281                 if (err < 0)
10282                         continue;
10283                 if (!i)
10284                         spec->multiout.dig_out_nid = dig_nid;
10285                 else {
10286                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
10287                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
10288                                 break;
10289                         spec->slave_dig_outs[i - 1] = dig_nid;
10290                 }
10291         }
10292         if (spec->autocfg.dig_in_pin)
10293                 spec->dig_in_nid = ALC880_DIGIN_NID;
10294
10295         if (spec->kctls.list)
10296                 add_mixer(spec, spec->kctls.list);
10297
10298         add_verb(spec, alc883_auto_init_verbs);
10299         /* if ADC 0x07 is available, initialize it, too */
10300         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10301                 add_verb(spec, alc882_adc1_init_verbs);
10302
10303         spec->num_mux_defs = 1;
10304         spec->input_mux = &spec->private_imux[0];
10305
10306         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10307
10308         err = alc_auto_add_mic_boost(codec);
10309         if (err < 0)
10310                 return err;
10311
10312         return 1; /* config found */
10313 }
10314
10315 /* additional initialization for auto-configuration model */
10316 static void alc882_auto_init(struct hda_codec *codec)
10317 {
10318         struct alc_spec *spec = codec->spec;
10319         alc882_auto_init_multi_out(codec);
10320         alc882_auto_init_hp_out(codec);
10321         alc882_auto_init_analog_input(codec);
10322         alc882_auto_init_input_src(codec);
10323         if (spec->unsol_event)
10324                 alc_inithook(codec);
10325 }
10326
10327 static int patch_alc882(struct hda_codec *codec)
10328 {
10329         struct alc_spec *spec;
10330         int err, board_config;
10331
10332         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10333         if (spec == NULL)
10334                 return -ENOMEM;
10335
10336         codec->spec = spec;
10337
10338         switch (codec->vendor_id) {
10339         case 0x10ec0882:
10340         case 0x10ec0885:
10341                 break;
10342         default:
10343                 /* ALC883 and variants */
10344                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10345                 break;
10346         }
10347
10348         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10349                                                   alc882_models,
10350                                                   alc882_cfg_tbl);
10351
10352         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10353                 board_config = snd_hda_check_board_codec_sid_config(codec,
10354                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10355
10356         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10357                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10358                        codec->chip_name);
10359                 board_config = ALC882_AUTO;
10360         }
10361
10362         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10363
10364         if (board_config == ALC882_AUTO) {
10365                 /* automatic parse from the BIOS config */
10366                 err = alc882_parse_auto_config(codec);
10367                 if (err < 0) {
10368                         alc_free(codec);
10369                         return err;
10370                 } else if (!err) {
10371                         printk(KERN_INFO
10372                                "hda_codec: Cannot set up configuration "
10373                                "from BIOS.  Using base mode...\n");
10374                         board_config = ALC882_3ST_DIG;
10375                 }
10376         }
10377
10378         err = snd_hda_attach_beep_device(codec, 0x1);
10379         if (err < 0) {
10380                 alc_free(codec);
10381                 return err;
10382         }
10383
10384         if (board_config != ALC882_AUTO)
10385                 setup_preset(codec, &alc882_presets[board_config]);
10386
10387         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10388         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10389         /* FIXME: setup DAC5 */
10390         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10391         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10392
10393         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10394         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10395
10396         if (codec->vendor_id == 0x10ec0888)
10397                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10398
10399         if (!spec->adc_nids && spec->input_mux) {
10400                 int i, j;
10401                 spec->num_adc_nids = 0;
10402                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10403                         const struct hda_input_mux *imux = spec->input_mux;
10404                         hda_nid_t cap;
10405                         hda_nid_t items[16];
10406                         hda_nid_t nid = alc882_adc_nids[i];
10407                         unsigned int wcap = get_wcaps(codec, nid);
10408                         /* get type */
10409                         wcap = get_wcaps_type(wcap);
10410                         if (wcap != AC_WID_AUD_IN)
10411                                 continue;
10412                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10413                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10414                         if (err < 0)
10415                                 continue;
10416                         err = snd_hda_get_connections(codec, cap, items,
10417                                                       ARRAY_SIZE(items));
10418                         if (err < 0)
10419                                 continue;
10420                         for (j = 0; j < imux->num_items; j++)
10421                                 if (imux->items[j].index >= err)
10422                                         break;
10423                         if (j < imux->num_items)
10424                                 continue;
10425                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10426                         spec->num_adc_nids++;
10427                 }
10428                 spec->adc_nids = spec->private_adc_nids;
10429                 spec->capsrc_nids = spec->private_capsrc_nids;
10430         }
10431
10432         set_capture_mixer(codec);
10433         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10434
10435         spec->vmaster_nid = 0x0c;
10436
10437         codec->patch_ops = alc_patch_ops;
10438         if (board_config == ALC882_AUTO)
10439                 spec->init_hook = alc882_auto_init;
10440 #ifdef CONFIG_SND_HDA_POWER_SAVE
10441         if (!spec->loopback.amplist)
10442                 spec->loopback.amplist = alc882_loopbacks;
10443 #endif
10444
10445         return 0;
10446 }
10447
10448
10449 /*
10450  * ALC262 support
10451  */
10452
10453 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10454 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10455
10456 #define alc262_dac_nids         alc260_dac_nids
10457 #define alc262_adc_nids         alc882_adc_nids
10458 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10459 #define alc262_capsrc_nids      alc882_capsrc_nids
10460 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10461
10462 #define alc262_modes            alc260_modes
10463 #define alc262_capture_source   alc882_capture_source
10464
10465 static hda_nid_t alc262_dmic_adc_nids[1] = {
10466         /* ADC0 */
10467         0x09
10468 };
10469
10470 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10471
10472 static struct snd_kcontrol_new alc262_base_mixer[] = {
10473         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10474         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10475         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10476         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10477         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10478         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10479         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10480         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10481         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10482         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10483         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10484         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10485         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10486         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10487         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10488         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10489         { } /* end */
10490 };
10491
10492 /* update HP, line and mono-out pins according to the master switch */
10493 static void alc262_hp_master_update(struct hda_codec *codec)
10494 {
10495         struct alc_spec *spec = codec->spec;
10496         int val = spec->master_sw;
10497
10498         /* HP & line-out */
10499         snd_hda_codec_write_cache(codec, 0x1b, 0,
10500                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10501                                   val ? PIN_HP : 0);
10502         snd_hda_codec_write_cache(codec, 0x15, 0,
10503                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10504                                   val ? PIN_HP : 0);
10505         /* mono (speaker) depending on the HP jack sense */
10506         val = val && !spec->jack_present;
10507         snd_hda_codec_write_cache(codec, 0x16, 0,
10508                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10509                                   val ? PIN_OUT : 0);
10510 }
10511
10512 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10513 {
10514         struct alc_spec *spec = codec->spec;
10515
10516         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10517         alc262_hp_master_update(codec);
10518 }
10519
10520 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10521 {
10522         if ((res >> 26) != ALC880_HP_EVENT)
10523                 return;
10524         alc262_hp_bpc_automute(codec);
10525 }
10526
10527 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10528 {
10529         struct alc_spec *spec = codec->spec;
10530
10531         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10532         alc262_hp_master_update(codec);
10533 }
10534
10535 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10536                                            unsigned int res)
10537 {
10538         if ((res >> 26) != ALC880_HP_EVENT)
10539                 return;
10540         alc262_hp_wildwest_automute(codec);
10541 }
10542
10543 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10544
10545 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10546                                    struct snd_ctl_elem_value *ucontrol)
10547 {
10548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10549         struct alc_spec *spec = codec->spec;
10550         int val = !!*ucontrol->value.integer.value;
10551
10552         if (val == spec->master_sw)
10553                 return 0;
10554         spec->master_sw = val;
10555         alc262_hp_master_update(codec);
10556         return 1;
10557 }
10558
10559 #define ALC262_HP_MASTER_SWITCH                                 \
10560         {                                                       \
10561                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10562                 .name = "Master Playback Switch",               \
10563                 .info = snd_ctl_boolean_mono_info,              \
10564                 .get = alc262_hp_master_sw_get,                 \
10565                 .put = alc262_hp_master_sw_put,                 \
10566         }, \
10567         {                                                       \
10568                 .iface = NID_MAPPING,                           \
10569                 .name = "Master Playback Switch",               \
10570                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
10571         }
10572
10573
10574 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10575         ALC262_HP_MASTER_SWITCH,
10576         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10577         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10578         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10579         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10580                               HDA_OUTPUT),
10581         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10582                             HDA_OUTPUT),
10583         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10584         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10585         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10586         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10587         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10588         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10589         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10590         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10591         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10592         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10593         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10594         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10595         { } /* end */
10596 };
10597
10598 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10599         ALC262_HP_MASTER_SWITCH,
10600         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10601         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10602         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10603         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10604         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10605                               HDA_OUTPUT),
10606         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10607                             HDA_OUTPUT),
10608         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10609         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10610         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10611         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10612         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10613         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10614         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10615         { } /* end */
10616 };
10617
10618 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10619         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10620         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10621         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10622         { } /* end */
10623 };
10624
10625 /* mute/unmute internal speaker according to the hp jack and mute state */
10626 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10627 {
10628         struct alc_spec *spec = codec->spec;
10629
10630         spec->autocfg.hp_pins[0] = 0x15;
10631         spec->autocfg.speaker_pins[0] = 0x14;
10632 }
10633
10634 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10635         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10636         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10637         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10638         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10639         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10640         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10641         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10642         { } /* end */
10643 };
10644
10645 static struct hda_verb alc262_hp_t5735_verbs[] = {
10646         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10647         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10648
10649         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10650         { }
10651 };
10652
10653 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10654         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10655         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10656         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10657         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10658         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10659         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10660         { } /* end */
10661 };
10662
10663 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10664         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10665         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10666         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10667         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10668         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10669         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10671         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10673         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10674         {}
10675 };
10676
10677 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10678         .num_items = 1,
10679         .items = {
10680                 { "Line", 0x1 },
10681         },
10682 };
10683
10684 /* bind hp and internal speaker mute (with plug check) as master switch */
10685 static void alc262_hippo_master_update(struct hda_codec *codec)
10686 {
10687         struct alc_spec *spec = codec->spec;
10688         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10689         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10690         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10691         unsigned int mute;
10692
10693         /* HP */
10694         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10695         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10696                                  HDA_AMP_MUTE, mute);
10697         /* mute internal speaker per jack sense */
10698         if (spec->jack_present)
10699                 mute = HDA_AMP_MUTE;
10700         if (line_nid)
10701                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10702                                          HDA_AMP_MUTE, mute);
10703         if (speaker_nid && speaker_nid != line_nid)
10704                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10705                                          HDA_AMP_MUTE, mute);
10706 }
10707
10708 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10709
10710 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10711                                       struct snd_ctl_elem_value *ucontrol)
10712 {
10713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10714         struct alc_spec *spec = codec->spec;
10715         int val = !!*ucontrol->value.integer.value;
10716
10717         if (val == spec->master_sw)
10718                 return 0;
10719         spec->master_sw = val;
10720         alc262_hippo_master_update(codec);
10721         return 1;
10722 }
10723
10724 #define ALC262_HIPPO_MASTER_SWITCH                              \
10725         {                                                       \
10726                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10727                 .name = "Master Playback Switch",               \
10728                 .info = snd_ctl_boolean_mono_info,              \
10729                 .get = alc262_hippo_master_sw_get,              \
10730                 .put = alc262_hippo_master_sw_put,              \
10731         },                                                      \
10732         {                                                       \
10733                 .iface = NID_MAPPING,                           \
10734                 .name = "Master Playback Switch",               \
10735                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
10736                              (SUBDEV_SPEAKER(0) << 16), \
10737         }
10738
10739 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10740         ALC262_HIPPO_MASTER_SWITCH,
10741         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10742         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10743         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10744         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10745         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10748         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10749         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10750         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10751         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10752         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10753         { } /* end */
10754 };
10755
10756 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10757         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10758         ALC262_HIPPO_MASTER_SWITCH,
10759         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10760         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10761         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10762         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10763         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10764         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10765         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10766         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10767         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10768         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10769         { } /* end */
10770 };
10771
10772 /* mute/unmute internal speaker according to the hp jack and mute state */
10773 static void alc262_hippo_automute(struct hda_codec *codec)
10774 {
10775         struct alc_spec *spec = codec->spec;
10776         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10777
10778         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10779         alc262_hippo_master_update(codec);
10780 }
10781
10782 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10783 {
10784         if ((res >> 26) != ALC880_HP_EVENT)
10785                 return;
10786         alc262_hippo_automute(codec);
10787 }
10788
10789 static void alc262_hippo_setup(struct hda_codec *codec)
10790 {
10791         struct alc_spec *spec = codec->spec;
10792
10793         spec->autocfg.hp_pins[0] = 0x15;
10794         spec->autocfg.speaker_pins[0] = 0x14;
10795 }
10796
10797 static void alc262_hippo1_setup(struct hda_codec *codec)
10798 {
10799         struct alc_spec *spec = codec->spec;
10800
10801         spec->autocfg.hp_pins[0] = 0x1b;
10802         spec->autocfg.speaker_pins[0] = 0x14;
10803 }
10804
10805
10806 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10807         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10808         ALC262_HIPPO_MASTER_SWITCH,
10809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10810         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10811         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10812         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10813         { } /* end */
10814 };
10815
10816 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10817         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10818         ALC262_HIPPO_MASTER_SWITCH,
10819         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10822         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10823         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10824         { } /* end */
10825 };
10826
10827 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10828         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10829         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10830         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10831         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10832         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10833         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10834         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10835         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10836         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10837         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10838         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10839         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10840         { } /* end */
10841 };
10842
10843 static struct hda_verb alc262_tyan_verbs[] = {
10844         /* Headphone automute */
10845         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10846         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10847         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10848
10849         /* P11 AUX_IN, white 4-pin connector */
10850         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10851         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10852         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10853         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10854
10855         {}
10856 };
10857
10858 /* unsolicited event for HP jack sensing */
10859 static void alc262_tyan_setup(struct hda_codec *codec)
10860 {
10861         struct alc_spec *spec = codec->spec;
10862
10863         spec->autocfg.hp_pins[0] = 0x1b;
10864         spec->autocfg.speaker_pins[0] = 0x15;
10865 }
10866
10867
10868 #define alc262_capture_mixer            alc882_capture_mixer
10869 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10870
10871 /*
10872  * generic initialization of ADC, input mixers and output mixers
10873  */
10874 static struct hda_verb alc262_init_verbs[] = {
10875         /*
10876          * Unmute ADC0-2 and set the default input to mic-in
10877          */
10878         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10879         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10880         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10881         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10882         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10883         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10884
10885         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10886          * mixer widget
10887          * Note: PASD motherboards uses the Line In 2 as the input for
10888          * front panel mic (mic 2)
10889          */
10890         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10891         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10892         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10893         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10894         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10895         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10896
10897         /*
10898          * Set up output mixers (0x0c - 0x0e)
10899          */
10900         /* set vol=0 to output mixers */
10901         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10902         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10903         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10904         /* set up input amps for analog loopback */
10905         /* Amp Indices: DAC = 0, mixer = 1 */
10906         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10907         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10908         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10909         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10910         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10911         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10912
10913         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10914         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10915         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10916         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10917         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10918         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10919
10920         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10921         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10922         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10923         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10924         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10925
10926         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10927         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10928
10929         /* FIXME: use matrix-type input source selection */
10930         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10931         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10932         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10933         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10934         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10935         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10936         /* Input mixer2 */
10937         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10938         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10939         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10940         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10941         /* Input mixer3 */
10942         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10943         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10944         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10945         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10946
10947         { }
10948 };
10949
10950 static struct hda_verb alc262_eapd_verbs[] = {
10951         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10952         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10953         { }
10954 };
10955
10956 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10957         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10958         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10959         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10960
10961         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10962         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10963         {}
10964 };
10965
10966 static struct hda_verb alc262_sony_unsol_verbs[] = {
10967         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10968         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10969         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10970
10971         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10972         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10973         {}
10974 };
10975
10976 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10977         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10978         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10979         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10980         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10981         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10982         { } /* end */
10983 };
10984
10985 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10986         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10987         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10988         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10989         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10990         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10991         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10992         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10993         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10994         {}
10995 };
10996
10997 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10998 {
10999         struct alc_spec *spec = codec->spec;
11000
11001         spec->autocfg.hp_pins[0] = 0x15;
11002         spec->autocfg.speaker_pins[0] = 0x14;
11003         spec->ext_mic.pin = 0x18;
11004         spec->ext_mic.mux_idx = 0;
11005         spec->int_mic.pin = 0x12;
11006         spec->int_mic.mux_idx = 9;
11007         spec->auto_mic = 1;
11008 }
11009
11010 /*
11011  * nec model
11012  *  0x15 = headphone
11013  *  0x16 = internal speaker
11014  *  0x18 = external mic
11015  */
11016
11017 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11018         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11019         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11020
11021         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11022         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11023         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11024
11025         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11026         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11027         { } /* end */
11028 };
11029
11030 static struct hda_verb alc262_nec_verbs[] = {
11031         /* Unmute Speaker */
11032         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11033
11034         /* Headphone */
11035         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11036         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11037
11038         /* External mic to headphone */
11039         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11040         /* External mic to speaker */
11041         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11042         {}
11043 };
11044
11045 /*
11046  * fujitsu model
11047  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11048  *  0x1b = port replicator headphone out
11049  */
11050
11051 #define ALC_HP_EVENT    0x37
11052
11053 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11054         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11055         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11056         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11057         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11058         {}
11059 };
11060
11061 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11062         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11063         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11064         {}
11065 };
11066
11067 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11068         /* Front Mic pin: input vref at 50% */
11069         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11070         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11071         {}
11072 };
11073
11074 static struct hda_input_mux alc262_fujitsu_capture_source = {
11075         .num_items = 3,
11076         .items = {
11077                 { "Mic", 0x0 },
11078                 { "Int Mic", 0x1 },
11079                 { "CD", 0x4 },
11080         },
11081 };
11082
11083 static struct hda_input_mux alc262_HP_capture_source = {
11084         .num_items = 5,
11085         .items = {
11086                 { "Mic", 0x0 },
11087                 { "Front Mic", 0x1 },
11088                 { "Line", 0x2 },
11089                 { "CD", 0x4 },
11090                 { "AUX IN", 0x6 },
11091         },
11092 };
11093
11094 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11095         .num_items = 4,
11096         .items = {
11097                 { "Mic", 0x0 },
11098                 { "Front Mic", 0x2 },
11099                 { "Line", 0x1 },
11100                 { "CD", 0x4 },
11101         },
11102 };
11103
11104 /* mute/unmute internal speaker according to the hp jacks and mute state */
11105 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11106 {
11107         struct alc_spec *spec = codec->spec;
11108         unsigned int mute;
11109
11110         if (force || !spec->sense_updated) {
11111                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11112                                      snd_hda_jack_detect(codec, 0x1b);
11113                 spec->sense_updated = 1;
11114         }
11115         /* unmute internal speaker only if both HPs are unplugged and
11116          * master switch is on
11117          */
11118         if (spec->jack_present)
11119                 mute = HDA_AMP_MUTE;
11120         else
11121                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11122         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11123                                  HDA_AMP_MUTE, mute);
11124 }
11125
11126 /* unsolicited event for HP jack sensing */
11127 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11128                                        unsigned int res)
11129 {
11130         if ((res >> 26) != ALC_HP_EVENT)
11131                 return;
11132         alc262_fujitsu_automute(codec, 1);
11133 }
11134
11135 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11136 {
11137         alc262_fujitsu_automute(codec, 1);
11138 }
11139
11140 /* bind volumes of both NID 0x0c and 0x0d */
11141 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11142         .ops = &snd_hda_bind_vol,
11143         .values = {
11144                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11145                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11146                 0
11147         },
11148 };
11149
11150 /* mute/unmute internal speaker according to the hp jack and mute state */
11151 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11152 {
11153         struct alc_spec *spec = codec->spec;
11154         unsigned int mute;
11155
11156         if (force || !spec->sense_updated) {
11157                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11158                 spec->sense_updated = 1;
11159         }
11160         if (spec->jack_present) {
11161                 /* mute internal speaker */
11162                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11163                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11164                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11165                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11166         } else {
11167                 /* unmute internal speaker if necessary */
11168                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11169                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11170                                          HDA_AMP_MUTE, mute);
11171                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11172                                          HDA_AMP_MUTE, mute);
11173         }
11174 }
11175
11176 /* unsolicited event for HP jack sensing */
11177 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11178                                        unsigned int res)
11179 {
11180         if ((res >> 26) != ALC_HP_EVENT)
11181                 return;
11182         alc262_lenovo_3000_automute(codec, 1);
11183 }
11184
11185 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11186                                   int dir, int idx, long *valp)
11187 {
11188         int i, change = 0;
11189
11190         for (i = 0; i < 2; i++, valp++)
11191                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11192                                                    HDA_AMP_MUTE,
11193                                                    *valp ? 0 : HDA_AMP_MUTE);
11194         return change;
11195 }
11196
11197 /* bind hp and internal speaker mute (with plug check) */
11198 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11199                                          struct snd_ctl_elem_value *ucontrol)
11200 {
11201         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11202         long *valp = ucontrol->value.integer.value;
11203         int change;
11204
11205         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11206         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11207         if (change)
11208                 alc262_fujitsu_automute(codec, 0);
11209         return change;
11210 }
11211
11212 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11213         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11214         {
11215                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11216                 .name = "Master Playback Switch",
11217                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11218                 .info = snd_hda_mixer_amp_switch_info,
11219                 .get = snd_hda_mixer_amp_switch_get,
11220                 .put = alc262_fujitsu_master_sw_put,
11221                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11222         },
11223         {
11224                 .iface = NID_MAPPING,
11225                 .name = "Master Playback Switch",
11226                 .private_value = 0x1b,
11227         },
11228         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11229         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11230         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11231         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11232         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11233         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11234         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11235         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11236         { } /* end */
11237 };
11238
11239 /* bind hp and internal speaker mute (with plug check) */
11240 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11241                                          struct snd_ctl_elem_value *ucontrol)
11242 {
11243         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11244         long *valp = ucontrol->value.integer.value;
11245         int change;
11246
11247         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11248         if (change)
11249                 alc262_lenovo_3000_automute(codec, 0);
11250         return change;
11251 }
11252
11253 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11254         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11255         {
11256                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11257                 .name = "Master Playback Switch",
11258                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11259                 .info = snd_hda_mixer_amp_switch_info,
11260                 .get = snd_hda_mixer_amp_switch_get,
11261                 .put = alc262_lenovo_3000_master_sw_put,
11262                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11263         },
11264         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11265         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11266         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11267         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11268         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11269         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11270         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11271         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11272         { } /* end */
11273 };
11274
11275 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11276         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11277         ALC262_HIPPO_MASTER_SWITCH,
11278         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11279         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11280         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11281         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11282         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11283         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11284         { } /* end */
11285 };
11286
11287 /* additional init verbs for Benq laptops */
11288 static struct hda_verb alc262_EAPD_verbs[] = {
11289         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11290         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11291         {}
11292 };
11293
11294 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11295         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11296         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11297
11298         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11299         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11300         {}
11301 };
11302
11303 /* Samsung Q1 Ultra Vista model setup */
11304 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11305         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11306         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11307         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11308         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11309         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11310         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11311         { } /* end */
11312 };
11313
11314 static struct hda_verb alc262_ultra_verbs[] = {
11315         /* output mixer */
11316         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11317         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11318         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11319         /* speaker */
11320         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11321         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11322         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11323         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11324         /* HP */
11325         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11326         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11327         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11328         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11329         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11330         /* internal mic */
11331         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11332         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11333         /* ADC, choose mic */
11334         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11335         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11336         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11337         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11338         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11339         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11340         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11341         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11342         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11343         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11344         {}
11345 };
11346
11347 /* mute/unmute internal speaker according to the hp jack and mute state */
11348 static void alc262_ultra_automute(struct hda_codec *codec)
11349 {
11350         struct alc_spec *spec = codec->spec;
11351         unsigned int mute;
11352
11353         mute = 0;
11354         /* auto-mute only when HP is used as HP */
11355         if (!spec->cur_mux[0]) {
11356                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11357                 if (spec->jack_present)
11358                         mute = HDA_AMP_MUTE;
11359         }
11360         /* mute/unmute internal speaker */
11361         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11362                                  HDA_AMP_MUTE, mute);
11363         /* mute/unmute HP */
11364         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11365                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11366 }
11367
11368 /* unsolicited event for HP jack sensing */
11369 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11370                                        unsigned int res)
11371 {
11372         if ((res >> 26) != ALC880_HP_EVENT)
11373                 return;
11374         alc262_ultra_automute(codec);
11375 }
11376
11377 static struct hda_input_mux alc262_ultra_capture_source = {
11378         .num_items = 2,
11379         .items = {
11380                 { "Mic", 0x1 },
11381                 { "Headphone", 0x7 },
11382         },
11383 };
11384
11385 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11386                                      struct snd_ctl_elem_value *ucontrol)
11387 {
11388         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11389         struct alc_spec *spec = codec->spec;
11390         int ret;
11391
11392         ret = alc_mux_enum_put(kcontrol, ucontrol);
11393         if (!ret)
11394                 return 0;
11395         /* reprogram the HP pin as mic or HP according to the input source */
11396         snd_hda_codec_write_cache(codec, 0x15, 0,
11397                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11398                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11399         alc262_ultra_automute(codec); /* mute/unmute HP */
11400         return ret;
11401 }
11402
11403 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11404         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11405         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11406         {
11407                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11408                 .name = "Capture Source",
11409                 .info = alc_mux_enum_info,
11410                 .get = alc_mux_enum_get,
11411                 .put = alc262_ultra_mux_enum_put,
11412         },
11413         {
11414                 .iface = NID_MAPPING,
11415                 .name = "Capture Source",
11416                 .private_value = 0x15,
11417         },
11418         { } /* end */
11419 };
11420
11421 /* We use two mixers depending on the output pin; 0x16 is a mono output
11422  * and thus it's bound with a different mixer.
11423  * This function returns which mixer amp should be used.
11424  */
11425 static int alc262_check_volbit(hda_nid_t nid)
11426 {
11427         if (!nid)
11428                 return 0;
11429         else if (nid == 0x16)
11430                 return 2;
11431         else
11432                 return 1;
11433 }
11434
11435 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11436                                   const char *pfx, int *vbits)
11437 {
11438         unsigned long val;
11439         int vbit;
11440
11441         vbit = alc262_check_volbit(nid);
11442         if (!vbit)
11443                 return 0;
11444         if (*vbits & vbit) /* a volume control for this mixer already there */
11445                 return 0;
11446         *vbits |= vbit;
11447         if (vbit == 2)
11448                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11449         else
11450                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11451         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11452 }
11453
11454 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11455                                  const char *pfx)
11456 {
11457         unsigned long val;
11458
11459         if (!nid)
11460                 return 0;
11461         if (nid == 0x16)
11462                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11463         else
11464                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11465         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11466 }
11467
11468 /* add playback controls from the parsed DAC table */
11469 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11470                                              const struct auto_pin_cfg *cfg)
11471 {
11472         const char *pfx;
11473         int vbits;
11474         int err;
11475
11476         spec->multiout.num_dacs = 1;    /* only use one dac */
11477         spec->multiout.dac_nids = spec->private_dac_nids;
11478         spec->multiout.dac_nids[0] = 2;
11479
11480         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11481                 pfx = "Master";
11482         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11483                 pfx = "Speaker";
11484         else
11485                 pfx = "Front";
11486         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11487         if (err < 0)
11488                 return err;
11489         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11490         if (err < 0)
11491                 return err;
11492         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11493         if (err < 0)
11494                 return err;
11495
11496         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11497                 alc262_check_volbit(cfg->speaker_pins[0]) |
11498                 alc262_check_volbit(cfg->hp_pins[0]);
11499         if (vbits == 1 || vbits == 2)
11500                 pfx = "Master"; /* only one mixer is used */
11501         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11502                 pfx = "Speaker";
11503         else
11504                 pfx = "Front";
11505         vbits = 0;
11506         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11507         if (err < 0)
11508                 return err;
11509         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11510                                      &vbits);
11511         if (err < 0)
11512                 return err;
11513         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11514                                      &vbits);
11515         if (err < 0)
11516                 return err;
11517         return 0;
11518 }
11519
11520 #define alc262_auto_create_input_ctls \
11521         alc882_auto_create_input_ctls
11522
11523 /*
11524  * generic initialization of ADC, input mixers and output mixers
11525  */
11526 static struct hda_verb alc262_volume_init_verbs[] = {
11527         /*
11528          * Unmute ADC0-2 and set the default input to mic-in
11529          */
11530         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11531         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11532         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11533         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11534         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11535         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11536
11537         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11538          * mixer widget
11539          * Note: PASD motherboards uses the Line In 2 as the input for
11540          * front panel mic (mic 2)
11541          */
11542         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11543         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11544         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11545         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11546         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11547         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11548
11549         /*
11550          * Set up output mixers (0x0c - 0x0f)
11551          */
11552         /* set vol=0 to output mixers */
11553         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11554         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11555         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11556
11557         /* set up input amps for analog loopback */
11558         /* Amp Indices: DAC = 0, mixer = 1 */
11559         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11560         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11561         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11562         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11563         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11564         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11565
11566         /* FIXME: use matrix-type input source selection */
11567         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11568         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11569         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11570         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11571         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11572         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11573         /* Input mixer2 */
11574         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11575         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11576         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11577         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11578         /* Input mixer3 */
11579         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11580         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11581         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11582         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11583
11584         { }
11585 };
11586
11587 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11588         /*
11589          * Unmute ADC0-2 and set the default input to mic-in
11590          */
11591         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11592         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11593         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11594         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11595         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11596         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11597
11598         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11599          * mixer widget
11600          * Note: PASD motherboards uses the Line In 2 as the input for
11601          * front panel mic (mic 2)
11602          */
11603         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11604         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11605         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11606         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11607         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11608         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11609         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11610         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11611
11612         /*
11613          * Set up output mixers (0x0c - 0x0e)
11614          */
11615         /* set vol=0 to output mixers */
11616         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11617         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11618         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11619
11620         /* set up input amps for analog loopback */
11621         /* Amp Indices: DAC = 0, mixer = 1 */
11622         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11623         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11624         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11625         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11626         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11627         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11628
11629         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11630         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11631         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11632
11633         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11634         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11635
11636         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11637         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11638
11639         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11640         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11641         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11642         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11643         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11644
11645         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11646         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11647         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11648         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11649         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11650         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11651
11652
11653         /* FIXME: use matrix-type input source selection */
11654         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11655         /* Input mixer1: only unmute Mic */
11656         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11657         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11658         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11659         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11660         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11661         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11662         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11663         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11664         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11665         /* Input mixer2 */
11666         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11667         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11668         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11669         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11671         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11673         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11674         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11675         /* Input mixer3 */
11676         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11677         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11678         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11679         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11680         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11681         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11682         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11683         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11684         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11685
11686         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11687
11688         { }
11689 };
11690
11691 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11692         /*
11693          * Unmute ADC0-2 and set the default input to mic-in
11694          */
11695         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11696         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11697         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11698         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11699         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11700         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11701
11702         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11703          * mixer widget
11704          * Note: PASD motherboards uses the Line In 2 as the input for front
11705          * panel mic (mic 2)
11706          */
11707         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11708         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11709         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11710         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11711         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11712         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11713         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11714         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11715         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11716         /*
11717          * Set up output mixers (0x0c - 0x0e)
11718          */
11719         /* set vol=0 to output mixers */
11720         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11721         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11722         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11723
11724         /* set up input amps for analog loopback */
11725         /* Amp Indices: DAC = 0, mixer = 1 */
11726         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11727         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11728         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11729         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11730         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11731         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11732
11733
11734         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11735         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11736         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11737         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11738         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11739         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11740         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11741
11742         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11743         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11744
11745         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11746         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11747
11748         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11749         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11750         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11751         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11752         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11753         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11754
11755         /* FIXME: use matrix-type input source selection */
11756         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11757         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11758         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11759         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11760         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11761         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11762         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11763         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11764         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11765         /* Input mixer2 */
11766         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11767         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11768         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11769         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11770         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11771         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11772         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11773         /* Input mixer3 */
11774         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11775         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11776         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11777         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11778         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11779         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11780         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11781
11782         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11783
11784         { }
11785 };
11786
11787 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11788
11789         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11790         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11791         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11792
11793         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11794         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11795         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11796         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11797
11798         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11799         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11800         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11801         {}
11802 };
11803
11804
11805 #ifdef CONFIG_SND_HDA_POWER_SAVE
11806 #define alc262_loopbacks        alc880_loopbacks
11807 #endif
11808
11809 /* pcm configuration: identical with ALC880 */
11810 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11811 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11812 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11813 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11814
11815 /*
11816  * BIOS auto configuration
11817  */
11818 static int alc262_parse_auto_config(struct hda_codec *codec)
11819 {
11820         struct alc_spec *spec = codec->spec;
11821         int err;
11822         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11823
11824         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11825                                            alc262_ignore);
11826         if (err < 0)
11827                 return err;
11828         if (!spec->autocfg.line_outs) {
11829                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11830                         spec->multiout.max_channels = 2;
11831                         spec->no_analog = 1;
11832                         goto dig_only;
11833                 }
11834                 return 0; /* can't find valid BIOS pin config */
11835         }
11836         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11837         if (err < 0)
11838                 return err;
11839         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11840         if (err < 0)
11841                 return err;
11842
11843         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11844
11845  dig_only:
11846         if (spec->autocfg.dig_outs) {
11847                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11848                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11849         }
11850         if (spec->autocfg.dig_in_pin)
11851                 spec->dig_in_nid = ALC262_DIGIN_NID;
11852
11853         if (spec->kctls.list)
11854                 add_mixer(spec, spec->kctls.list);
11855
11856         add_verb(spec, alc262_volume_init_verbs);
11857         spec->num_mux_defs = 1;
11858         spec->input_mux = &spec->private_imux[0];
11859
11860         err = alc_auto_add_mic_boost(codec);
11861         if (err < 0)
11862                 return err;
11863
11864         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11865
11866         return 1;
11867 }
11868
11869 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11870 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11871 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11872 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11873
11874
11875 /* init callback for auto-configuration model -- overriding the default init */
11876 static void alc262_auto_init(struct hda_codec *codec)
11877 {
11878         struct alc_spec *spec = codec->spec;
11879         alc262_auto_init_multi_out(codec);
11880         alc262_auto_init_hp_out(codec);
11881         alc262_auto_init_analog_input(codec);
11882         alc262_auto_init_input_src(codec);
11883         if (spec->unsol_event)
11884                 alc_inithook(codec);
11885 }
11886
11887 /*
11888  * configuration and preset
11889  */
11890 static const char *alc262_models[ALC262_MODEL_LAST] = {
11891         [ALC262_BASIC]          = "basic",
11892         [ALC262_HIPPO]          = "hippo",
11893         [ALC262_HIPPO_1]        = "hippo_1",
11894         [ALC262_FUJITSU]        = "fujitsu",
11895         [ALC262_HP_BPC]         = "hp-bpc",
11896         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11897         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11898         [ALC262_HP_RP5700]      = "hp-rp5700",
11899         [ALC262_BENQ_ED8]       = "benq",
11900         [ALC262_BENQ_T31]       = "benq-t31",
11901         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11902         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11903         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11904         [ALC262_ULTRA]          = "ultra",
11905         [ALC262_LENOVO_3000]    = "lenovo-3000",
11906         [ALC262_NEC]            = "nec",
11907         [ALC262_TYAN]           = "tyan",
11908         [ALC262_AUTO]           = "auto",
11909 };
11910
11911 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11912         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11913         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11914         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11915                            ALC262_HP_BPC),
11916         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11917                            ALC262_HP_BPC),
11918         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11919                            ALC262_HP_BPC),
11920         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11921         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11922         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11923         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11924         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11925         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11926         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11927         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11928         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11929         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11930         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11931         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11932                       ALC262_HP_TC_T5735),
11933         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11934         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11935         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11936         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11937         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11938         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11939         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11940         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11941 #if 0 /* disable the quirk since model=auto works better in recent versions */
11942         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11943                            ALC262_SONY_ASSAMD),
11944 #endif
11945         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11946                       ALC262_TOSHIBA_RX1),
11947         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11948         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11949         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11950         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11951         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11952                            ALC262_ULTRA),
11953         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11954         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11955         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11956         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11957         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11958         {}
11959 };
11960
11961 static struct alc_config_preset alc262_presets[] = {
11962         [ALC262_BASIC] = {
11963                 .mixers = { alc262_base_mixer },
11964                 .init_verbs = { alc262_init_verbs },
11965                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11966                 .dac_nids = alc262_dac_nids,
11967                 .hp_nid = 0x03,
11968                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11969                 .channel_mode = alc262_modes,
11970                 .input_mux = &alc262_capture_source,
11971         },
11972         [ALC262_HIPPO] = {
11973                 .mixers = { alc262_hippo_mixer },
11974                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11975                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11976                 .dac_nids = alc262_dac_nids,
11977                 .hp_nid = 0x03,
11978                 .dig_out_nid = ALC262_DIGOUT_NID,
11979                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11980                 .channel_mode = alc262_modes,
11981                 .input_mux = &alc262_capture_source,
11982                 .unsol_event = alc262_hippo_unsol_event,
11983                 .setup = alc262_hippo_setup,
11984                 .init_hook = alc262_hippo_automute,
11985         },
11986         [ALC262_HIPPO_1] = {
11987                 .mixers = { alc262_hippo1_mixer },
11988                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11989                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11990                 .dac_nids = alc262_dac_nids,
11991                 .hp_nid = 0x02,
11992                 .dig_out_nid = ALC262_DIGOUT_NID,
11993                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11994                 .channel_mode = alc262_modes,
11995                 .input_mux = &alc262_capture_source,
11996                 .unsol_event = alc262_hippo_unsol_event,
11997                 .setup = alc262_hippo1_setup,
11998                 .init_hook = alc262_hippo_automute,
11999         },
12000         [ALC262_FUJITSU] = {
12001                 .mixers = { alc262_fujitsu_mixer },
12002                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12003                                 alc262_fujitsu_unsol_verbs },
12004                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12005                 .dac_nids = alc262_dac_nids,
12006                 .hp_nid = 0x03,
12007                 .dig_out_nid = ALC262_DIGOUT_NID,
12008                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12009                 .channel_mode = alc262_modes,
12010                 .input_mux = &alc262_fujitsu_capture_source,
12011                 .unsol_event = alc262_fujitsu_unsol_event,
12012                 .init_hook = alc262_fujitsu_init_hook,
12013         },
12014         [ALC262_HP_BPC] = {
12015                 .mixers = { alc262_HP_BPC_mixer },
12016                 .init_verbs = { alc262_HP_BPC_init_verbs },
12017                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12018                 .dac_nids = alc262_dac_nids,
12019                 .hp_nid = 0x03,
12020                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12021                 .channel_mode = alc262_modes,
12022                 .input_mux = &alc262_HP_capture_source,
12023                 .unsol_event = alc262_hp_bpc_unsol_event,
12024                 .init_hook = alc262_hp_bpc_automute,
12025         },
12026         [ALC262_HP_BPC_D7000_WF] = {
12027                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12028                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12029                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12030                 .dac_nids = alc262_dac_nids,
12031                 .hp_nid = 0x03,
12032                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12033                 .channel_mode = alc262_modes,
12034                 .input_mux = &alc262_HP_D7000_capture_source,
12035                 .unsol_event = alc262_hp_wildwest_unsol_event,
12036                 .init_hook = alc262_hp_wildwest_automute,
12037         },
12038         [ALC262_HP_BPC_D7000_WL] = {
12039                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12040                             alc262_HP_BPC_WildWest_option_mixer },
12041                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12042                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12043                 .dac_nids = alc262_dac_nids,
12044                 .hp_nid = 0x03,
12045                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12046                 .channel_mode = alc262_modes,
12047                 .input_mux = &alc262_HP_D7000_capture_source,
12048                 .unsol_event = alc262_hp_wildwest_unsol_event,
12049                 .init_hook = alc262_hp_wildwest_automute,
12050         },
12051         [ALC262_HP_TC_T5735] = {
12052                 .mixers = { alc262_hp_t5735_mixer },
12053                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12054                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12055                 .dac_nids = alc262_dac_nids,
12056                 .hp_nid = 0x03,
12057                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12058                 .channel_mode = alc262_modes,
12059                 .input_mux = &alc262_capture_source,
12060                 .unsol_event = alc_sku_unsol_event,
12061                 .setup = alc262_hp_t5735_setup,
12062                 .init_hook = alc_inithook,
12063         },
12064         [ALC262_HP_RP5700] = {
12065                 .mixers = { alc262_hp_rp5700_mixer },
12066                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12067                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12068                 .dac_nids = alc262_dac_nids,
12069                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12070                 .channel_mode = alc262_modes,
12071                 .input_mux = &alc262_hp_rp5700_capture_source,
12072         },
12073         [ALC262_BENQ_ED8] = {
12074                 .mixers = { alc262_base_mixer },
12075                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12076                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12077                 .dac_nids = alc262_dac_nids,
12078                 .hp_nid = 0x03,
12079                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12080                 .channel_mode = alc262_modes,
12081                 .input_mux = &alc262_capture_source,
12082         },
12083         [ALC262_SONY_ASSAMD] = {
12084                 .mixers = { alc262_sony_mixer },
12085                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12086                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12087                 .dac_nids = alc262_dac_nids,
12088                 .hp_nid = 0x02,
12089                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12090                 .channel_mode = alc262_modes,
12091                 .input_mux = &alc262_capture_source,
12092                 .unsol_event = alc262_hippo_unsol_event,
12093                 .setup = alc262_hippo_setup,
12094                 .init_hook = alc262_hippo_automute,
12095         },
12096         [ALC262_BENQ_T31] = {
12097                 .mixers = { alc262_benq_t31_mixer },
12098                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12099                                 alc_hp15_unsol_verbs },
12100                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12101                 .dac_nids = alc262_dac_nids,
12102                 .hp_nid = 0x03,
12103                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12104                 .channel_mode = alc262_modes,
12105                 .input_mux = &alc262_capture_source,
12106                 .unsol_event = alc262_hippo_unsol_event,
12107                 .setup = alc262_hippo_setup,
12108                 .init_hook = alc262_hippo_automute,
12109         },
12110         [ALC262_ULTRA] = {
12111                 .mixers = { alc262_ultra_mixer },
12112                 .cap_mixer = alc262_ultra_capture_mixer,
12113                 .init_verbs = { alc262_ultra_verbs },
12114                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12115                 .dac_nids = alc262_dac_nids,
12116                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12117                 .channel_mode = alc262_modes,
12118                 .input_mux = &alc262_ultra_capture_source,
12119                 .adc_nids = alc262_adc_nids, /* ADC0 */
12120                 .capsrc_nids = alc262_capsrc_nids,
12121                 .num_adc_nids = 1, /* single ADC */
12122                 .unsol_event = alc262_ultra_unsol_event,
12123                 .init_hook = alc262_ultra_automute,
12124         },
12125         [ALC262_LENOVO_3000] = {
12126                 .mixers = { alc262_lenovo_3000_mixer },
12127                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12128                                 alc262_lenovo_3000_unsol_verbs,
12129                                 alc262_lenovo_3000_init_verbs },
12130                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12131                 .dac_nids = alc262_dac_nids,
12132                 .hp_nid = 0x03,
12133                 .dig_out_nid = ALC262_DIGOUT_NID,
12134                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12135                 .channel_mode = alc262_modes,
12136                 .input_mux = &alc262_fujitsu_capture_source,
12137                 .unsol_event = alc262_lenovo_3000_unsol_event,
12138         },
12139         [ALC262_NEC] = {
12140                 .mixers = { alc262_nec_mixer },
12141                 .init_verbs = { alc262_nec_verbs },
12142                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12143                 .dac_nids = alc262_dac_nids,
12144                 .hp_nid = 0x03,
12145                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12146                 .channel_mode = alc262_modes,
12147                 .input_mux = &alc262_capture_source,
12148         },
12149         [ALC262_TOSHIBA_S06] = {
12150                 .mixers = { alc262_toshiba_s06_mixer },
12151                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12152                                                         alc262_eapd_verbs },
12153                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12154                 .capsrc_nids = alc262_dmic_capsrc_nids,
12155                 .dac_nids = alc262_dac_nids,
12156                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12157                 .num_adc_nids = 1, /* single ADC */
12158                 .dig_out_nid = ALC262_DIGOUT_NID,
12159                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12160                 .channel_mode = alc262_modes,
12161                 .unsol_event = alc_sku_unsol_event,
12162                 .setup = alc262_toshiba_s06_setup,
12163                 .init_hook = alc_inithook,
12164         },
12165         [ALC262_TOSHIBA_RX1] = {
12166                 .mixers = { alc262_toshiba_rx1_mixer },
12167                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12168                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12169                 .dac_nids = alc262_dac_nids,
12170                 .hp_nid = 0x03,
12171                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12172                 .channel_mode = alc262_modes,
12173                 .input_mux = &alc262_capture_source,
12174                 .unsol_event = alc262_hippo_unsol_event,
12175                 .setup = alc262_hippo_setup,
12176                 .init_hook = alc262_hippo_automute,
12177         },
12178         [ALC262_TYAN] = {
12179                 .mixers = { alc262_tyan_mixer },
12180                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12181                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12182                 .dac_nids = alc262_dac_nids,
12183                 .hp_nid = 0x02,
12184                 .dig_out_nid = ALC262_DIGOUT_NID,
12185                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12186                 .channel_mode = alc262_modes,
12187                 .input_mux = &alc262_capture_source,
12188                 .unsol_event = alc_automute_amp_unsol_event,
12189                 .setup = alc262_tyan_setup,
12190                 .init_hook = alc_automute_amp,
12191         },
12192 };
12193
12194 static int patch_alc262(struct hda_codec *codec)
12195 {
12196         struct alc_spec *spec;
12197         int board_config;
12198         int err;
12199
12200         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12201         if (spec == NULL)
12202                 return -ENOMEM;
12203
12204         codec->spec = spec;
12205 #if 0
12206         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12207          * under-run
12208          */
12209         {
12210         int tmp;
12211         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12212         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12213         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12214         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12215         }
12216 #endif
12217
12218         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12219
12220         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12221                                                   alc262_models,
12222                                                   alc262_cfg_tbl);
12223
12224         if (board_config < 0) {
12225                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12226                        codec->chip_name);
12227                 board_config = ALC262_AUTO;
12228         }
12229
12230         if (board_config == ALC262_AUTO) {
12231                 /* automatic parse from the BIOS config */
12232                 err = alc262_parse_auto_config(codec);
12233                 if (err < 0) {
12234                         alc_free(codec);
12235                         return err;
12236                 } else if (!err) {
12237                         printk(KERN_INFO
12238                                "hda_codec: Cannot set up configuration "
12239                                "from BIOS.  Using base mode...\n");
12240                         board_config = ALC262_BASIC;
12241                 }
12242         }
12243
12244         if (!spec->no_analog) {
12245                 err = snd_hda_attach_beep_device(codec, 0x1);
12246                 if (err < 0) {
12247                         alc_free(codec);
12248                         return err;
12249                 }
12250         }
12251
12252         if (board_config != ALC262_AUTO)
12253                 setup_preset(codec, &alc262_presets[board_config]);
12254
12255         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12256         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12257
12258         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12259         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12260
12261         if (!spec->adc_nids && spec->input_mux) {
12262                 int i;
12263                 /* check whether the digital-mic has to be supported */
12264                 for (i = 0; i < spec->input_mux->num_items; i++) {
12265                         if (spec->input_mux->items[i].index >= 9)
12266                                 break;
12267                 }
12268                 if (i < spec->input_mux->num_items) {
12269                         /* use only ADC0 */
12270                         spec->adc_nids = alc262_dmic_adc_nids;
12271                         spec->num_adc_nids = 1;
12272                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12273                 } else {
12274                         /* all analog inputs */
12275                         /* check whether NID 0x07 is valid */
12276                         unsigned int wcap = get_wcaps(codec, 0x07);
12277
12278                         /* get type */
12279                         wcap = get_wcaps_type(wcap);
12280                         if (wcap != AC_WID_AUD_IN) {
12281                                 spec->adc_nids = alc262_adc_nids_alt;
12282                                 spec->num_adc_nids =
12283                                         ARRAY_SIZE(alc262_adc_nids_alt);
12284                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12285                         } else {
12286                                 spec->adc_nids = alc262_adc_nids;
12287                                 spec->num_adc_nids =
12288                                         ARRAY_SIZE(alc262_adc_nids);
12289                                 spec->capsrc_nids = alc262_capsrc_nids;
12290                         }
12291                 }
12292         }
12293         if (!spec->cap_mixer && !spec->no_analog)
12294                 set_capture_mixer(codec);
12295         if (!spec->no_analog)
12296                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12297
12298         spec->vmaster_nid = 0x0c;
12299
12300         codec->patch_ops = alc_patch_ops;
12301         if (board_config == ALC262_AUTO)
12302                 spec->init_hook = alc262_auto_init;
12303 #ifdef CONFIG_SND_HDA_POWER_SAVE
12304         if (!spec->loopback.amplist)
12305                 spec->loopback.amplist = alc262_loopbacks;
12306 #endif
12307
12308         return 0;
12309 }
12310
12311 /*
12312  *  ALC268 channel source setting (2 channel)
12313  */
12314 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12315 #define alc268_modes            alc260_modes
12316
12317 static hda_nid_t alc268_dac_nids[2] = {
12318         /* front, hp */
12319         0x02, 0x03
12320 };
12321
12322 static hda_nid_t alc268_adc_nids[2] = {
12323         /* ADC0-1 */
12324         0x08, 0x07
12325 };
12326
12327 static hda_nid_t alc268_adc_nids_alt[1] = {
12328         /* ADC0 */
12329         0x08
12330 };
12331
12332 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12333
12334 static struct snd_kcontrol_new alc268_base_mixer[] = {
12335         /* output mixer control */
12336         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12337         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12338         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12339         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12340         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12341         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12342         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12343         { }
12344 };
12345
12346 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12347         /* output mixer control */
12348         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12349         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12350         ALC262_HIPPO_MASTER_SWITCH,
12351         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12352         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12353         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12354         { }
12355 };
12356
12357 /* bind Beep switches of both NID 0x0f and 0x10 */
12358 static struct hda_bind_ctls alc268_bind_beep_sw = {
12359         .ops = &snd_hda_bind_sw,
12360         .values = {
12361                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12362                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12363                 0
12364         },
12365 };
12366
12367 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12368         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12369         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12370         { }
12371 };
12372
12373 static struct hda_verb alc268_eapd_verbs[] = {
12374         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12375         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12376         { }
12377 };
12378
12379 /* Toshiba specific */
12380 static struct hda_verb alc268_toshiba_verbs[] = {
12381         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12382         { } /* end */
12383 };
12384
12385 /* Acer specific */
12386 /* bind volumes of both NID 0x02 and 0x03 */
12387 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12388         .ops = &snd_hda_bind_vol,
12389         .values = {
12390                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12391                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12392                 0
12393         },
12394 };
12395
12396 /* mute/unmute internal speaker according to the hp jack and mute state */
12397 static void alc268_acer_automute(struct hda_codec *codec, int force)
12398 {
12399         struct alc_spec *spec = codec->spec;
12400         unsigned int mute;
12401
12402         if (force || !spec->sense_updated) {
12403                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12404                 spec->sense_updated = 1;
12405         }
12406         if (spec->jack_present)
12407                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12408         else /* unmute internal speaker if necessary */
12409                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12410         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12411                                  HDA_AMP_MUTE, mute);
12412 }
12413
12414
12415 /* bind hp and internal speaker mute (with plug check) */
12416 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12417                                      struct snd_ctl_elem_value *ucontrol)
12418 {
12419         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12420         long *valp = ucontrol->value.integer.value;
12421         int change;
12422
12423         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12424         if (change)
12425                 alc268_acer_automute(codec, 0);
12426         return change;
12427 }
12428
12429 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12430         /* output mixer control */
12431         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12432         {
12433                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12434                 .name = "Master Playback Switch",
12435                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12436                 .info = snd_hda_mixer_amp_switch_info,
12437                 .get = snd_hda_mixer_amp_switch_get,
12438                 .put = alc268_acer_master_sw_put,
12439                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12440         },
12441         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12442         { }
12443 };
12444
12445 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12446         /* output mixer control */
12447         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12448         {
12449                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12450                 .name = "Master Playback Switch",
12451                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12452                 .info = snd_hda_mixer_amp_switch_info,
12453                 .get = snd_hda_mixer_amp_switch_get,
12454                 .put = alc268_acer_master_sw_put,
12455                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12456         },
12457         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12458         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12459         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12460         { }
12461 };
12462
12463 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12464         /* output mixer control */
12465         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12466         {
12467                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12468                 .name = "Master Playback Switch",
12469                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12470                 .info = snd_hda_mixer_amp_switch_info,
12471                 .get = snd_hda_mixer_amp_switch_get,
12472                 .put = alc268_acer_master_sw_put,
12473                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12474         },
12475         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12476         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12477         { }
12478 };
12479
12480 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12481         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12482         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12483         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12484         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12485         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12486         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12487         { }
12488 };
12489
12490 static struct hda_verb alc268_acer_verbs[] = {
12491         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12492         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12493         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12494         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12495         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12496         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12497         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12498         { }
12499 };
12500
12501 /* unsolicited event for HP jack sensing */
12502 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12503 #define alc268_toshiba_setup            alc262_hippo_setup
12504 #define alc268_toshiba_automute         alc262_hippo_automute
12505
12506 static void alc268_acer_unsol_event(struct hda_codec *codec,
12507                                        unsigned int res)
12508 {
12509         if ((res >> 26) != ALC880_HP_EVENT)
12510                 return;
12511         alc268_acer_automute(codec, 1);
12512 }
12513
12514 static void alc268_acer_init_hook(struct hda_codec *codec)
12515 {
12516         alc268_acer_automute(codec, 1);
12517 }
12518
12519 /* toggle speaker-output according to the hp-jack state */
12520 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12521 {
12522         unsigned int present;
12523         unsigned char bits;
12524
12525         present = snd_hda_jack_detect(codec, 0x15);
12526         bits = present ? HDA_AMP_MUTE : 0;
12527         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12528                                  HDA_AMP_MUTE, bits);
12529         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12530                                  HDA_AMP_MUTE, bits);
12531 }
12532
12533 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12534                                     unsigned int res)
12535 {
12536         switch (res >> 26) {
12537         case ALC880_HP_EVENT:
12538                 alc268_aspire_one_speaker_automute(codec);
12539                 break;
12540         case ALC880_MIC_EVENT:
12541                 alc_mic_automute(codec);
12542                 break;
12543         }
12544 }
12545
12546 static void alc268_acer_lc_setup(struct hda_codec *codec)
12547 {
12548         struct alc_spec *spec = codec->spec;
12549         spec->ext_mic.pin = 0x18;
12550         spec->ext_mic.mux_idx = 0;
12551         spec->int_mic.pin = 0x12;
12552         spec->int_mic.mux_idx = 6;
12553         spec->auto_mic = 1;
12554 }
12555
12556 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12557 {
12558         alc268_aspire_one_speaker_automute(codec);
12559         alc_mic_automute(codec);
12560 }
12561
12562 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12563         /* output mixer control */
12564         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12565         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12566         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12567         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12568         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12569         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12570         { }
12571 };
12572
12573 static struct hda_verb alc268_dell_verbs[] = {
12574         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12575         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12576         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12577         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12578         { }
12579 };
12580
12581 /* mute/unmute internal speaker according to the hp jack and mute state */
12582 static void alc268_dell_setup(struct hda_codec *codec)
12583 {
12584         struct alc_spec *spec = codec->spec;
12585
12586         spec->autocfg.hp_pins[0] = 0x15;
12587         spec->autocfg.speaker_pins[0] = 0x14;
12588         spec->ext_mic.pin = 0x18;
12589         spec->ext_mic.mux_idx = 0;
12590         spec->int_mic.pin = 0x19;
12591         spec->int_mic.mux_idx = 1;
12592         spec->auto_mic = 1;
12593 }
12594
12595 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12596         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12597         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12598         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12599         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12600         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12601         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12602         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12603         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12604         { }
12605 };
12606
12607 static struct hda_verb alc267_quanta_il1_verbs[] = {
12608         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12609         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12610         { }
12611 };
12612
12613 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12614 {
12615         struct alc_spec *spec = codec->spec;
12616         spec->autocfg.hp_pins[0] = 0x15;
12617         spec->autocfg.speaker_pins[0] = 0x14;
12618         spec->ext_mic.pin = 0x18;
12619         spec->ext_mic.mux_idx = 0;
12620         spec->int_mic.pin = 0x19;
12621         spec->int_mic.mux_idx = 1;
12622         spec->auto_mic = 1;
12623 }
12624
12625 /*
12626  * generic initialization of ADC, input mixers and output mixers
12627  */
12628 static struct hda_verb alc268_base_init_verbs[] = {
12629         /* Unmute DAC0-1 and set vol = 0 */
12630         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12631         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12632
12633         /*
12634          * Set up output mixers (0x0c - 0x0e)
12635          */
12636         /* set vol=0 to output mixers */
12637         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12638         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12639
12640         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12641         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12642
12643         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12644         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12645         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12646         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12647         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12648         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12649         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12650         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12651
12652         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12653         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12654         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12655         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12656         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12657
12658         /* set PCBEEP vol = 0, mute connections */
12659         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12660         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12661         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12662
12663         /* Unmute Selector 23h,24h and set the default input to mic-in */
12664
12665         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12666         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12667         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12668         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12669
12670         { }
12671 };
12672
12673 /*
12674  * generic initialization of ADC, input mixers and output mixers
12675  */
12676 static struct hda_verb alc268_volume_init_verbs[] = {
12677         /* set output DAC */
12678         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12679         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12680
12681         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12682         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12683         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12684         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12685         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12686
12687         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12688         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12689         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12690
12691         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12692         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12693
12694         /* set PCBEEP vol = 0, mute connections */
12695         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12696         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12697         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12698
12699         { }
12700 };
12701
12702 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12703         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12704         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12705         { } /* end */
12706 };
12707
12708 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12709         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12710         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12711         _DEFINE_CAPSRC(1),
12712         { } /* end */
12713 };
12714
12715 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12716         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12717         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12718         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12719         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12720         _DEFINE_CAPSRC(2),
12721         { } /* end */
12722 };
12723
12724 static struct hda_input_mux alc268_capture_source = {
12725         .num_items = 4,
12726         .items = {
12727                 { "Mic", 0x0 },
12728                 { "Front Mic", 0x1 },
12729                 { "Line", 0x2 },
12730                 { "CD", 0x3 },
12731         },
12732 };
12733
12734 static struct hda_input_mux alc268_acer_capture_source = {
12735         .num_items = 3,
12736         .items = {
12737                 { "Mic", 0x0 },
12738                 { "Internal Mic", 0x1 },
12739                 { "Line", 0x2 },
12740         },
12741 };
12742
12743 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12744         .num_items = 3,
12745         .items = {
12746                 { "Mic", 0x0 },
12747                 { "Internal Mic", 0x6 },
12748                 { "Line", 0x2 },
12749         },
12750 };
12751
12752 #ifdef CONFIG_SND_DEBUG
12753 static struct snd_kcontrol_new alc268_test_mixer[] = {
12754         /* Volume widgets */
12755         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12756         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12757         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12758         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12759         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12760         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12761         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12762         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12763         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12764         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12765         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12766         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12767         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12768         /* The below appears problematic on some hardwares */
12769         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12770         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12771         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12772         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12773         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12774
12775         /* Modes for retasking pin widgets */
12776         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12777         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12778         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12779         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12780
12781         /* Controls for GPIO pins, assuming they are configured as outputs */
12782         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12783         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12784         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12785         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12786
12787         /* Switches to allow the digital SPDIF output pin to be enabled.
12788          * The ALC268 does not have an SPDIF input.
12789          */
12790         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12791
12792         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12793          * this output to turn on an external amplifier.
12794          */
12795         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12796         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12797
12798         { } /* end */
12799 };
12800 #endif
12801
12802 /* create input playback/capture controls for the given pin */
12803 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12804                                     const char *ctlname, int idx)
12805 {
12806         hda_nid_t dac;
12807         int err;
12808
12809         switch (nid) {
12810         case 0x14:
12811         case 0x16:
12812                 dac = 0x02;
12813                 break;
12814         case 0x15:
12815                 dac = 0x03;
12816                 break;
12817         default:
12818                 return 0;
12819         }
12820         if (spec->multiout.dac_nids[0] != dac &&
12821             spec->multiout.dac_nids[1] != dac) {
12822                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12823                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12824                                                       HDA_OUTPUT));
12825                 if (err < 0)
12826                         return err;
12827                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12828         }
12829
12830         if (nid != 0x16)
12831                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12832                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12833         else /* mono */
12834                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12835                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12836         if (err < 0)
12837                 return err;
12838         return 0;
12839 }
12840
12841 /* add playback controls from the parsed DAC table */
12842 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12843                                              const struct auto_pin_cfg *cfg)
12844 {
12845         hda_nid_t nid;
12846         int err;
12847
12848         spec->multiout.dac_nids = spec->private_dac_nids;
12849
12850         nid = cfg->line_out_pins[0];
12851         if (nid) {
12852                 const char *name;
12853                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12854                         name = "Speaker";
12855                 else
12856                         name = "Front";
12857                 err = alc268_new_analog_output(spec, nid, name, 0);
12858                 if (err < 0)
12859                         return err;
12860         }
12861
12862         nid = cfg->speaker_pins[0];
12863         if (nid == 0x1d) {
12864                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12865                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12866                 if (err < 0)
12867                         return err;
12868         } else {
12869                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12870                 if (err < 0)
12871                         return err;
12872         }
12873         nid = cfg->hp_pins[0];
12874         if (nid) {
12875                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12876                 if (err < 0)
12877                         return err;
12878         }
12879
12880         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12881         if (nid == 0x16) {
12882                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12883                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12884                 if (err < 0)
12885                         return err;
12886         }
12887         return 0;
12888 }
12889
12890 /* create playback/capture controls for input pins */
12891 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12892                                                 const struct auto_pin_cfg *cfg)
12893 {
12894         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12895 }
12896
12897 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12898                                               hda_nid_t nid, int pin_type)
12899 {
12900         int idx;
12901
12902         alc_set_pin_output(codec, nid, pin_type);
12903         if (nid == 0x14 || nid == 0x16)
12904                 idx = 0;
12905         else
12906                 idx = 1;
12907         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12908 }
12909
12910 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12911 {
12912         struct alc_spec *spec = codec->spec;
12913         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12914         if (nid) {
12915                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12916                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12917         }
12918 }
12919
12920 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12921 {
12922         struct alc_spec *spec = codec->spec;
12923         hda_nid_t pin;
12924
12925         pin = spec->autocfg.hp_pins[0];
12926         if (pin)
12927                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12928         pin = spec->autocfg.speaker_pins[0];
12929         if (pin)
12930                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12931 }
12932
12933 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12934 {
12935         struct alc_spec *spec = codec->spec;
12936         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12937         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12938         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12939         unsigned int    dac_vol1, dac_vol2;
12940
12941         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12942                 snd_hda_codec_write(codec, speaker_nid, 0,
12943                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12944                 /* mute mixer inputs from 0x1d */
12945                 snd_hda_codec_write(codec, 0x0f, 0,
12946                                     AC_VERB_SET_AMP_GAIN_MUTE,
12947                                     AMP_IN_UNMUTE(1));
12948                 snd_hda_codec_write(codec, 0x10, 0,
12949                                     AC_VERB_SET_AMP_GAIN_MUTE,
12950                                     AMP_IN_UNMUTE(1));
12951         } else {
12952                 /* unmute mixer inputs from 0x1d */
12953                 snd_hda_codec_write(codec, 0x0f, 0,
12954                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12955                 snd_hda_codec_write(codec, 0x10, 0,
12956                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12957         }
12958
12959         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12960         if (line_nid == 0x14)
12961                 dac_vol2 = AMP_OUT_ZERO;
12962         else if (line_nid == 0x15)
12963                 dac_vol1 = AMP_OUT_ZERO;
12964         if (hp_nid == 0x14)
12965                 dac_vol2 = AMP_OUT_ZERO;
12966         else if (hp_nid == 0x15)
12967                 dac_vol1 = AMP_OUT_ZERO;
12968         if (line_nid != 0x16 || hp_nid != 0x16 ||
12969             spec->autocfg.line_out_pins[1] != 0x16 ||
12970             spec->autocfg.line_out_pins[2] != 0x16)
12971                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12972
12973         snd_hda_codec_write(codec, 0x02, 0,
12974                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12975         snd_hda_codec_write(codec, 0x03, 0,
12976                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12977 }
12978
12979 /* pcm configuration: identical with ALC880 */
12980 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12981 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12982 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12983 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12984
12985 /*
12986  * BIOS auto configuration
12987  */
12988 static int alc268_parse_auto_config(struct hda_codec *codec)
12989 {
12990         struct alc_spec *spec = codec->spec;
12991         int err;
12992         static hda_nid_t alc268_ignore[] = { 0 };
12993
12994         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12995                                            alc268_ignore);
12996         if (err < 0)
12997                 return err;
12998         if (!spec->autocfg.line_outs) {
12999                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13000                         spec->multiout.max_channels = 2;
13001                         spec->no_analog = 1;
13002                         goto dig_only;
13003                 }
13004                 return 0; /* can't find valid BIOS pin config */
13005         }
13006         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13007         if (err < 0)
13008                 return err;
13009         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13010         if (err < 0)
13011                 return err;
13012
13013         spec->multiout.max_channels = 2;
13014
13015  dig_only:
13016         /* digital only support output */
13017         if (spec->autocfg.dig_outs) {
13018                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
13019                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
13020         }
13021         if (spec->kctls.list)
13022                 add_mixer(spec, spec->kctls.list);
13023
13024         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13025                 add_mixer(spec, alc268_beep_mixer);
13026
13027         add_verb(spec, alc268_volume_init_verbs);
13028         spec->num_mux_defs = 2;
13029         spec->input_mux = &spec->private_imux[0];
13030
13031         err = alc_auto_add_mic_boost(codec);
13032         if (err < 0)
13033                 return err;
13034
13035         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13036
13037         return 1;
13038 }
13039
13040 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13041
13042 /* init callback for auto-configuration model -- overriding the default init */
13043 static void alc268_auto_init(struct hda_codec *codec)
13044 {
13045         struct alc_spec *spec = codec->spec;
13046         alc268_auto_init_multi_out(codec);
13047         alc268_auto_init_hp_out(codec);
13048         alc268_auto_init_mono_speaker_out(codec);
13049         alc268_auto_init_analog_input(codec);
13050         if (spec->unsol_event)
13051                 alc_inithook(codec);
13052 }
13053
13054 /*
13055  * configuration and preset
13056  */
13057 static const char *alc268_models[ALC268_MODEL_LAST] = {
13058         [ALC267_QUANTA_IL1]     = "quanta-il1",
13059         [ALC268_3ST]            = "3stack",
13060         [ALC268_TOSHIBA]        = "toshiba",
13061         [ALC268_ACER]           = "acer",
13062         [ALC268_ACER_DMIC]      = "acer-dmic",
13063         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13064         [ALC268_DELL]           = "dell",
13065         [ALC268_ZEPTO]          = "zepto",
13066 #ifdef CONFIG_SND_DEBUG
13067         [ALC268_TEST]           = "test",
13068 #endif
13069         [ALC268_AUTO]           = "auto",
13070 };
13071
13072 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13073         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13074         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13075         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13076         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13077         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13078         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13079                                                 ALC268_ACER_ASPIRE_ONE),
13080         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13081         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13082                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13083         /* almost compatible with toshiba but with optional digital outs;
13084          * auto-probing seems working fine
13085          */
13086         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13087                            ALC268_AUTO),
13088         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13089         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13090         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13091         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13092         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13093         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
13094         {}
13095 };
13096
13097 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13098 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13099         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13100         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13101         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13102                            ALC268_TOSHIBA),
13103         {}
13104 };
13105
13106 static struct alc_config_preset alc268_presets[] = {
13107         [ALC267_QUANTA_IL1] = {
13108                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13109                             alc268_capture_nosrc_mixer },
13110                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13111                                 alc267_quanta_il1_verbs },
13112                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13113                 .dac_nids = alc268_dac_nids,
13114                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13115                 .adc_nids = alc268_adc_nids_alt,
13116                 .hp_nid = 0x03,
13117                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13118                 .channel_mode = alc268_modes,
13119                 .unsol_event = alc_sku_unsol_event,
13120                 .setup = alc267_quanta_il1_setup,
13121                 .init_hook = alc_inithook,
13122         },
13123         [ALC268_3ST] = {
13124                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13125                             alc268_beep_mixer },
13126                 .init_verbs = { alc268_base_init_verbs },
13127                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13128                 .dac_nids = alc268_dac_nids,
13129                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13130                 .adc_nids = alc268_adc_nids_alt,
13131                 .capsrc_nids = alc268_capsrc_nids,
13132                 .hp_nid = 0x03,
13133                 .dig_out_nid = ALC268_DIGOUT_NID,
13134                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13135                 .channel_mode = alc268_modes,
13136                 .input_mux = &alc268_capture_source,
13137         },
13138         [ALC268_TOSHIBA] = {
13139                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13140                             alc268_beep_mixer },
13141                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13142                                 alc268_toshiba_verbs },
13143                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13144                 .dac_nids = alc268_dac_nids,
13145                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13146                 .adc_nids = alc268_adc_nids_alt,
13147                 .capsrc_nids = alc268_capsrc_nids,
13148                 .hp_nid = 0x03,
13149                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13150                 .channel_mode = alc268_modes,
13151                 .input_mux = &alc268_capture_source,
13152                 .unsol_event = alc268_toshiba_unsol_event,
13153                 .setup = alc268_toshiba_setup,
13154                 .init_hook = alc268_toshiba_automute,
13155         },
13156         [ALC268_ACER] = {
13157                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13158                             alc268_beep_mixer },
13159                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13160                                 alc268_acer_verbs },
13161                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13162                 .dac_nids = alc268_dac_nids,
13163                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13164                 .adc_nids = alc268_adc_nids_alt,
13165                 .capsrc_nids = alc268_capsrc_nids,
13166                 .hp_nid = 0x02,
13167                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13168                 .channel_mode = alc268_modes,
13169                 .input_mux = &alc268_acer_capture_source,
13170                 .unsol_event = alc268_acer_unsol_event,
13171                 .init_hook = alc268_acer_init_hook,
13172         },
13173         [ALC268_ACER_DMIC] = {
13174                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13175                             alc268_beep_mixer },
13176                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13177                                 alc268_acer_verbs },
13178                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13179                 .dac_nids = alc268_dac_nids,
13180                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13181                 .adc_nids = alc268_adc_nids_alt,
13182                 .capsrc_nids = alc268_capsrc_nids,
13183                 .hp_nid = 0x02,
13184                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13185                 .channel_mode = alc268_modes,
13186                 .input_mux = &alc268_acer_dmic_capture_source,
13187                 .unsol_event = alc268_acer_unsol_event,
13188                 .init_hook = alc268_acer_init_hook,
13189         },
13190         [ALC268_ACER_ASPIRE_ONE] = {
13191                 .mixers = { alc268_acer_aspire_one_mixer,
13192                             alc268_beep_mixer,
13193                             alc268_capture_nosrc_mixer },
13194                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13195                                 alc268_acer_aspire_one_verbs },
13196                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13197                 .dac_nids = alc268_dac_nids,
13198                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13199                 .adc_nids = alc268_adc_nids_alt,
13200                 .capsrc_nids = alc268_capsrc_nids,
13201                 .hp_nid = 0x03,
13202                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13203                 .channel_mode = alc268_modes,
13204                 .unsol_event = alc268_acer_lc_unsol_event,
13205                 .setup = alc268_acer_lc_setup,
13206                 .init_hook = alc268_acer_lc_init_hook,
13207         },
13208         [ALC268_DELL] = {
13209                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13210                             alc268_capture_nosrc_mixer },
13211                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13212                                 alc268_dell_verbs },
13213                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13214                 .dac_nids = alc268_dac_nids,
13215                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13216                 .adc_nids = alc268_adc_nids_alt,
13217                 .capsrc_nids = alc268_capsrc_nids,
13218                 .hp_nid = 0x02,
13219                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13220                 .channel_mode = alc268_modes,
13221                 .unsol_event = alc_sku_unsol_event,
13222                 .setup = alc268_dell_setup,
13223                 .init_hook = alc_inithook,
13224         },
13225         [ALC268_ZEPTO] = {
13226                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13227                             alc268_beep_mixer },
13228                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13229                                 alc268_toshiba_verbs },
13230                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13231                 .dac_nids = alc268_dac_nids,
13232                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13233                 .adc_nids = alc268_adc_nids_alt,
13234                 .capsrc_nids = alc268_capsrc_nids,
13235                 .hp_nid = 0x03,
13236                 .dig_out_nid = ALC268_DIGOUT_NID,
13237                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13238                 .channel_mode = alc268_modes,
13239                 .input_mux = &alc268_capture_source,
13240                 .setup = alc268_toshiba_setup,
13241                 .init_hook = alc268_toshiba_automute,
13242         },
13243 #ifdef CONFIG_SND_DEBUG
13244         [ALC268_TEST] = {
13245                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13246                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13247                                 alc268_volume_init_verbs },
13248                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13249                 .dac_nids = alc268_dac_nids,
13250                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13251                 .adc_nids = alc268_adc_nids_alt,
13252                 .capsrc_nids = alc268_capsrc_nids,
13253                 .hp_nid = 0x03,
13254                 .dig_out_nid = ALC268_DIGOUT_NID,
13255                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13256                 .channel_mode = alc268_modes,
13257                 .input_mux = &alc268_capture_source,
13258         },
13259 #endif
13260 };
13261
13262 static int patch_alc268(struct hda_codec *codec)
13263 {
13264         struct alc_spec *spec;
13265         int board_config;
13266         int i, has_beep, err;
13267
13268         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13269         if (spec == NULL)
13270                 return -ENOMEM;
13271
13272         codec->spec = spec;
13273
13274         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13275                                                   alc268_models,
13276                                                   alc268_cfg_tbl);
13277
13278         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13279                 board_config = snd_hda_check_board_codec_sid_config(codec,
13280                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13281
13282         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13283                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13284                        codec->chip_name);
13285                 board_config = ALC268_AUTO;
13286         }
13287
13288         if (board_config == ALC268_AUTO) {
13289                 /* automatic parse from the BIOS config */
13290                 err = alc268_parse_auto_config(codec);
13291                 if (err < 0) {
13292                         alc_free(codec);
13293                         return err;
13294                 } else if (!err) {
13295                         printk(KERN_INFO
13296                                "hda_codec: Cannot set up configuration "
13297                                "from BIOS.  Using base mode...\n");
13298                         board_config = ALC268_3ST;
13299                 }
13300         }
13301
13302         if (board_config != ALC268_AUTO)
13303                 setup_preset(codec, &alc268_presets[board_config]);
13304
13305         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13306         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13307         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13308
13309         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13310
13311         has_beep = 0;
13312         for (i = 0; i < spec->num_mixers; i++) {
13313                 if (spec->mixers[i] == alc268_beep_mixer) {
13314                         has_beep = 1;
13315                         break;
13316                 }
13317         }
13318
13319         if (has_beep) {
13320                 err = snd_hda_attach_beep_device(codec, 0x1);
13321                 if (err < 0) {
13322                         alc_free(codec);
13323                         return err;
13324                 }
13325                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13326                         /* override the amp caps for beep generator */
13327                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13328                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13329                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13330                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13331                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13332         }
13333
13334         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13335                 /* check whether NID 0x07 is valid */
13336                 unsigned int wcap = get_wcaps(codec, 0x07);
13337                 int i;
13338
13339                 spec->capsrc_nids = alc268_capsrc_nids;
13340                 /* get type */
13341                 wcap = get_wcaps_type(wcap);
13342                 if (spec->auto_mic ||
13343                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13344                         spec->adc_nids = alc268_adc_nids_alt;
13345                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13346                         if (spec->auto_mic)
13347                                 fixup_automic_adc(codec);
13348                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13349                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13350                         else
13351                                 add_mixer(spec, alc268_capture_alt_mixer);
13352                 } else {
13353                         spec->adc_nids = alc268_adc_nids;
13354                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13355                         add_mixer(spec, alc268_capture_mixer);
13356                 }
13357                 /* set default input source */
13358                 for (i = 0; i < spec->num_adc_nids; i++)
13359                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13360                                 0, AC_VERB_SET_CONNECT_SEL,
13361                                 i < spec->num_mux_defs ?
13362                                 spec->input_mux[i].items[0].index :
13363                                 spec->input_mux->items[0].index);
13364         }
13365
13366         spec->vmaster_nid = 0x02;
13367
13368         codec->patch_ops = alc_patch_ops;
13369         if (board_config == ALC268_AUTO)
13370                 spec->init_hook = alc268_auto_init;
13371
13372         return 0;
13373 }
13374
13375 /*
13376  *  ALC269 channel source setting (2 channel)
13377  */
13378 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13379
13380 #define alc269_dac_nids         alc260_dac_nids
13381
13382 static hda_nid_t alc269_adc_nids[1] = {
13383         /* ADC1 */
13384         0x08,
13385 };
13386
13387 static hda_nid_t alc269_capsrc_nids[1] = {
13388         0x23,
13389 };
13390
13391 static hda_nid_t alc269vb_adc_nids[1] = {
13392         /* ADC1 */
13393         0x09,
13394 };
13395
13396 static hda_nid_t alc269vb_capsrc_nids[1] = {
13397         0x22,
13398 };
13399
13400 static hda_nid_t alc269_adc_candidates[] = {
13401         0x08, 0x09, 0x07,
13402 };
13403
13404 #define alc269_modes            alc260_modes
13405 #define alc269_capture_source   alc880_lg_lw_capture_source
13406
13407 static struct snd_kcontrol_new alc269_base_mixer[] = {
13408         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13409         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13410         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13411         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13412         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13413         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13414         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13415         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13416         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13417         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13418         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13419         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13420         { } /* end */
13421 };
13422
13423 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13424         /* output mixer control */
13425         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13426         {
13427                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13428                 .name = "Master Playback Switch",
13429                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13430                 .info = snd_hda_mixer_amp_switch_info,
13431                 .get = snd_hda_mixer_amp_switch_get,
13432                 .put = alc268_acer_master_sw_put,
13433                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13434         },
13435         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13436         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13437         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13438         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13439         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13440         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13441         { }
13442 };
13443
13444 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13445         /* output mixer control */
13446         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13447         {
13448                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13449                 .name = "Master Playback Switch",
13450                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13451                 .info = snd_hda_mixer_amp_switch_info,
13452                 .get = snd_hda_mixer_amp_switch_get,
13453                 .put = alc268_acer_master_sw_put,
13454                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13455         },
13456         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13457         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13458         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13459         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13460         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13461         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13462         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13463         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13464         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13465         { }
13466 };
13467
13468 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
13469         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13470         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13471         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13472         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13473         { } /* end */
13474 };
13475
13476 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
13477         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13478         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13479         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13480         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13481         { } /* end */
13482 };
13483
13484 /* capture mixer elements */
13485 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
13486         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13487         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13488         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13489         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13490         { } /* end */
13491 };
13492
13493 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
13494         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13495         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13496         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13497         { } /* end */
13498 };
13499
13500 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
13501         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13502         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13503         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13504         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13505         { } /* end */
13506 };
13507
13508 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
13509         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13510         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13511         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13512         { } /* end */
13513 };
13514
13515 /* FSC amilo */
13516 #define alc269_fujitsu_mixer    alc269_laptop_mixer
13517
13518 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13519         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13520         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13521         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13522         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13523         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13524         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13525         { }
13526 };
13527
13528 static struct hda_verb alc269_lifebook_verbs[] = {
13529         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13530         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13531         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13532         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13533         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13534         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13535         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13536         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13537         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13538         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13539         { }
13540 };
13541
13542 /* toggle speaker-output according to the hp-jack state */
13543 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13544 {
13545         unsigned int present;
13546         unsigned char bits;
13547
13548         present = snd_hda_jack_detect(codec, 0x15);
13549         bits = present ? HDA_AMP_MUTE : 0;
13550         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13551                                  HDA_AMP_MUTE, bits);
13552         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13553                                  HDA_AMP_MUTE, bits);
13554
13555         snd_hda_codec_write(codec, 0x20, 0,
13556                         AC_VERB_SET_COEF_INDEX, 0x0c);
13557         snd_hda_codec_write(codec, 0x20, 0,
13558                         AC_VERB_SET_PROC_COEF, 0x680);
13559
13560         snd_hda_codec_write(codec, 0x20, 0,
13561                         AC_VERB_SET_COEF_INDEX, 0x0c);
13562         snd_hda_codec_write(codec, 0x20, 0,
13563                         AC_VERB_SET_PROC_COEF, 0x480);
13564 }
13565
13566 /* toggle speaker-output according to the hp-jacks state */
13567 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13568 {
13569         unsigned int present;
13570         unsigned char bits;
13571
13572         /* Check laptop headphone socket */
13573         present = snd_hda_jack_detect(codec, 0x15);
13574
13575         /* Check port replicator headphone socket */
13576         present |= snd_hda_jack_detect(codec, 0x1a);
13577
13578         bits = present ? HDA_AMP_MUTE : 0;
13579         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13580                                  HDA_AMP_MUTE, bits);
13581         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13582                                  HDA_AMP_MUTE, bits);
13583
13584         snd_hda_codec_write(codec, 0x20, 0,
13585                         AC_VERB_SET_COEF_INDEX, 0x0c);
13586         snd_hda_codec_write(codec, 0x20, 0,
13587                         AC_VERB_SET_PROC_COEF, 0x680);
13588
13589         snd_hda_codec_write(codec, 0x20, 0,
13590                         AC_VERB_SET_COEF_INDEX, 0x0c);
13591         snd_hda_codec_write(codec, 0x20, 0,
13592                         AC_VERB_SET_PROC_COEF, 0x480);
13593 }
13594
13595 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13596 {
13597         unsigned int present_laptop;
13598         unsigned int present_dock;
13599
13600         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13601         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13602
13603         /* Laptop mic port overrides dock mic port, design decision */
13604         if (present_dock)
13605                 snd_hda_codec_write(codec, 0x23, 0,
13606                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13607         if (present_laptop)
13608                 snd_hda_codec_write(codec, 0x23, 0,
13609                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13610         if (!present_dock && !present_laptop)
13611                 snd_hda_codec_write(codec, 0x23, 0,
13612                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13613 }
13614
13615 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13616                                     unsigned int res)
13617 {
13618         switch (res >> 26) {
13619         case ALC880_HP_EVENT:
13620                 alc269_quanta_fl1_speaker_automute(codec);
13621                 break;
13622         case ALC880_MIC_EVENT:
13623                 alc_mic_automute(codec);
13624                 break;
13625         }
13626 }
13627
13628 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13629                                         unsigned int res)
13630 {
13631         if ((res >> 26) == ALC880_HP_EVENT)
13632                 alc269_lifebook_speaker_automute(codec);
13633         if ((res >> 26) == ALC880_MIC_EVENT)
13634                 alc269_lifebook_mic_autoswitch(codec);
13635 }
13636
13637 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13638 {
13639         struct alc_spec *spec = codec->spec;
13640         spec->autocfg.hp_pins[0] = 0x15;
13641         spec->autocfg.speaker_pins[0] = 0x14;
13642         spec->ext_mic.pin = 0x18;
13643         spec->ext_mic.mux_idx = 0;
13644         spec->int_mic.pin = 0x19;
13645         spec->int_mic.mux_idx = 1;
13646         spec->auto_mic = 1;
13647 }
13648
13649 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13650 {
13651         alc269_quanta_fl1_speaker_automute(codec);
13652         alc_mic_automute(codec);
13653 }
13654
13655 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13656 {
13657         alc269_lifebook_speaker_automute(codec);
13658         alc269_lifebook_mic_autoswitch(codec);
13659 }
13660
13661 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
13662         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13663         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13664         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13665         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13666         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13667         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13668         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13669         {}
13670 };
13671
13672 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
13673         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13674         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13675         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13676         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13677         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13678         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13679         {}
13680 };
13681
13682 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
13683         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13684         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
13685         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13686         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13687         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13688         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13689         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13690         {}
13691 };
13692
13693 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
13694         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13695         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
13696         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13697         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13698         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13699         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13700         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13701         {}
13702 };
13703
13704 /* toggle speaker-output according to the hp-jack state */
13705 static void alc269_speaker_automute(struct hda_codec *codec)
13706 {
13707         struct alc_spec *spec = codec->spec;
13708         unsigned int nid = spec->autocfg.hp_pins[0];
13709         unsigned int present;
13710         unsigned char bits;
13711
13712         present = snd_hda_jack_detect(codec, nid);
13713         bits = present ? HDA_AMP_MUTE : 0;
13714         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13715                                  HDA_AMP_MUTE, bits);
13716         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13717                                  HDA_AMP_MUTE, bits);
13718 }
13719
13720 /* unsolicited event for HP jack sensing */
13721 static void alc269_laptop_unsol_event(struct hda_codec *codec,
13722                                      unsigned int res)
13723 {
13724         switch (res >> 26) {
13725         case ALC880_HP_EVENT:
13726                 alc269_speaker_automute(codec);
13727                 break;
13728         case ALC880_MIC_EVENT:
13729                 alc_mic_automute(codec);
13730                 break;
13731         }
13732 }
13733
13734 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
13735 {
13736         struct alc_spec *spec = codec->spec;
13737         spec->autocfg.hp_pins[0] = 0x15;
13738         spec->autocfg.speaker_pins[0] = 0x14;
13739         spec->ext_mic.pin = 0x18;
13740         spec->ext_mic.mux_idx = 0;
13741         spec->int_mic.pin = 0x12;
13742         spec->int_mic.mux_idx = 5;
13743         spec->auto_mic = 1;
13744 }
13745
13746 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
13747 {
13748         struct alc_spec *spec = codec->spec;
13749         spec->autocfg.hp_pins[0] = 0x15;
13750         spec->autocfg.speaker_pins[0] = 0x14;
13751         spec->ext_mic.pin = 0x18;
13752         spec->ext_mic.mux_idx = 0;
13753         spec->int_mic.pin = 0x12;
13754         spec->int_mic.mux_idx = 6;
13755         spec->auto_mic = 1;
13756 }
13757
13758 static void alc269_laptop_amic_setup(struct hda_codec *codec)
13759 {
13760         struct alc_spec *spec = codec->spec;
13761         spec->autocfg.hp_pins[0] = 0x15;
13762         spec->autocfg.speaker_pins[0] = 0x14;
13763         spec->ext_mic.pin = 0x18;
13764         spec->ext_mic.mux_idx = 0;
13765         spec->int_mic.pin = 0x19;
13766         spec->int_mic.mux_idx = 1;
13767         spec->auto_mic = 1;
13768 }
13769
13770 static void alc269_laptop_inithook(struct hda_codec *codec)
13771 {
13772         alc269_speaker_automute(codec);
13773         alc_mic_automute(codec);
13774 }
13775
13776 /*
13777  * generic initialization of ADC, input mixers and output mixers
13778  */
13779 static struct hda_verb alc269_init_verbs[] = {
13780         /*
13781          * Unmute ADC0 and set the default input to mic-in
13782          */
13783         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13784
13785         /*
13786          * Set up output mixers (0x02 - 0x03)
13787          */
13788         /* set vol=0 to output mixers */
13789         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13790         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13791
13792         /* set up input amps for analog loopback */
13793         /* Amp Indices: DAC = 0, mixer = 1 */
13794         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13795         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13796         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13797         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13798         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13799         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13800
13801         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13802         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13803         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13804         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13805         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13806         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13807         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13808
13809         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13810         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13811
13812         /* FIXME: use Mux-type input source selection */
13813         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13814         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13815         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13816
13817         /* set EAPD */
13818         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13819         { }
13820 };
13821
13822 static struct hda_verb alc269vb_init_verbs[] = {
13823         /*
13824          * Unmute ADC0 and set the default input to mic-in
13825          */
13826         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13827
13828         /*
13829          * Set up output mixers (0x02 - 0x03)
13830          */
13831         /* set vol=0 to output mixers */
13832         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13833         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13834
13835         /* set up input amps for analog loopback */
13836         /* Amp Indices: DAC = 0, mixer = 1 */
13837         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13838         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13839         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13840         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13841         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13842         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13843
13844         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13845         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13846         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13847         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13848         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13849         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13850         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13851
13852         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13853         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13854
13855         /* FIXME: use Mux-type input source selection */
13856         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13857         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13858         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
13859
13860         /* set EAPD */
13861         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13862         { }
13863 };
13864
13865 #define alc269_auto_create_multi_out_ctls \
13866         alc268_auto_create_multi_out_ctls
13867 #define alc269_auto_create_input_ctls \
13868         alc268_auto_create_input_ctls
13869
13870 #ifdef CONFIG_SND_HDA_POWER_SAVE
13871 #define alc269_loopbacks        alc880_loopbacks
13872 #endif
13873
13874 /* pcm configuration: identical with ALC880 */
13875 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13876 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13877 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13878 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13879
13880 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13881         .substreams = 1,
13882         .channels_min = 2,
13883         .channels_max = 8,
13884         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13885         /* NID is set in alc_build_pcms */
13886         .ops = {
13887                 .open = alc880_playback_pcm_open,
13888                 .prepare = alc880_playback_pcm_prepare,
13889                 .cleanup = alc880_playback_pcm_cleanup
13890         },
13891 };
13892
13893 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13894         .substreams = 1,
13895         .channels_min = 2,
13896         .channels_max = 2,
13897         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13898         /* NID is set in alc_build_pcms */
13899 };
13900
13901 /*
13902  * BIOS auto configuration
13903  */
13904 static int alc269_parse_auto_config(struct hda_codec *codec)
13905 {
13906         struct alc_spec *spec = codec->spec;
13907         int err;
13908         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13909
13910         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13911                                            alc269_ignore);
13912         if (err < 0)
13913                 return err;
13914
13915         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13916         if (err < 0)
13917                 return err;
13918         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13919         if (err < 0)
13920                 return err;
13921
13922         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13923
13924         if (spec->autocfg.dig_outs)
13925                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13926
13927         if (spec->kctls.list)
13928                 add_mixer(spec, spec->kctls.list);
13929
13930         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) {
13931                 add_verb(spec, alc269vb_init_verbs);
13932                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
13933         } else {
13934                 add_verb(spec, alc269_init_verbs);
13935                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13936         }
13937
13938         spec->num_mux_defs = 1;
13939         spec->input_mux = &spec->private_imux[0];
13940         fillup_priv_adc_nids(codec, alc269_adc_candidates,
13941                              sizeof(alc269_adc_candidates));
13942
13943         /* set default input source */
13944         snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
13945                                   0, AC_VERB_SET_CONNECT_SEL,
13946                                   spec->input_mux->items[0].index);
13947
13948         err = alc_auto_add_mic_boost(codec);
13949         if (err < 0)
13950                 return err;
13951
13952         if (!spec->cap_mixer && !spec->no_analog)
13953                 set_capture_mixer(codec);
13954
13955         return 1;
13956 }
13957
13958 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13959 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13960 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13961
13962
13963 /* init callback for auto-configuration model -- overriding the default init */
13964 static void alc269_auto_init(struct hda_codec *codec)
13965 {
13966         struct alc_spec *spec = codec->spec;
13967         alc269_auto_init_multi_out(codec);
13968         alc269_auto_init_hp_out(codec);
13969         alc269_auto_init_analog_input(codec);
13970         if (spec->unsol_event)
13971                 alc_inithook(codec);
13972 }
13973
13974 /*
13975  * configuration and preset
13976  */
13977 static const char *alc269_models[ALC269_MODEL_LAST] = {
13978         [ALC269_BASIC]                  = "basic",
13979         [ALC269_QUANTA_FL1]             = "quanta",
13980         [ALC269_AMIC]                   = "laptop-amic",
13981         [ALC269_DMIC]                   = "laptop-dmic",
13982         [ALC269_FUJITSU]                = "fujitsu",
13983         [ALC269_LIFEBOOK]               = "lifebook",
13984         [ALC269_AUTO]                   = "auto",
13985 };
13986
13987 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13988         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13989         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13990                       ALC269_AMIC),
13991         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
13992         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
13993         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
13994         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
13995         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
13996         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
13997         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
13998         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
13999         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14000         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14001         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14002         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14003         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14004         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14005         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14006         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14007         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14008         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14009         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14010         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14011         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14012         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14013         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14014         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14015         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14016         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14017         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14018         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14019         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14020         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14021         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14022         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14023         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14024         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14025         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14026         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14027         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14028                       ALC269_DMIC),
14029         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14030                       ALC269_DMIC),
14031         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14032         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14033         SND_PCI_QUIRK(0x104d, 0x9071, "SONY XTB", ALC269_DMIC),
14034         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14035         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14036         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14037         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14038         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14039         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14040         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14041         {}
14042 };
14043
14044 static struct alc_config_preset alc269_presets[] = {
14045         [ALC269_BASIC] = {
14046                 .mixers = { alc269_base_mixer },
14047                 .init_verbs = { alc269_init_verbs },
14048                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14049                 .dac_nids = alc269_dac_nids,
14050                 .hp_nid = 0x03,
14051                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14052                 .channel_mode = alc269_modes,
14053                 .input_mux = &alc269_capture_source,
14054         },
14055         [ALC269_QUANTA_FL1] = {
14056                 .mixers = { alc269_quanta_fl1_mixer },
14057                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14058                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14059                 .dac_nids = alc269_dac_nids,
14060                 .hp_nid = 0x03,
14061                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14062                 .channel_mode = alc269_modes,
14063                 .input_mux = &alc269_capture_source,
14064                 .unsol_event = alc269_quanta_fl1_unsol_event,
14065                 .setup = alc269_quanta_fl1_setup,
14066                 .init_hook = alc269_quanta_fl1_init_hook,
14067         },
14068         [ALC269_AMIC] = {
14069                 .mixers = { alc269_laptop_mixer },
14070                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14071                 .init_verbs = { alc269_init_verbs,
14072                                 alc269_laptop_amic_init_verbs },
14073                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14074                 .dac_nids = alc269_dac_nids,
14075                 .hp_nid = 0x03,
14076                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14077                 .channel_mode = alc269_modes,
14078                 .unsol_event = alc269_laptop_unsol_event,
14079                 .setup = alc269_laptop_amic_setup,
14080                 .init_hook = alc269_laptop_inithook,
14081         },
14082         [ALC269_DMIC] = {
14083                 .mixers = { alc269_laptop_mixer },
14084                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14085                 .init_verbs = { alc269_init_verbs,
14086                                 alc269_laptop_dmic_init_verbs },
14087                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14088                 .dac_nids = alc269_dac_nids,
14089                 .hp_nid = 0x03,
14090                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14091                 .channel_mode = alc269_modes,
14092                 .unsol_event = alc269_laptop_unsol_event,
14093                 .setup = alc269_laptop_dmic_setup,
14094                 .init_hook = alc269_laptop_inithook,
14095         },
14096         [ALC269VB_AMIC] = {
14097                 .mixers = { alc269vb_laptop_mixer },
14098                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14099                 .init_verbs = { alc269vb_init_verbs,
14100                                 alc269vb_laptop_amic_init_verbs },
14101                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14102                 .dac_nids = alc269_dac_nids,
14103                 .hp_nid = 0x03,
14104                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14105                 .channel_mode = alc269_modes,
14106                 .unsol_event = alc269_laptop_unsol_event,
14107                 .setup = alc269_laptop_amic_setup,
14108                 .init_hook = alc269_laptop_inithook,
14109         },
14110         [ALC269VB_DMIC] = {
14111                 .mixers = { alc269vb_laptop_mixer },
14112                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14113                 .init_verbs = { alc269vb_init_verbs,
14114                                 alc269vb_laptop_dmic_init_verbs },
14115                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14116                 .dac_nids = alc269_dac_nids,
14117                 .hp_nid = 0x03,
14118                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14119                 .channel_mode = alc269_modes,
14120                 .unsol_event = alc269_laptop_unsol_event,
14121                 .setup = alc269vb_laptop_dmic_setup,
14122                 .init_hook = alc269_laptop_inithook,
14123         },
14124         [ALC269_FUJITSU] = {
14125                 .mixers = { alc269_fujitsu_mixer },
14126                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14127                 .init_verbs = { alc269_init_verbs,
14128                                 alc269_laptop_dmic_init_verbs },
14129                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14130                 .dac_nids = alc269_dac_nids,
14131                 .hp_nid = 0x03,
14132                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14133                 .channel_mode = alc269_modes,
14134                 .unsol_event = alc269_laptop_unsol_event,
14135                 .setup = alc269_laptop_dmic_setup,
14136                 .init_hook = alc269_laptop_inithook,
14137         },
14138         [ALC269_LIFEBOOK] = {
14139                 .mixers = { alc269_lifebook_mixer },
14140                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14141                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14142                 .dac_nids = alc269_dac_nids,
14143                 .hp_nid = 0x03,
14144                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14145                 .channel_mode = alc269_modes,
14146                 .input_mux = &alc269_capture_source,
14147                 .unsol_event = alc269_lifebook_unsol_event,
14148                 .init_hook = alc269_lifebook_init_hook,
14149         },
14150 };
14151
14152 static int patch_alc269(struct hda_codec *codec)
14153 {
14154         struct alc_spec *spec;
14155         int board_config;
14156         int err;
14157         int is_alc269vb = 0;
14158
14159         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14160         if (spec == NULL)
14161                 return -ENOMEM;
14162
14163         codec->spec = spec;
14164
14165         alc_fix_pll_init(codec, 0x20, 0x04, 15);
14166
14167         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14168                 kfree(codec->chip_name);
14169                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
14170                 if (!codec->chip_name) {
14171                         alc_free(codec);
14172                         return -ENOMEM;
14173                 }
14174                 is_alc269vb = 1;
14175         }
14176
14177         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14178                                                   alc269_models,
14179                                                   alc269_cfg_tbl);
14180
14181         if (board_config < 0) {
14182                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14183                        codec->chip_name);
14184                 board_config = ALC269_AUTO;
14185         }
14186
14187         if (board_config == ALC269_AUTO) {
14188                 /* automatic parse from the BIOS config */
14189                 err = alc269_parse_auto_config(codec);
14190                 if (err < 0) {
14191                         alc_free(codec);
14192                         return err;
14193                 } else if (!err) {
14194                         printk(KERN_INFO
14195                                "hda_codec: Cannot set up configuration "
14196                                "from BIOS.  Using base mode...\n");
14197                         board_config = ALC269_BASIC;
14198                 }
14199         }
14200
14201         err = snd_hda_attach_beep_device(codec, 0x1);
14202         if (err < 0) {
14203                 alc_free(codec);
14204                 return err;
14205         }
14206
14207         if (board_config != ALC269_AUTO)
14208                 setup_preset(codec, &alc269_presets[board_config]);
14209
14210         if (board_config == ALC269_QUANTA_FL1) {
14211                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
14212                  * fix the sample rate of analog I/O to 44.1kHz
14213                  */
14214                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
14215                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
14216         } else {
14217                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
14218                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
14219         }
14220         spec->stream_digital_playback = &alc269_pcm_digital_playback;
14221         spec->stream_digital_capture = &alc269_pcm_digital_capture;
14222
14223         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
14224                 if (!is_alc269vb) {
14225                         spec->adc_nids = alc269_adc_nids;
14226                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
14227                         spec->capsrc_nids = alc269_capsrc_nids;
14228                 } else {
14229                         spec->adc_nids = alc269vb_adc_nids;
14230                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
14231                         spec->capsrc_nids = alc269vb_capsrc_nids;
14232                 }
14233         }
14234
14235         if (!spec->cap_mixer)
14236                 set_capture_mixer(codec);
14237         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
14238
14239         spec->vmaster_nid = 0x02;
14240
14241         codec->patch_ops = alc_patch_ops;
14242         if (board_config == ALC269_AUTO)
14243                 spec->init_hook = alc269_auto_init;
14244 #ifdef CONFIG_SND_HDA_POWER_SAVE
14245         if (!spec->loopback.amplist)
14246                 spec->loopback.amplist = alc269_loopbacks;
14247 #endif
14248
14249         return 0;
14250 }
14251
14252 /*
14253  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
14254  */
14255
14256 /*
14257  * set the path ways for 2 channel output
14258  * need to set the codec line out and mic 1 pin widgets to inputs
14259  */
14260 static struct hda_verb alc861_threestack_ch2_init[] = {
14261         /* set pin widget 1Ah (line in) for input */
14262         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14263         /* set pin widget 18h (mic1/2) for input, for mic also enable
14264          * the vref
14265          */
14266         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14267
14268         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14269 #if 0
14270         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14271         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14272 #endif
14273         { } /* end */
14274 };
14275 /*
14276  * 6ch mode
14277  * need to set the codec line out and mic 1 pin widgets to outputs
14278  */
14279 static struct hda_verb alc861_threestack_ch6_init[] = {
14280         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14281         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14282         /* set pin widget 18h (mic1) for output (CLFE)*/
14283         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14284
14285         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14286         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14287
14288         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14289 #if 0
14290         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14291         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14292 #endif
14293         { } /* end */
14294 };
14295
14296 static struct hda_channel_mode alc861_threestack_modes[2] = {
14297         { 2, alc861_threestack_ch2_init },
14298         { 6, alc861_threestack_ch6_init },
14299 };
14300 /* Set mic1 as input and unmute the mixer */
14301 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
14302         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14303         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14304         { } /* end */
14305 };
14306 /* Set mic1 as output and mute mixer */
14307 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
14308         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14309         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14310         { } /* end */
14311 };
14312
14313 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
14314         { 2, alc861_uniwill_m31_ch2_init },
14315         { 4, alc861_uniwill_m31_ch4_init },
14316 };
14317
14318 /* Set mic1 and line-in as input and unmute the mixer */
14319 static struct hda_verb alc861_asus_ch2_init[] = {
14320         /* set pin widget 1Ah (line in) for input */
14321         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14322         /* set pin widget 18h (mic1/2) for input, for mic also enable
14323          * the vref
14324          */
14325         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14326
14327         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14328 #if 0
14329         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14330         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14331 #endif
14332         { } /* end */
14333 };
14334 /* Set mic1 nad line-in as output and mute mixer */
14335 static struct hda_verb alc861_asus_ch6_init[] = {
14336         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14337         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14338         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14339         /* set pin widget 18h (mic1) for output (CLFE)*/
14340         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14341         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14342         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14343         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14344
14345         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14346 #if 0
14347         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14348         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14349 #endif
14350         { } /* end */
14351 };
14352
14353 static struct hda_channel_mode alc861_asus_modes[2] = {
14354         { 2, alc861_asus_ch2_init },
14355         { 6, alc861_asus_ch6_init },
14356 };
14357
14358 /* patch-ALC861 */
14359
14360 static struct snd_kcontrol_new alc861_base_mixer[] = {
14361         /* output mixer control */
14362         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14363         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14364         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14365         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14366         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14367
14368         /*Input mixer control */
14369         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14370            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14371         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14372         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14373         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14374         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14375         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14376         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14377         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14378         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14379
14380         { } /* end */
14381 };
14382
14383 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
14384         /* output mixer control */
14385         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14386         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14387         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14388         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14389         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14390
14391         /* Input mixer control */
14392         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14393            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14394         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14395         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14396         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14397         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14399         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14400         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14401         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14402
14403         {
14404                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14405                 .name = "Channel Mode",
14406                 .info = alc_ch_mode_info,
14407                 .get = alc_ch_mode_get,
14408                 .put = alc_ch_mode_put,
14409                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
14410         },
14411         { } /* end */
14412 };
14413
14414 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
14415         /* output mixer control */
14416         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14417         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14418         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14419
14420         { } /* end */
14421 };
14422
14423 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
14424         /* output mixer control */
14425         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14426         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14427         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14428         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14429         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14430
14431         /* Input mixer control */
14432         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14433            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14434         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14435         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14436         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14437         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14438         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14439         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14440         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14441         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14442
14443         {
14444                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14445                 .name = "Channel Mode",
14446                 .info = alc_ch_mode_info,
14447                 .get = alc_ch_mode_get,
14448                 .put = alc_ch_mode_put,
14449                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
14450         },
14451         { } /* end */
14452 };
14453
14454 static struct snd_kcontrol_new alc861_asus_mixer[] = {
14455         /* output mixer control */
14456         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14457         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14458         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14459         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14460         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14461
14462         /* Input mixer control */
14463         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14464         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14465         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14466         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14467         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14468         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14469         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14470         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14471         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14472         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
14473
14474         {
14475                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14476                 .name = "Channel Mode",
14477                 .info = alc_ch_mode_info,
14478                 .get = alc_ch_mode_get,
14479                 .put = alc_ch_mode_put,
14480                 .private_value = ARRAY_SIZE(alc861_asus_modes),
14481         },
14482         { }
14483 };
14484
14485 /* additional mixer */
14486 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
14487         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14488         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14489         { }
14490 };
14491
14492 /*
14493  * generic initialization of ADC, input mixers and output mixers
14494  */
14495 static struct hda_verb alc861_base_init_verbs[] = {
14496         /*
14497          * Unmute ADC0 and set the default input to mic-in
14498          */
14499         /* port-A for surround (rear panel) */
14500         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14501         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14502         /* port-B for mic-in (rear panel) with vref */
14503         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14504         /* port-C for line-in (rear panel) */
14505         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14506         /* port-D for Front */
14507         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14508         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14509         /* port-E for HP out (front panel) */
14510         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14511         /* route front PCM to HP */
14512         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14513         /* port-F for mic-in (front panel) with vref */
14514         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14515         /* port-G for CLFE (rear panel) */
14516         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14517         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14518         /* port-H for side (rear panel) */
14519         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14520         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14521         /* CD-in */
14522         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14523         /* route front mic to ADC1*/
14524         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14525         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14526
14527         /* Unmute DAC0~3 & spdif out*/
14528         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14529         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14530         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14531         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14532         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14533
14534         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14535         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14536         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14537         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14538         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14539
14540         /* Unmute Stereo Mixer 15 */
14541         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14542         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14543         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14544         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14545
14546         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14547         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14548         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14549         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14550         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14551         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14552         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14553         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14554         /* hp used DAC 3 (Front) */
14555         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14556         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14557
14558         { }
14559 };
14560
14561 static struct hda_verb alc861_threestack_init_verbs[] = {
14562         /*
14563          * Unmute ADC0 and set the default input to mic-in
14564          */
14565         /* port-A for surround (rear panel) */
14566         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14567         /* port-B for mic-in (rear panel) with vref */
14568         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14569         /* port-C for line-in (rear panel) */
14570         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14571         /* port-D for Front */
14572         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14573         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14574         /* port-E for HP out (front panel) */
14575         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14576         /* route front PCM to HP */
14577         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14578         /* port-F for mic-in (front panel) with vref */
14579         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14580         /* port-G for CLFE (rear panel) */
14581         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14582         /* port-H for side (rear panel) */
14583         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14584         /* CD-in */
14585         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14586         /* route front mic to ADC1*/
14587         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14588         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14589         /* Unmute DAC0~3 & spdif out*/
14590         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14591         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14592         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14593         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14594         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14595
14596         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14597         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14598         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14599         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14600         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14601
14602         /* Unmute Stereo Mixer 15 */
14603         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14604         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14605         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14606         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14607
14608         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14609         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14610         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14611         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14612         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14613         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14614         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14615         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14616         /* hp used DAC 3 (Front) */
14617         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14618         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14619         { }
14620 };
14621
14622 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14623         /*
14624          * Unmute ADC0 and set the default input to mic-in
14625          */
14626         /* port-A for surround (rear panel) */
14627         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14628         /* port-B for mic-in (rear panel) with vref */
14629         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14630         /* port-C for line-in (rear panel) */
14631         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14632         /* port-D for Front */
14633         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14634         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14635         /* port-E for HP out (front panel) */
14636         /* this has to be set to VREF80 */
14637         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14638         /* route front PCM to HP */
14639         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14640         /* port-F for mic-in (front panel) with vref */
14641         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14642         /* port-G for CLFE (rear panel) */
14643         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14644         /* port-H for side (rear panel) */
14645         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14646         /* CD-in */
14647         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14648         /* route front mic to ADC1*/
14649         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14650         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14651         /* Unmute DAC0~3 & spdif out*/
14652         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14653         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14654         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14655         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14656         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14657
14658         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14659         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14660         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14661         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14662         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14663
14664         /* Unmute Stereo Mixer 15 */
14665         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14666         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14667         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14668         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14669
14670         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14671         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14672         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14673         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14674         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14675         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14676         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14677         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14678         /* hp used DAC 3 (Front) */
14679         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14680         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14681         { }
14682 };
14683
14684 static struct hda_verb alc861_asus_init_verbs[] = {
14685         /*
14686          * Unmute ADC0 and set the default input to mic-in
14687          */
14688         /* port-A for surround (rear panel)
14689          * according to codec#0 this is the HP jack
14690          */
14691         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14692         /* route front PCM to HP */
14693         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14694         /* port-B for mic-in (rear panel) with vref */
14695         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14696         /* port-C for line-in (rear panel) */
14697         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14698         /* port-D for Front */
14699         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14700         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14701         /* port-E for HP out (front panel) */
14702         /* this has to be set to VREF80 */
14703         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14704         /* route front PCM to HP */
14705         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14706         /* port-F for mic-in (front panel) with vref */
14707         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14708         /* port-G for CLFE (rear panel) */
14709         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14710         /* port-H for side (rear panel) */
14711         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14712         /* CD-in */
14713         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14714         /* route front mic to ADC1*/
14715         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14716         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14717         /* Unmute DAC0~3 & spdif out*/
14718         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14719         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14720         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14721         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14722         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14723         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14724         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14725         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14726         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14727         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14728
14729         /* Unmute Stereo Mixer 15 */
14730         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14732         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14733         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14734
14735         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14736         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14737         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14738         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14739         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14740         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14741         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14742         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14743         /* hp used DAC 3 (Front) */
14744         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14745         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14746         { }
14747 };
14748
14749 /* additional init verbs for ASUS laptops */
14750 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14751         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14752         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14753         { }
14754 };
14755
14756 /*
14757  * generic initialization of ADC, input mixers and output mixers
14758  */
14759 static struct hda_verb alc861_auto_init_verbs[] = {
14760         /*
14761          * Unmute ADC0 and set the default input to mic-in
14762          */
14763         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14764         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14765
14766         /* Unmute DAC0~3 & spdif out*/
14767         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14768         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14769         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14770         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14771         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14772
14773         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14774         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14775         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14776         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14777         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14778
14779         /* Unmute Stereo Mixer 15 */
14780         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14781         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14782         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14783         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14784
14785         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14786         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14787         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14788         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14789         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14790         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14791         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14792         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14793
14794         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14795         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14796         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14797         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14798         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14799         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14800         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14801         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14802
14803         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14804
14805         { }
14806 };
14807
14808 static struct hda_verb alc861_toshiba_init_verbs[] = {
14809         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14810
14811         { }
14812 };
14813
14814 /* toggle speaker-output according to the hp-jack state */
14815 static void alc861_toshiba_automute(struct hda_codec *codec)
14816 {
14817         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14818
14819         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14820                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14821         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14822                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14823 }
14824
14825 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14826                                        unsigned int res)
14827 {
14828         if ((res >> 26) == ALC880_HP_EVENT)
14829                 alc861_toshiba_automute(codec);
14830 }
14831
14832 /* pcm configuration: identical with ALC880 */
14833 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14834 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14835 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14836 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14837
14838
14839 #define ALC861_DIGOUT_NID       0x07
14840
14841 static struct hda_channel_mode alc861_8ch_modes[1] = {
14842         { 8, NULL }
14843 };
14844
14845 static hda_nid_t alc861_dac_nids[4] = {
14846         /* front, surround, clfe, side */
14847         0x03, 0x06, 0x05, 0x04
14848 };
14849
14850 static hda_nid_t alc660_dac_nids[3] = {
14851         /* front, clfe, surround */
14852         0x03, 0x05, 0x06
14853 };
14854
14855 static hda_nid_t alc861_adc_nids[1] = {
14856         /* ADC0-2 */
14857         0x08,
14858 };
14859
14860 static struct hda_input_mux alc861_capture_source = {
14861         .num_items = 5,
14862         .items = {
14863                 { "Mic", 0x0 },
14864                 { "Front Mic", 0x3 },
14865                 { "Line", 0x1 },
14866                 { "CD", 0x4 },
14867                 { "Mixer", 0x5 },
14868         },
14869 };
14870
14871 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14872 {
14873         struct alc_spec *spec = codec->spec;
14874         hda_nid_t mix, srcs[5];
14875         int i, j, num;
14876
14877         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14878                 return 0;
14879         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14880         if (num < 0)
14881                 return 0;
14882         for (i = 0; i < num; i++) {
14883                 unsigned int type;
14884                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14885                 if (type != AC_WID_AUD_OUT)
14886                         continue;
14887                 for (j = 0; j < spec->multiout.num_dacs; j++)
14888                         if (spec->multiout.dac_nids[j] == srcs[i])
14889                                 break;
14890                 if (j >= spec->multiout.num_dacs)
14891                         return srcs[i];
14892         }
14893         return 0;
14894 }
14895
14896 /* fill in the dac_nids table from the parsed pin configuration */
14897 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14898                                      const struct auto_pin_cfg *cfg)
14899 {
14900         struct alc_spec *spec = codec->spec;
14901         int i;
14902         hda_nid_t nid, dac;
14903
14904         spec->multiout.dac_nids = spec->private_dac_nids;
14905         for (i = 0; i < cfg->line_outs; i++) {
14906                 nid = cfg->line_out_pins[i];
14907                 dac = alc861_look_for_dac(codec, nid);
14908                 if (!dac)
14909                         continue;
14910                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14911         }
14912         return 0;
14913 }
14914
14915 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14916                                 hda_nid_t nid, unsigned int chs)
14917 {
14918         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14919                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14920 }
14921
14922 /* add playback controls from the parsed DAC table */
14923 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14924                                              const struct auto_pin_cfg *cfg)
14925 {
14926         struct alc_spec *spec = codec->spec;
14927         static const char *chname[4] = {
14928                 "Front", "Surround", NULL /*CLFE*/, "Side"
14929         };
14930         hda_nid_t nid;
14931         int i, err;
14932
14933         if (cfg->line_outs == 1) {
14934                 const char *pfx = NULL;
14935                 if (!cfg->hp_outs)
14936                         pfx = "Master";
14937                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14938                         pfx = "Speaker";
14939                 if (pfx) {
14940                         nid = spec->multiout.dac_nids[0];
14941                         return alc861_create_out_sw(codec, pfx, nid, 3);
14942                 }
14943         }
14944
14945         for (i = 0; i < cfg->line_outs; i++) {
14946                 nid = spec->multiout.dac_nids[i];
14947                 if (!nid)
14948                         continue;
14949                 if (i == 2) {
14950                         /* Center/LFE */
14951                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14952                         if (err < 0)
14953                                 return err;
14954                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14955                         if (err < 0)
14956                                 return err;
14957                 } else {
14958                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14959                         if (err < 0)
14960                                 return err;
14961                 }
14962         }
14963         return 0;
14964 }
14965
14966 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14967 {
14968         struct alc_spec *spec = codec->spec;
14969         int err;
14970         hda_nid_t nid;
14971
14972         if (!pin)
14973                 return 0;
14974
14975         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14976                 nid = alc861_look_for_dac(codec, pin);
14977                 if (nid) {
14978                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14979                         if (err < 0)
14980                                 return err;
14981                         spec->multiout.hp_nid = nid;
14982                 }
14983         }
14984         return 0;
14985 }
14986
14987 /* create playback/capture controls for input pins */
14988 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14989                                                 const struct auto_pin_cfg *cfg)
14990 {
14991         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14992 }
14993
14994 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14995                                               hda_nid_t nid,
14996                                               int pin_type, hda_nid_t dac)
14997 {
14998         hda_nid_t mix, srcs[5];
14999         int i, num;
15000
15001         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15002                             pin_type);
15003         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15004                             AMP_OUT_UNMUTE);
15005         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15006                 return;
15007         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15008         if (num < 0)
15009                 return;
15010         for (i = 0; i < num; i++) {
15011                 unsigned int mute;
15012                 if (srcs[i] == dac || srcs[i] == 0x15)
15013                         mute = AMP_IN_UNMUTE(i);
15014                 else
15015                         mute = AMP_IN_MUTE(i);
15016                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15017                                     mute);
15018         }
15019 }
15020
15021 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15022 {
15023         struct alc_spec *spec = codec->spec;
15024         int i;
15025
15026         for (i = 0; i < spec->autocfg.line_outs; i++) {
15027                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15028                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15029                 if (nid)
15030                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15031                                                           spec->multiout.dac_nids[i]);
15032         }
15033 }
15034
15035 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15036 {
15037         struct alc_spec *spec = codec->spec;
15038
15039         if (spec->autocfg.hp_outs)
15040                 alc861_auto_set_output_and_unmute(codec,
15041                                                   spec->autocfg.hp_pins[0],
15042                                                   PIN_HP,
15043                                                   spec->multiout.hp_nid);
15044         if (spec->autocfg.speaker_outs)
15045                 alc861_auto_set_output_and_unmute(codec,
15046                                                   spec->autocfg.speaker_pins[0],
15047                                                   PIN_OUT,
15048                                                   spec->multiout.dac_nids[0]);
15049 }
15050
15051 static void alc861_auto_init_analog_input(struct hda_codec *codec)
15052 {
15053         struct alc_spec *spec = codec->spec;
15054         int i;
15055
15056         for (i = 0; i < AUTO_PIN_LAST; i++) {
15057                 hda_nid_t nid = spec->autocfg.input_pins[i];
15058                 if (nid >= 0x0c && nid <= 0x11)
15059                         alc_set_input_pin(codec, nid, i);
15060         }
15061 }
15062
15063 /* parse the BIOS configuration and set up the alc_spec */
15064 /* return 1 if successful, 0 if the proper config is not found,
15065  * or a negative error code
15066  */
15067 static int alc861_parse_auto_config(struct hda_codec *codec)
15068 {
15069         struct alc_spec *spec = codec->spec;
15070         int err;
15071         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15072
15073         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15074                                            alc861_ignore);
15075         if (err < 0)
15076                 return err;
15077         if (!spec->autocfg.line_outs)
15078                 return 0; /* can't find valid BIOS pin config */
15079
15080         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15081         if (err < 0)
15082                 return err;
15083         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15084         if (err < 0)
15085                 return err;
15086         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15087         if (err < 0)
15088                 return err;
15089         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15090         if (err < 0)
15091                 return err;
15092
15093         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15094
15095         if (spec->autocfg.dig_outs)
15096                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
15097
15098         if (spec->kctls.list)
15099                 add_mixer(spec, spec->kctls.list);
15100
15101         add_verb(spec, alc861_auto_init_verbs);
15102
15103         spec->num_mux_defs = 1;
15104         spec->input_mux = &spec->private_imux[0];
15105
15106         spec->adc_nids = alc861_adc_nids;
15107         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15108         set_capture_mixer(codec);
15109
15110         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15111
15112         return 1;
15113 }
15114
15115 /* additional initialization for auto-configuration model */
15116 static void alc861_auto_init(struct hda_codec *codec)
15117 {
15118         struct alc_spec *spec = codec->spec;
15119         alc861_auto_init_multi_out(codec);
15120         alc861_auto_init_hp_out(codec);
15121         alc861_auto_init_analog_input(codec);
15122         if (spec->unsol_event)
15123                 alc_inithook(codec);
15124 }
15125
15126 #ifdef CONFIG_SND_HDA_POWER_SAVE
15127 static struct hda_amp_list alc861_loopbacks[] = {
15128         { 0x15, HDA_INPUT, 0 },
15129         { 0x15, HDA_INPUT, 1 },
15130         { 0x15, HDA_INPUT, 2 },
15131         { 0x15, HDA_INPUT, 3 },
15132         { } /* end */
15133 };
15134 #endif
15135
15136
15137 /*
15138  * configuration and preset
15139  */
15140 static const char *alc861_models[ALC861_MODEL_LAST] = {
15141         [ALC861_3ST]            = "3stack",
15142         [ALC660_3ST]            = "3stack-660",
15143         [ALC861_3ST_DIG]        = "3stack-dig",
15144         [ALC861_6ST_DIG]        = "6stack-dig",
15145         [ALC861_UNIWILL_M31]    = "uniwill-m31",
15146         [ALC861_TOSHIBA]        = "toshiba",
15147         [ALC861_ASUS]           = "asus",
15148         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
15149         [ALC861_AUTO]           = "auto",
15150 };
15151
15152 static struct snd_pci_quirk alc861_cfg_tbl[] = {
15153         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15154         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15155         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15156         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15157         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15158         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
15159         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
15160         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
15161          *        Any other models that need this preset?
15162          */
15163         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
15164         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
15165         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
15166         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
15167         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
15168         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
15169         /* FIXME: the below seems conflict */
15170         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
15171         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
15172         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
15173         {}
15174 };
15175
15176 static struct alc_config_preset alc861_presets[] = {
15177         [ALC861_3ST] = {
15178                 .mixers = { alc861_3ST_mixer },
15179                 .init_verbs = { alc861_threestack_init_verbs },
15180                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15181                 .dac_nids = alc861_dac_nids,
15182                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15183                 .channel_mode = alc861_threestack_modes,
15184                 .need_dac_fix = 1,
15185                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15186                 .adc_nids = alc861_adc_nids,
15187                 .input_mux = &alc861_capture_source,
15188         },
15189         [ALC861_3ST_DIG] = {
15190                 .mixers = { alc861_base_mixer },
15191                 .init_verbs = { alc861_threestack_init_verbs },
15192                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15193                 .dac_nids = alc861_dac_nids,
15194                 .dig_out_nid = ALC861_DIGOUT_NID,
15195                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15196                 .channel_mode = alc861_threestack_modes,
15197                 .need_dac_fix = 1,
15198                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15199                 .adc_nids = alc861_adc_nids,
15200                 .input_mux = &alc861_capture_source,
15201         },
15202         [ALC861_6ST_DIG] = {
15203                 .mixers = { alc861_base_mixer },
15204                 .init_verbs = { alc861_base_init_verbs },
15205                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15206                 .dac_nids = alc861_dac_nids,
15207                 .dig_out_nid = ALC861_DIGOUT_NID,
15208                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
15209                 .channel_mode = alc861_8ch_modes,
15210                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15211                 .adc_nids = alc861_adc_nids,
15212                 .input_mux = &alc861_capture_source,
15213         },
15214         [ALC660_3ST] = {
15215                 .mixers = { alc861_3ST_mixer },
15216                 .init_verbs = { alc861_threestack_init_verbs },
15217                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
15218                 .dac_nids = alc660_dac_nids,
15219                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15220                 .channel_mode = alc861_threestack_modes,
15221                 .need_dac_fix = 1,
15222                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15223                 .adc_nids = alc861_adc_nids,
15224                 .input_mux = &alc861_capture_source,
15225         },
15226         [ALC861_UNIWILL_M31] = {
15227                 .mixers = { alc861_uniwill_m31_mixer },
15228                 .init_verbs = { alc861_uniwill_m31_init_verbs },
15229                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15230                 .dac_nids = alc861_dac_nids,
15231                 .dig_out_nid = ALC861_DIGOUT_NID,
15232                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
15233                 .channel_mode = alc861_uniwill_m31_modes,
15234                 .need_dac_fix = 1,
15235                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15236                 .adc_nids = alc861_adc_nids,
15237                 .input_mux = &alc861_capture_source,
15238         },
15239         [ALC861_TOSHIBA] = {
15240                 .mixers = { alc861_toshiba_mixer },
15241                 .init_verbs = { alc861_base_init_verbs,
15242                                 alc861_toshiba_init_verbs },
15243                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15244                 .dac_nids = alc861_dac_nids,
15245                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15246                 .channel_mode = alc883_3ST_2ch_modes,
15247                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15248                 .adc_nids = alc861_adc_nids,
15249                 .input_mux = &alc861_capture_source,
15250                 .unsol_event = alc861_toshiba_unsol_event,
15251                 .init_hook = alc861_toshiba_automute,
15252         },
15253         [ALC861_ASUS] = {
15254                 .mixers = { alc861_asus_mixer },
15255                 .init_verbs = { alc861_asus_init_verbs },
15256                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15257                 .dac_nids = alc861_dac_nids,
15258                 .dig_out_nid = ALC861_DIGOUT_NID,
15259                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
15260                 .channel_mode = alc861_asus_modes,
15261                 .need_dac_fix = 1,
15262                 .hp_nid = 0x06,
15263                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15264                 .adc_nids = alc861_adc_nids,
15265                 .input_mux = &alc861_capture_source,
15266         },
15267         [ALC861_ASUS_LAPTOP] = {
15268                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
15269                 .init_verbs = { alc861_asus_init_verbs,
15270                                 alc861_asus_laptop_init_verbs },
15271                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15272                 .dac_nids = alc861_dac_nids,
15273                 .dig_out_nid = ALC861_DIGOUT_NID,
15274                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15275                 .channel_mode = alc883_3ST_2ch_modes,
15276                 .need_dac_fix = 1,
15277                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15278                 .adc_nids = alc861_adc_nids,
15279                 .input_mux = &alc861_capture_source,
15280         },
15281 };
15282
15283 /* Pin config fixes */
15284 enum {
15285         PINFIX_FSC_AMILO_PI1505,
15286 };
15287
15288 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
15289         { 0x0b, 0x0221101f }, /* HP */
15290         { 0x0f, 0x90170310 }, /* speaker */
15291         { }
15292 };
15293
15294 static const struct alc_fixup alc861_fixups[] = {
15295         [PINFIX_FSC_AMILO_PI1505] = {
15296                 .pins = alc861_fsc_amilo_pi1505_pinfix
15297         },
15298 };
15299
15300 static struct snd_pci_quirk alc861_fixup_tbl[] = {
15301         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
15302         {}
15303 };
15304
15305 static int patch_alc861(struct hda_codec *codec)
15306 {
15307         struct alc_spec *spec;
15308         int board_config;
15309         int err;
15310
15311         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15312         if (spec == NULL)
15313                 return -ENOMEM;
15314
15315         codec->spec = spec;
15316
15317         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
15318                                                   alc861_models,
15319                                                   alc861_cfg_tbl);
15320
15321         if (board_config < 0) {
15322                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15323                        codec->chip_name);
15324                 board_config = ALC861_AUTO;
15325         }
15326
15327         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
15328
15329         if (board_config == ALC861_AUTO) {
15330                 /* automatic parse from the BIOS config */
15331                 err = alc861_parse_auto_config(codec);
15332                 if (err < 0) {
15333                         alc_free(codec);
15334                         return err;
15335                 } else if (!err) {
15336                         printk(KERN_INFO
15337                                "hda_codec: Cannot set up configuration "
15338                                "from BIOS.  Using base mode...\n");
15339                    board_config = ALC861_3ST_DIG;
15340                 }
15341         }
15342
15343         err = snd_hda_attach_beep_device(codec, 0x23);
15344         if (err < 0) {
15345                 alc_free(codec);
15346                 return err;
15347         }
15348
15349         if (board_config != ALC861_AUTO)
15350                 setup_preset(codec, &alc861_presets[board_config]);
15351
15352         spec->stream_analog_playback = &alc861_pcm_analog_playback;
15353         spec->stream_analog_capture = &alc861_pcm_analog_capture;
15354
15355         spec->stream_digital_playback = &alc861_pcm_digital_playback;
15356         spec->stream_digital_capture = &alc861_pcm_digital_capture;
15357
15358         if (!spec->cap_mixer)
15359                 set_capture_mixer(codec);
15360         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
15361
15362         spec->vmaster_nid = 0x03;
15363
15364         codec->patch_ops = alc_patch_ops;
15365         if (board_config == ALC861_AUTO) {
15366                 spec->init_hook = alc861_auto_init;
15367 #ifdef CONFIG_SND_HDA_POWER_SAVE
15368                 spec->power_hook = alc_power_eapd;
15369 #endif
15370         }
15371 #ifdef CONFIG_SND_HDA_POWER_SAVE
15372         if (!spec->loopback.amplist)
15373                 spec->loopback.amplist = alc861_loopbacks;
15374 #endif
15375
15376         return 0;
15377 }
15378
15379 /*
15380  * ALC861-VD support
15381  *
15382  * Based on ALC882
15383  *
15384  * In addition, an independent DAC
15385  */
15386 #define ALC861VD_DIGOUT_NID     0x06
15387
15388 static hda_nid_t alc861vd_dac_nids[4] = {
15389         /* front, surr, clfe, side surr */
15390         0x02, 0x03, 0x04, 0x05
15391 };
15392
15393 /* dac_nids for ALC660vd are in a different order - according to
15394  * Realtek's driver.
15395  * This should probably result in a different mixer for 6stack models
15396  * of ALC660vd codecs, but for now there is only 3stack mixer
15397  * - and it is the same as in 861vd.
15398  * adc_nids in ALC660vd are (is) the same as in 861vd
15399  */
15400 static hda_nid_t alc660vd_dac_nids[3] = {
15401         /* front, rear, clfe, rear_surr */
15402         0x02, 0x04, 0x03
15403 };
15404
15405 static hda_nid_t alc861vd_adc_nids[1] = {
15406         /* ADC0 */
15407         0x09,
15408 };
15409
15410 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
15411
15412 /* input MUX */
15413 /* FIXME: should be a matrix-type input source selection */
15414 static struct hda_input_mux alc861vd_capture_source = {
15415         .num_items = 4,
15416         .items = {
15417                 { "Mic", 0x0 },
15418                 { "Front Mic", 0x1 },
15419                 { "Line", 0x2 },
15420                 { "CD", 0x4 },
15421         },
15422 };
15423
15424 static struct hda_input_mux alc861vd_dallas_capture_source = {
15425         .num_items = 2,
15426         .items = {
15427                 { "Ext Mic", 0x0 },
15428                 { "Int Mic", 0x1 },
15429         },
15430 };
15431
15432 static struct hda_input_mux alc861vd_hp_capture_source = {
15433         .num_items = 2,
15434         .items = {
15435                 { "Front Mic", 0x0 },
15436                 { "ATAPI Mic", 0x1 },
15437         },
15438 };
15439
15440 /*
15441  * 2ch mode
15442  */
15443 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
15444         { 2, NULL }
15445 };
15446
15447 /*
15448  * 6ch mode
15449  */
15450 static struct hda_verb alc861vd_6stack_ch6_init[] = {
15451         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15452         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15453         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15454         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15455         { } /* end */
15456 };
15457
15458 /*
15459  * 8ch mode
15460  */
15461 static struct hda_verb alc861vd_6stack_ch8_init[] = {
15462         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15463         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15464         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15465         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15466         { } /* end */
15467 };
15468
15469 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
15470         { 6, alc861vd_6stack_ch6_init },
15471         { 8, alc861vd_6stack_ch8_init },
15472 };
15473
15474 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
15475         {
15476                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15477                 .name = "Channel Mode",
15478                 .info = alc_ch_mode_info,
15479                 .get = alc_ch_mode_get,
15480                 .put = alc_ch_mode_put,
15481         },
15482         { } /* end */
15483 };
15484
15485 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15486  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15487  */
15488 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
15489         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15490         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15491
15492         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15493         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
15494
15495         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
15496                                 HDA_OUTPUT),
15497         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
15498                                 HDA_OUTPUT),
15499         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
15500         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
15501
15502         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15503         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15504
15505         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15506
15507         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15508         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15509         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15510
15511         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15512         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15513         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15514
15515         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15516         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15517
15518         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15519         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15520
15521         { } /* end */
15522 };
15523
15524 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15525         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15526         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15527
15528         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15529
15530         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15531         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15532         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15533
15534         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15535         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15536         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15537
15538         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15539         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15540
15541         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15542         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15543
15544         { } /* end */
15545 };
15546
15547 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15548         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15549         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15550         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15551
15552         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15553
15554         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15555         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15556         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15557
15558         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15559         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15560         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15561
15562         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15563         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15564
15565         { } /* end */
15566 };
15567
15568 /* Pin assignment: Speaker=0x14, HP = 0x15,
15569  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15570  */
15571 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15572         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15573         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15574         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15575         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15576         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15577         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15578         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15579         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15580         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15581         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15582         { } /* end */
15583 };
15584
15585 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15586  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15587  */
15588 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15589         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15590         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15591         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15592         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15593         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15594         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15595         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15596         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15597
15598         { } /* end */
15599 };
15600
15601 /*
15602  * generic initialization of ADC, input mixers and output mixers
15603  */
15604 static struct hda_verb alc861vd_volume_init_verbs[] = {
15605         /*
15606          * Unmute ADC0 and set the default input to mic-in
15607          */
15608         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15609         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15610
15611         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15612          * the analog-loopback mixer widget
15613          */
15614         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15615         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15616         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15617         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15618         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15619         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15620
15621         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15623         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15624         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15625         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15626
15627         /*
15628          * Set up output mixers (0x02 - 0x05)
15629          */
15630         /* set vol=0 to output mixers */
15631         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15632         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15633         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15634         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15635
15636         /* set up input amps for analog loopback */
15637         /* Amp Indices: DAC = 0, mixer = 1 */
15638         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15639         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15640         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15641         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15642         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15643         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15644         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15645         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15646
15647         { }
15648 };
15649
15650 /*
15651  * 3-stack pin configuration:
15652  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15653  */
15654 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15655         /*
15656          * Set pin mode and muting
15657          */
15658         /* set front pin widgets 0x14 for output */
15659         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15660         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15661         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15662
15663         /* Mic (rear) pin: input vref at 80% */
15664         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15665         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15666         /* Front Mic pin: input vref at 80% */
15667         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15668         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15669         /* Line In pin: input */
15670         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15671         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15672         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15673         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15674         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15675         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15676         /* CD pin widget for input */
15677         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15678
15679         { }
15680 };
15681
15682 /*
15683  * 6-stack pin configuration:
15684  */
15685 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15686         /*
15687          * Set pin mode and muting
15688          */
15689         /* set front pin widgets 0x14 for output */
15690         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15691         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15692         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15693
15694         /* Rear Pin: output 1 (0x0d) */
15695         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15696         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15697         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15698         /* CLFE Pin: output 2 (0x0e) */
15699         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15700         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15701         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15702         /* Side Pin: output 3 (0x0f) */
15703         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15704         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15705         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15706
15707         /* Mic (rear) pin: input vref at 80% */
15708         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15709         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15710         /* Front Mic pin: input vref at 80% */
15711         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15712         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15713         /* Line In pin: input */
15714         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15715         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15716         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15717         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15718         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15719         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15720         /* CD pin widget for input */
15721         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15722
15723         { }
15724 };
15725
15726 static struct hda_verb alc861vd_eapd_verbs[] = {
15727         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15728         { }
15729 };
15730
15731 static struct hda_verb alc660vd_eapd_verbs[] = {
15732         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15733         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15734         { }
15735 };
15736
15737 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15738         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15739         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15740         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15741         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15742         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15743         {}
15744 };
15745
15746 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15747 {
15748         unsigned int present;
15749         unsigned char bits;
15750
15751         present = snd_hda_jack_detect(codec, 0x18);
15752         bits = present ? HDA_AMP_MUTE : 0;
15753
15754         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15755                                  HDA_AMP_MUTE, bits);
15756 }
15757
15758 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15759 {
15760         struct alc_spec *spec = codec->spec;
15761         spec->autocfg.hp_pins[0] = 0x1b;
15762         spec->autocfg.speaker_pins[0] = 0x14;
15763 }
15764
15765 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15766 {
15767         alc_automute_amp(codec);
15768         alc861vd_lenovo_mic_automute(codec);
15769 }
15770
15771 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15772                                         unsigned int res)
15773 {
15774         switch (res >> 26) {
15775         case ALC880_MIC_EVENT:
15776                 alc861vd_lenovo_mic_automute(codec);
15777                 break;
15778         default:
15779                 alc_automute_amp_unsol_event(codec, res);
15780                 break;
15781         }
15782 }
15783
15784 static struct hda_verb alc861vd_dallas_verbs[] = {
15785         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15786         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15787         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15788         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15789
15790         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15791         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15792         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15793         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15794         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15795         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15796         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15797         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15798
15799         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15800         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15801         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15802         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15803         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15804         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15805         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15806         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15807
15808         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15809         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15810         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15811         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15812         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15813         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15814         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15815         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15816
15817         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15818         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15819         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15820         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15821
15822         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15823         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15824         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15825
15826         { } /* end */
15827 };
15828
15829 /* toggle speaker-output according to the hp-jack state */
15830 static void alc861vd_dallas_setup(struct hda_codec *codec)
15831 {
15832         struct alc_spec *spec = codec->spec;
15833
15834         spec->autocfg.hp_pins[0] = 0x15;
15835         spec->autocfg.speaker_pins[0] = 0x14;
15836 }
15837
15838 #ifdef CONFIG_SND_HDA_POWER_SAVE
15839 #define alc861vd_loopbacks      alc880_loopbacks
15840 #endif
15841
15842 /* pcm configuration: identical with ALC880 */
15843 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15844 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15845 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15846 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15847
15848 /*
15849  * configuration and preset
15850  */
15851 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15852         [ALC660VD_3ST]          = "3stack-660",
15853         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15854         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15855         [ALC861VD_3ST]          = "3stack",
15856         [ALC861VD_3ST_DIG]      = "3stack-digout",
15857         [ALC861VD_6ST_DIG]      = "6stack-digout",
15858         [ALC861VD_LENOVO]       = "lenovo",
15859         [ALC861VD_DALLAS]       = "dallas",
15860         [ALC861VD_HP]           = "hp",
15861         [ALC861VD_AUTO]         = "auto",
15862 };
15863
15864 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15865         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15866         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15867         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15868         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15869         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15870         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15871         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15872         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15873         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15874         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15875         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15876         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15877         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15878         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15879         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15880         {}
15881 };
15882
15883 static struct alc_config_preset alc861vd_presets[] = {
15884         [ALC660VD_3ST] = {
15885                 .mixers = { alc861vd_3st_mixer },
15886                 .init_verbs = { alc861vd_volume_init_verbs,
15887                                  alc861vd_3stack_init_verbs },
15888                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15889                 .dac_nids = alc660vd_dac_nids,
15890                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15891                 .channel_mode = alc861vd_3stack_2ch_modes,
15892                 .input_mux = &alc861vd_capture_source,
15893         },
15894         [ALC660VD_3ST_DIG] = {
15895                 .mixers = { alc861vd_3st_mixer },
15896                 .init_verbs = { alc861vd_volume_init_verbs,
15897                                  alc861vd_3stack_init_verbs },
15898                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15899                 .dac_nids = alc660vd_dac_nids,
15900                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15901                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15902                 .channel_mode = alc861vd_3stack_2ch_modes,
15903                 .input_mux = &alc861vd_capture_source,
15904         },
15905         [ALC861VD_3ST] = {
15906                 .mixers = { alc861vd_3st_mixer },
15907                 .init_verbs = { alc861vd_volume_init_verbs,
15908                                  alc861vd_3stack_init_verbs },
15909                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15910                 .dac_nids = alc861vd_dac_nids,
15911                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15912                 .channel_mode = alc861vd_3stack_2ch_modes,
15913                 .input_mux = &alc861vd_capture_source,
15914         },
15915         [ALC861VD_3ST_DIG] = {
15916                 .mixers = { alc861vd_3st_mixer },
15917                 .init_verbs = { alc861vd_volume_init_verbs,
15918                                  alc861vd_3stack_init_verbs },
15919                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15920                 .dac_nids = alc861vd_dac_nids,
15921                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15922                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15923                 .channel_mode = alc861vd_3stack_2ch_modes,
15924                 .input_mux = &alc861vd_capture_source,
15925         },
15926         [ALC861VD_6ST_DIG] = {
15927                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15928                 .init_verbs = { alc861vd_volume_init_verbs,
15929                                 alc861vd_6stack_init_verbs },
15930                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15931                 .dac_nids = alc861vd_dac_nids,
15932                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15933                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15934                 .channel_mode = alc861vd_6stack_modes,
15935                 .input_mux = &alc861vd_capture_source,
15936         },
15937         [ALC861VD_LENOVO] = {
15938                 .mixers = { alc861vd_lenovo_mixer },
15939                 .init_verbs = { alc861vd_volume_init_verbs,
15940                                 alc861vd_3stack_init_verbs,
15941                                 alc861vd_eapd_verbs,
15942                                 alc861vd_lenovo_unsol_verbs },
15943                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15944                 .dac_nids = alc660vd_dac_nids,
15945                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15946                 .channel_mode = alc861vd_3stack_2ch_modes,
15947                 .input_mux = &alc861vd_capture_source,
15948                 .unsol_event = alc861vd_lenovo_unsol_event,
15949                 .setup = alc861vd_lenovo_setup,
15950                 .init_hook = alc861vd_lenovo_init_hook,
15951         },
15952         [ALC861VD_DALLAS] = {
15953                 .mixers = { alc861vd_dallas_mixer },
15954                 .init_verbs = { alc861vd_dallas_verbs },
15955                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15956                 .dac_nids = alc861vd_dac_nids,
15957                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15958                 .channel_mode = alc861vd_3stack_2ch_modes,
15959                 .input_mux = &alc861vd_dallas_capture_source,
15960                 .unsol_event = alc_automute_amp_unsol_event,
15961                 .setup = alc861vd_dallas_setup,
15962                 .init_hook = alc_automute_amp,
15963         },
15964         [ALC861VD_HP] = {
15965                 .mixers = { alc861vd_hp_mixer },
15966                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15967                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15968                 .dac_nids = alc861vd_dac_nids,
15969                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15970                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15971                 .channel_mode = alc861vd_3stack_2ch_modes,
15972                 .input_mux = &alc861vd_hp_capture_source,
15973                 .unsol_event = alc_automute_amp_unsol_event,
15974                 .setup = alc861vd_dallas_setup,
15975                 .init_hook = alc_automute_amp,
15976         },
15977         [ALC660VD_ASUS_V1S] = {
15978                 .mixers = { alc861vd_lenovo_mixer },
15979                 .init_verbs = { alc861vd_volume_init_verbs,
15980                                 alc861vd_3stack_init_verbs,
15981                                 alc861vd_eapd_verbs,
15982                                 alc861vd_lenovo_unsol_verbs },
15983                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15984                 .dac_nids = alc660vd_dac_nids,
15985                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15986                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15987                 .channel_mode = alc861vd_3stack_2ch_modes,
15988                 .input_mux = &alc861vd_capture_source,
15989                 .unsol_event = alc861vd_lenovo_unsol_event,
15990                 .setup = alc861vd_lenovo_setup,
15991                 .init_hook = alc861vd_lenovo_init_hook,
15992         },
15993 };
15994
15995 /*
15996  * BIOS auto configuration
15997  */
15998 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15999                                                 const struct auto_pin_cfg *cfg)
16000 {
16001         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16002 }
16003
16004
16005 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16006                                 hda_nid_t nid, int pin_type, int dac_idx)
16007 {
16008         alc_set_pin_output(codec, nid, pin_type);
16009 }
16010
16011 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16012 {
16013         struct alc_spec *spec = codec->spec;
16014         int i;
16015
16016         for (i = 0; i <= HDA_SIDE; i++) {
16017                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16018                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16019                 if (nid)
16020                         alc861vd_auto_set_output_and_unmute(codec, nid,
16021                                                             pin_type, i);
16022         }
16023 }
16024
16025
16026 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16027 {
16028         struct alc_spec *spec = codec->spec;
16029         hda_nid_t pin;
16030
16031         pin = spec->autocfg.hp_pins[0];
16032         if (pin) /* connect to front and use dac 0 */
16033                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16034         pin = spec->autocfg.speaker_pins[0];
16035         if (pin)
16036                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16037 }
16038
16039 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16040
16041 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16042 {
16043         struct alc_spec *spec = codec->spec;
16044         int i;
16045
16046         for (i = 0; i < AUTO_PIN_LAST; i++) {
16047                 hda_nid_t nid = spec->autocfg.input_pins[i];
16048                 if (alc_is_input_pin(codec, nid)) {
16049                         alc_set_input_pin(codec, nid, i);
16050                         if (nid != ALC861VD_PIN_CD_NID &&
16051                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16052                                 snd_hda_codec_write(codec, nid, 0,
16053                                                 AC_VERB_SET_AMP_GAIN_MUTE,
16054                                                 AMP_OUT_MUTE);
16055                 }
16056         }
16057 }
16058
16059 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
16060
16061 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
16062 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
16063
16064 /* add playback controls from the parsed DAC table */
16065 /* Based on ALC880 version. But ALC861VD has separate,
16066  * different NIDs for mute/unmute switch and volume control */
16067 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16068                                              const struct auto_pin_cfg *cfg)
16069 {
16070         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16071         hda_nid_t nid_v, nid_s;
16072         int i, err;
16073
16074         for (i = 0; i < cfg->line_outs; i++) {
16075                 if (!spec->multiout.dac_nids[i])
16076                         continue;
16077                 nid_v = alc861vd_idx_to_mixer_vol(
16078                                 alc880_dac_to_idx(
16079                                         spec->multiout.dac_nids[i]));
16080                 nid_s = alc861vd_idx_to_mixer_switch(
16081                                 alc880_dac_to_idx(
16082                                         spec->multiout.dac_nids[i]));
16083
16084                 if (i == 2) {
16085                         /* Center/LFE */
16086                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16087                                               "Center",
16088                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16089                                                               HDA_OUTPUT));
16090                         if (err < 0)
16091                                 return err;
16092                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16093                                               "LFE",
16094                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16095                                                               HDA_OUTPUT));
16096                         if (err < 0)
16097                                 return err;
16098                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16099                                              "Center",
16100                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16101                                                               HDA_INPUT));
16102                         if (err < 0)
16103                                 return err;
16104                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16105                                              "LFE",
16106                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16107                                                               HDA_INPUT));
16108                         if (err < 0)
16109                                 return err;
16110                 } else {
16111                         const char *pfx;
16112                         if (cfg->line_outs == 1 &&
16113                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16114                                 if (!cfg->hp_pins)
16115                                         pfx = "Speaker";
16116                                 else
16117                                         pfx = "PCM";
16118                         } else
16119                                 pfx = chname[i];
16120                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16121                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16122                                                               HDA_OUTPUT));
16123                         if (err < 0)
16124                                 return err;
16125                         if (cfg->line_outs == 1 &&
16126                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16127                                 pfx = "Speaker";
16128                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16129                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16130                                                               HDA_INPUT));
16131                         if (err < 0)
16132                                 return err;
16133                 }
16134         }
16135         return 0;
16136 }
16137
16138 /* add playback controls for speaker and HP outputs */
16139 /* Based on ALC880 version. But ALC861VD has separate,
16140  * different NIDs for mute/unmute switch and volume control */
16141 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16142                                         hda_nid_t pin, const char *pfx)
16143 {
16144         hda_nid_t nid_v, nid_s;
16145         int err;
16146
16147         if (!pin)
16148                 return 0;
16149
16150         if (alc880_is_fixed_pin(pin)) {
16151                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16152                 /* specify the DAC as the extra output */
16153                 if (!spec->multiout.hp_nid)
16154                         spec->multiout.hp_nid = nid_v;
16155                 else
16156                         spec->multiout.extra_out_nid[0] = nid_v;
16157                 /* control HP volume/switch on the output mixer amp */
16158                 nid_v = alc861vd_idx_to_mixer_vol(
16159                                 alc880_fixed_pin_idx(pin));
16160                 nid_s = alc861vd_idx_to_mixer_switch(
16161                                 alc880_fixed_pin_idx(pin));
16162
16163                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16164                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
16165                 if (err < 0)
16166                         return err;
16167                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16168                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
16169                 if (err < 0)
16170                         return err;
16171         } else if (alc880_is_multi_pin(pin)) {
16172                 /* set manual connection */
16173                 /* we have only a switch on HP-out PIN */
16174                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
16175                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16176                 if (err < 0)
16177                         return err;
16178         }
16179         return 0;
16180 }
16181
16182 /* parse the BIOS configuration and set up the alc_spec
16183  * return 1 if successful, 0 if the proper config is not found,
16184  * or a negative error code
16185  * Based on ALC880 version - had to change it to override
16186  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
16187 static int alc861vd_parse_auto_config(struct hda_codec *codec)
16188 {
16189         struct alc_spec *spec = codec->spec;
16190         int err;
16191         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
16192
16193         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16194                                            alc861vd_ignore);
16195         if (err < 0)
16196                 return err;
16197         if (!spec->autocfg.line_outs)
16198                 return 0; /* can't find valid BIOS pin config */
16199
16200         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16201         if (err < 0)
16202                 return err;
16203         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
16204         if (err < 0)
16205                 return err;
16206         err = alc861vd_auto_create_extra_out(spec,
16207                                              spec->autocfg.speaker_pins[0],
16208                                              "Speaker");
16209         if (err < 0)
16210                 return err;
16211         err = alc861vd_auto_create_extra_out(spec,
16212                                              spec->autocfg.hp_pins[0],
16213                                              "Headphone");
16214         if (err < 0)
16215                 return err;
16216         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
16217         if (err < 0)
16218                 return err;
16219
16220         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16221
16222         if (spec->autocfg.dig_outs)
16223                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
16224
16225         if (spec->kctls.list)
16226                 add_mixer(spec, spec->kctls.list);
16227
16228         add_verb(spec, alc861vd_volume_init_verbs);
16229
16230         spec->num_mux_defs = 1;
16231         spec->input_mux = &spec->private_imux[0];
16232
16233         err = alc_auto_add_mic_boost(codec);
16234         if (err < 0)
16235                 return err;
16236
16237         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
16238
16239         return 1;
16240 }
16241
16242 /* additional initialization for auto-configuration model */
16243 static void alc861vd_auto_init(struct hda_codec *codec)
16244 {
16245         struct alc_spec *spec = codec->spec;
16246         alc861vd_auto_init_multi_out(codec);
16247         alc861vd_auto_init_hp_out(codec);
16248         alc861vd_auto_init_analog_input(codec);
16249         alc861vd_auto_init_input_src(codec);
16250         if (spec->unsol_event)
16251                 alc_inithook(codec);
16252 }
16253
16254 enum {
16255         ALC660VD_FIX_ASUS_GPIO1
16256 };
16257
16258 /* reset GPIO1 */
16259 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
16260         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
16261         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
16262         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
16263         { }
16264 };
16265
16266 static const struct alc_fixup alc861vd_fixups[] = {
16267         [ALC660VD_FIX_ASUS_GPIO1] = {
16268                 .verbs = alc660vd_fix_asus_gpio1_verbs,
16269         },
16270 };
16271
16272 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
16273         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
16274         {}
16275 };
16276
16277 static int patch_alc861vd(struct hda_codec *codec)
16278 {
16279         struct alc_spec *spec;
16280         int err, board_config;
16281
16282         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16283         if (spec == NULL)
16284                 return -ENOMEM;
16285
16286         codec->spec = spec;
16287
16288         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
16289                                                   alc861vd_models,
16290                                                   alc861vd_cfg_tbl);
16291
16292         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
16293                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16294                        codec->chip_name);
16295                 board_config = ALC861VD_AUTO;
16296         }
16297
16298         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
16299
16300         if (board_config == ALC861VD_AUTO) {
16301                 /* automatic parse from the BIOS config */
16302                 err = alc861vd_parse_auto_config(codec);
16303                 if (err < 0) {
16304                         alc_free(codec);
16305                         return err;
16306                 } else if (!err) {
16307                         printk(KERN_INFO
16308                                "hda_codec: Cannot set up configuration "
16309                                "from BIOS.  Using base mode...\n");
16310                         board_config = ALC861VD_3ST;
16311                 }
16312         }
16313
16314         err = snd_hda_attach_beep_device(codec, 0x23);
16315         if (err < 0) {
16316                 alc_free(codec);
16317                 return err;
16318         }
16319
16320         if (board_config != ALC861VD_AUTO)
16321                 setup_preset(codec, &alc861vd_presets[board_config]);
16322
16323         if (codec->vendor_id == 0x10ec0660) {
16324                 /* always turn on EAPD */
16325                 add_verb(spec, alc660vd_eapd_verbs);
16326         }
16327
16328         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
16329         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
16330
16331         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
16332         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
16333
16334         if (!spec->adc_nids) {
16335                 spec->adc_nids = alc861vd_adc_nids;
16336                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
16337         }
16338         if (!spec->capsrc_nids)
16339                 spec->capsrc_nids = alc861vd_capsrc_nids;
16340
16341         set_capture_mixer(codec);
16342         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16343
16344         spec->vmaster_nid = 0x02;
16345
16346         codec->patch_ops = alc_patch_ops;
16347
16348         if (board_config == ALC861VD_AUTO)
16349                 spec->init_hook = alc861vd_auto_init;
16350 #ifdef CONFIG_SND_HDA_POWER_SAVE
16351         if (!spec->loopback.amplist)
16352                 spec->loopback.amplist = alc861vd_loopbacks;
16353 #endif
16354
16355         return 0;
16356 }
16357
16358 /*
16359  * ALC662 support
16360  *
16361  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
16362  * configuration.  Each pin widget can choose any input DACs and a mixer.
16363  * Each ADC is connected from a mixer of all inputs.  This makes possible
16364  * 6-channel independent captures.
16365  *
16366  * In addition, an independent DAC for the multi-playback (not used in this
16367  * driver yet).
16368  */
16369 #define ALC662_DIGOUT_NID       0x06
16370 #define ALC662_DIGIN_NID        0x0a
16371
16372 static hda_nid_t alc662_dac_nids[4] = {
16373         /* front, rear, clfe, rear_surr */
16374         0x02, 0x03, 0x04
16375 };
16376
16377 static hda_nid_t alc272_dac_nids[2] = {
16378         0x02, 0x03
16379 };
16380
16381 static hda_nid_t alc662_adc_nids[2] = {
16382         /* ADC1-2 */
16383         0x09, 0x08
16384 };
16385
16386 static hda_nid_t alc272_adc_nids[1] = {
16387         /* ADC1-2 */
16388         0x08,
16389 };
16390
16391 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
16392 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
16393
16394
16395 /* input MUX */
16396 /* FIXME: should be a matrix-type input source selection */
16397 static struct hda_input_mux alc662_capture_source = {
16398         .num_items = 4,
16399         .items = {
16400                 { "Mic", 0x0 },
16401                 { "Front Mic", 0x1 },
16402                 { "Line", 0x2 },
16403                 { "CD", 0x4 },
16404         },
16405 };
16406
16407 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
16408         .num_items = 2,
16409         .items = {
16410                 { "Mic", 0x1 },
16411                 { "Line", 0x2 },
16412         },
16413 };
16414
16415 static struct hda_input_mux alc663_capture_source = {
16416         .num_items = 3,
16417         .items = {
16418                 { "Mic", 0x0 },
16419                 { "Front Mic", 0x1 },
16420                 { "Line", 0x2 },
16421         },
16422 };
16423
16424 #if 0 /* set to 1 for testing other input sources below */
16425 static struct hda_input_mux alc272_nc10_capture_source = {
16426         .num_items = 16,
16427         .items = {
16428                 { "Autoselect Mic", 0x0 },
16429                 { "Internal Mic", 0x1 },
16430                 { "In-0x02", 0x2 },
16431                 { "In-0x03", 0x3 },
16432                 { "In-0x04", 0x4 },
16433                 { "In-0x05", 0x5 },
16434                 { "In-0x06", 0x6 },
16435                 { "In-0x07", 0x7 },
16436                 { "In-0x08", 0x8 },
16437                 { "In-0x09", 0x9 },
16438                 { "In-0x0a", 0x0a },
16439                 { "In-0x0b", 0x0b },
16440                 { "In-0x0c", 0x0c },
16441                 { "In-0x0d", 0x0d },
16442                 { "In-0x0e", 0x0e },
16443                 { "In-0x0f", 0x0f },
16444         },
16445 };
16446 #endif
16447
16448 /*
16449  * 2ch mode
16450  */
16451 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
16452         { 2, NULL }
16453 };
16454
16455 /*
16456  * 2ch mode
16457  */
16458 static struct hda_verb alc662_3ST_ch2_init[] = {
16459         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
16460         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16461         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
16462         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16463         { } /* end */
16464 };
16465
16466 /*
16467  * 6ch mode
16468  */
16469 static struct hda_verb alc662_3ST_ch6_init[] = {
16470         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16471         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16472         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
16473         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16474         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16475         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
16476         { } /* end */
16477 };
16478
16479 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
16480         { 2, alc662_3ST_ch2_init },
16481         { 6, alc662_3ST_ch6_init },
16482 };
16483
16484 /*
16485  * 2ch mode
16486  */
16487 static struct hda_verb alc662_sixstack_ch6_init[] = {
16488         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16489         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16490         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16491         { } /* end */
16492 };
16493
16494 /*
16495  * 6ch mode
16496  */
16497 static struct hda_verb alc662_sixstack_ch8_init[] = {
16498         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16499         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16500         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16501         { } /* end */
16502 };
16503
16504 static struct hda_channel_mode alc662_5stack_modes[2] = {
16505         { 2, alc662_sixstack_ch6_init },
16506         { 6, alc662_sixstack_ch8_init },
16507 };
16508
16509 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16510  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16511  */
16512
16513 static struct snd_kcontrol_new alc662_base_mixer[] = {
16514         /* output mixer control */
16515         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16516         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16517         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16518         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16519         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16520         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16521         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16522         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16523         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16524
16525         /*Input mixer control */
16526         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16527         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16528         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16529         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16530         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16531         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16532         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16533         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16534         { } /* end */
16535 };
16536
16537 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16538         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16539         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16540         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16541         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16542         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16543         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16544         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16545         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16546         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16547         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16548         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16549         { } /* end */
16550 };
16551
16552 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16553         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16554         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16555         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16556         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16557         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16558         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16559         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16560         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16561         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16562         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16563         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16564         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16565         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16566         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16567         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16568         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16569         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16570         { } /* end */
16571 };
16572
16573 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16574         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16575         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16576         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16577         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16578         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16579         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16580         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16581         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16582         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16583         { } /* end */
16584 };
16585
16586 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16587         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16588         ALC262_HIPPO_MASTER_SWITCH,
16589
16590         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16591         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16592         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16593
16594         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16595         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16596         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16597         { } /* end */
16598 };
16599
16600 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16601         ALC262_HIPPO_MASTER_SWITCH,
16602         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16603         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16604         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16605         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16606         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16607         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16608         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16609         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16610         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16611         { } /* end */
16612 };
16613
16614 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16615         .ops = &snd_hda_bind_vol,
16616         .values = {
16617                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16618                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16619                 0
16620         },
16621 };
16622
16623 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16624         .ops = &snd_hda_bind_sw,
16625         .values = {
16626                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16627                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16628                 0
16629         },
16630 };
16631
16632 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16633         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16634         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16635         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16636         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16637         { } /* end */
16638 };
16639
16640 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16641         .ops = &snd_hda_bind_sw,
16642         .values = {
16643                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16644                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16645                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16646                 0
16647         },
16648 };
16649
16650 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16651         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16652         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16653         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16654         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16655         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16656         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16657
16658         { } /* end */
16659 };
16660
16661 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16662         .ops = &snd_hda_bind_sw,
16663         .values = {
16664                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16665                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16666                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16667                 0
16668         },
16669 };
16670
16671 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16672         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16673         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16674         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16675         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16676         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16677         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16678         { } /* end */
16679 };
16680
16681 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16682         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16683         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16684         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16685         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16686         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16687         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16688         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16689         { } /* end */
16690 };
16691
16692 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16693         .ops = &snd_hda_bind_vol,
16694         .values = {
16695                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16696                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16697                 0
16698         },
16699 };
16700
16701 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16702         .ops = &snd_hda_bind_sw,
16703         .values = {
16704                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16705                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16706                 0
16707         },
16708 };
16709
16710 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16711         HDA_BIND_VOL("Master Playback Volume",
16712                                 &alc663_asus_two_bind_master_vol),
16713         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16714         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16715         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16716         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16717         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16718         { } /* end */
16719 };
16720
16721 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16722         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16723         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16724         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16725         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16726         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16727         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16728         { } /* end */
16729 };
16730
16731 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16732         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16733         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16734         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16735         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16736         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16737
16738         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16739         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16740         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16741         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16742         { } /* end */
16743 };
16744
16745 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16746         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16747         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16748         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16749
16750         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16751         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16752         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16753         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16754         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16755         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16756         { } /* end */
16757 };
16758
16759 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16760         .ops = &snd_hda_bind_sw,
16761         .values = {
16762                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16763                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16764                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16765                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16766                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16767                 0
16768         },
16769 };
16770
16771 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16772         .ops = &snd_hda_bind_sw,
16773         .values = {
16774                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16775                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16776                 0
16777         },
16778 };
16779
16780 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16781         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16782         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16783         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16784         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16785         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16786         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16787         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16788         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16789         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16790         { } /* end */
16791 };
16792
16793 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16794         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16795         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16796         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16797         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16798         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16799         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16800         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16801         { } /* end */
16802 };
16803
16804
16805 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16806         {
16807                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16808                 .name = "Channel Mode",
16809                 .info = alc_ch_mode_info,
16810                 .get = alc_ch_mode_get,
16811                 .put = alc_ch_mode_put,
16812         },
16813         { } /* end */
16814 };
16815
16816 static struct hda_verb alc662_init_verbs[] = {
16817         /* ADC: mute amp left and right */
16818         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16819         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16820
16821         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16822         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16823         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16824         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16825         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16826         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16827
16828         /* Front Pin: output 0 (0x0c) */
16829         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16830         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16831
16832         /* Rear Pin: output 1 (0x0d) */
16833         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16834         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16835
16836         /* CLFE Pin: output 2 (0x0e) */
16837         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16838         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16839
16840         /* Mic (rear) pin: input vref at 80% */
16841         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16842         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16843         /* Front Mic pin: input vref at 80% */
16844         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16845         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16846         /* Line In pin: input */
16847         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16848         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16849         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16850         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16851         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16852         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16853         /* CD pin widget for input */
16854         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16855
16856         /* FIXME: use matrix-type input source selection */
16857         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16858         /* Input mixer */
16859         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16860         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16861
16862         /* always trun on EAPD */
16863         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16864         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16865
16866         { }
16867 };
16868
16869 static struct hda_verb alc663_init_verbs[] = {
16870         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16871         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16872         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16873         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16874         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16875         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16876         { }
16877 };
16878
16879 static struct hda_verb alc272_init_verbs[] = {
16880         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16881         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16882         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16883         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16884         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16885         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16886         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16887         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16888         { }
16889 };
16890
16891 static struct hda_verb alc662_sue_init_verbs[] = {
16892         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16893         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16894         {}
16895 };
16896
16897 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16898         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16899         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16900         {}
16901 };
16902
16903 /* Set Unsolicited Event*/
16904 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16905         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16906         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16907         {}
16908 };
16909
16910 static struct hda_verb alc663_m51va_init_verbs[] = {
16911         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16912         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16913         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16914         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16915         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16916         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16917         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16918         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16919         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16920         {}
16921 };
16922
16923 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16924         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16925         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16926         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16927         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16928         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16929         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16930         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16931         {}
16932 };
16933
16934 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16935         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16936         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16937         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16938         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16939         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16940         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16941         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16942         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16943         {}
16944 };
16945
16946 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16947         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16948         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16949         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16950         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16951         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16952         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16953         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16954         {}
16955 };
16956
16957 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16958         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16959         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16960         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16961         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16962         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16963         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16964         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16965         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16966         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16967         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16968         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16969         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16970         {}
16971 };
16972
16973 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16974         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16975         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16976         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16977         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16978         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16979         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16980         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16981         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16982         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16983         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16984         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16985         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16986         {}
16987 };
16988
16989 static struct hda_verb alc663_g71v_init_verbs[] = {
16990         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16991         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16992         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16993
16994         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16995         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16996         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16997
16998         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16999         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17000         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17001         {}
17002 };
17003
17004 static struct hda_verb alc663_g50v_init_verbs[] = {
17005         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17006         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17007         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17008
17009         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17010         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17011         {}
17012 };
17013
17014 static struct hda_verb alc662_ecs_init_verbs[] = {
17015         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17016         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17017         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17018         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17019         {}
17020 };
17021
17022 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17023         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17024         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17025         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17026         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17027         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17028         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17029         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17030         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17031         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17032         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17033         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17034         {}
17035 };
17036
17037 static struct hda_verb alc272_dell_init_verbs[] = {
17038         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17039         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17040         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17041         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17042         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17043         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17044         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17045         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17046         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17047         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17048         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17049         {}
17050 };
17051
17052 static struct hda_verb alc663_mode7_init_verbs[] = {
17053         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17054         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17055         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17056         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17057         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17058         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17059         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
17060         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17061         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17062         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17063         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17064         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17065         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17066         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17067         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17068         {}
17069 };
17070
17071 static struct hda_verb alc663_mode8_init_verbs[] = {
17072         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17073         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17074         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17075         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
17076         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17077         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17078         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17079         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17080         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17081         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17082         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17083         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17084         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17085         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17086         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17087         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17088         {}
17089 };
17090
17091 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17092         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17093         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17094         { } /* end */
17095 };
17096
17097 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17098         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17099         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17100         { } /* end */
17101 };
17102
17103 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17104 {
17105         unsigned int present;
17106         unsigned char bits;
17107
17108         present = snd_hda_jack_detect(codec, 0x14);
17109         bits = present ? HDA_AMP_MUTE : 0;
17110
17111         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17112                                  HDA_AMP_MUTE, bits);
17113 }
17114
17115 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17116 {
17117         unsigned int present;
17118         unsigned char bits;
17119
17120         present = snd_hda_jack_detect(codec, 0x1b);
17121         bits = present ? HDA_AMP_MUTE : 0;
17122
17123         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17124                                  HDA_AMP_MUTE, bits);
17125         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17126                                  HDA_AMP_MUTE, bits);
17127 }
17128
17129 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17130                                            unsigned int res)
17131 {
17132         if ((res >> 26) == ALC880_HP_EVENT)
17133                 alc662_lenovo_101e_all_automute(codec);
17134         if ((res >> 26) == ALC880_FRONT_EVENT)
17135                 alc662_lenovo_101e_ispeaker_automute(codec);
17136 }
17137
17138 /* unsolicited event for HP jack sensing */
17139 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17140                                      unsigned int res)
17141 {
17142         if ((res >> 26) == ALC880_MIC_EVENT)
17143                 alc_mic_automute(codec);
17144         else
17145                 alc262_hippo_unsol_event(codec, res);
17146 }
17147
17148 static void alc662_eeepc_setup(struct hda_codec *codec)
17149 {
17150         struct alc_spec *spec = codec->spec;
17151
17152         alc262_hippo1_setup(codec);
17153         spec->ext_mic.pin = 0x18;
17154         spec->ext_mic.mux_idx = 0;
17155         spec->int_mic.pin = 0x19;
17156         spec->int_mic.mux_idx = 1;
17157         spec->auto_mic = 1;
17158 }
17159
17160 static void alc662_eeepc_inithook(struct hda_codec *codec)
17161 {
17162         alc262_hippo_automute(codec);
17163         alc_mic_automute(codec);
17164 }
17165
17166 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
17167 {
17168         struct alc_spec *spec = codec->spec;
17169
17170         spec->autocfg.hp_pins[0] = 0x14;
17171         spec->autocfg.speaker_pins[0] = 0x1b;
17172 }
17173
17174 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
17175
17176 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
17177 {
17178         unsigned int present;
17179         unsigned char bits;
17180
17181         present = snd_hda_jack_detect(codec, 0x21);
17182         bits = present ? HDA_AMP_MUTE : 0;
17183         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17184                                  HDA_AMP_MUTE, bits);
17185         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17186                                  HDA_AMP_MUTE, bits);
17187 }
17188
17189 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
17190 {
17191         unsigned int present;
17192         unsigned char bits;
17193
17194         present = snd_hda_jack_detect(codec, 0x21);
17195         bits = present ? HDA_AMP_MUTE : 0;
17196         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17197                                  HDA_AMP_MUTE, bits);
17198         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17199                                  HDA_AMP_MUTE, bits);
17200         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17201                                  HDA_AMP_MUTE, bits);
17202         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17203                                  HDA_AMP_MUTE, bits);
17204 }
17205
17206 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
17207 {
17208         unsigned int present;
17209         unsigned char bits;
17210
17211         present = snd_hda_jack_detect(codec, 0x15);
17212         bits = present ? HDA_AMP_MUTE : 0;
17213         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17214                                  HDA_AMP_MUTE, bits);
17215         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17216                                  HDA_AMP_MUTE, bits);
17217         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17218                                  HDA_AMP_MUTE, bits);
17219         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17220                                  HDA_AMP_MUTE, bits);
17221 }
17222
17223 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
17224 {
17225         unsigned int present;
17226         unsigned char bits;
17227
17228         present = snd_hda_jack_detect(codec, 0x1b);
17229         bits = present ? 0 : PIN_OUT;
17230         snd_hda_codec_write(codec, 0x14, 0,
17231                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
17232 }
17233
17234 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
17235 {
17236         unsigned int present1, present2;
17237
17238         present1 = snd_hda_jack_detect(codec, 0x21);
17239         present2 = snd_hda_jack_detect(codec, 0x15);
17240
17241         if (present1 || present2) {
17242                 snd_hda_codec_write_cache(codec, 0x14, 0,
17243                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17244         } else {
17245                 snd_hda_codec_write_cache(codec, 0x14, 0,
17246                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17247         }
17248 }
17249
17250 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
17251 {
17252         unsigned int present1, present2;
17253
17254         present1 = snd_hda_jack_detect(codec, 0x1b);
17255         present2 = snd_hda_jack_detect(codec, 0x15);
17256
17257         if (present1 || present2) {
17258                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17259                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17260                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17261                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17262         } else {
17263                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17264                                          HDA_AMP_MUTE, 0);
17265                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17266                                          HDA_AMP_MUTE, 0);
17267         }
17268 }
17269
17270 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
17271 {
17272         unsigned int present1, present2;
17273
17274         present1 = snd_hda_codec_read(codec, 0x1b, 0,
17275                         AC_VERB_GET_PIN_SENSE, 0)
17276                         & AC_PINSENSE_PRESENCE;
17277         present2 = snd_hda_codec_read(codec, 0x21, 0,
17278                         AC_VERB_GET_PIN_SENSE, 0)
17279                         & AC_PINSENSE_PRESENCE;
17280
17281         if (present1 || present2) {
17282                 snd_hda_codec_write_cache(codec, 0x14, 0,
17283                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17284                 snd_hda_codec_write_cache(codec, 0x17, 0,
17285                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17286         } else {
17287                 snd_hda_codec_write_cache(codec, 0x14, 0,
17288                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17289                 snd_hda_codec_write_cache(codec, 0x17, 0,
17290                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17291         }
17292 }
17293
17294 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
17295 {
17296         unsigned int present1, present2;
17297
17298         present1 = snd_hda_codec_read(codec, 0x21, 0,
17299                         AC_VERB_GET_PIN_SENSE, 0)
17300                         & AC_PINSENSE_PRESENCE;
17301         present2 = snd_hda_codec_read(codec, 0x15, 0,
17302                         AC_VERB_GET_PIN_SENSE, 0)
17303                         & AC_PINSENSE_PRESENCE;
17304
17305         if (present1 || present2) {
17306                 snd_hda_codec_write_cache(codec, 0x14, 0,
17307                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17308                 snd_hda_codec_write_cache(codec, 0x17, 0,
17309                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17310         } else {
17311                 snd_hda_codec_write_cache(codec, 0x14, 0,
17312                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17313                 snd_hda_codec_write_cache(codec, 0x17, 0,
17314                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17315         }
17316 }
17317
17318 static void alc663_m51va_unsol_event(struct hda_codec *codec,
17319                                            unsigned int res)
17320 {
17321         switch (res >> 26) {
17322         case ALC880_HP_EVENT:
17323                 alc663_m51va_speaker_automute(codec);
17324                 break;
17325         case ALC880_MIC_EVENT:
17326                 alc_mic_automute(codec);
17327                 break;
17328         }
17329 }
17330
17331 static void alc663_m51va_setup(struct hda_codec *codec)
17332 {
17333         struct alc_spec *spec = codec->spec;
17334         spec->ext_mic.pin = 0x18;
17335         spec->ext_mic.mux_idx = 0;
17336         spec->int_mic.pin = 0x12;
17337         spec->int_mic.mux_idx = 9;
17338         spec->auto_mic = 1;
17339 }
17340
17341 static void alc663_m51va_inithook(struct hda_codec *codec)
17342 {
17343         alc663_m51va_speaker_automute(codec);
17344         alc_mic_automute(codec);
17345 }
17346
17347 /* ***************** Mode1 ******************************/
17348 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
17349
17350 static void alc663_mode1_setup(struct hda_codec *codec)
17351 {
17352         struct alc_spec *spec = codec->spec;
17353         spec->ext_mic.pin = 0x18;
17354         spec->ext_mic.mux_idx = 0;
17355         spec->int_mic.pin = 0x19;
17356         spec->int_mic.mux_idx = 1;
17357         spec->auto_mic = 1;
17358 }
17359
17360 #define alc663_mode1_inithook           alc663_m51va_inithook
17361
17362 /* ***************** Mode2 ******************************/
17363 static void alc662_mode2_unsol_event(struct hda_codec *codec,
17364                                            unsigned int res)
17365 {
17366         switch (res >> 26) {
17367         case ALC880_HP_EVENT:
17368                 alc662_f5z_speaker_automute(codec);
17369                 break;
17370         case ALC880_MIC_EVENT:
17371                 alc_mic_automute(codec);
17372                 break;
17373         }
17374 }
17375
17376 #define alc662_mode2_setup      alc663_mode1_setup
17377
17378 static void alc662_mode2_inithook(struct hda_codec *codec)
17379 {
17380         alc662_f5z_speaker_automute(codec);
17381         alc_mic_automute(codec);
17382 }
17383 /* ***************** Mode3 ******************************/
17384 static void alc663_mode3_unsol_event(struct hda_codec *codec,
17385                                            unsigned int res)
17386 {
17387         switch (res >> 26) {
17388         case ALC880_HP_EVENT:
17389                 alc663_two_hp_m1_speaker_automute(codec);
17390                 break;
17391         case ALC880_MIC_EVENT:
17392                 alc_mic_automute(codec);
17393                 break;
17394         }
17395 }
17396
17397 #define alc663_mode3_setup      alc663_mode1_setup
17398
17399 static void alc663_mode3_inithook(struct hda_codec *codec)
17400 {
17401         alc663_two_hp_m1_speaker_automute(codec);
17402         alc_mic_automute(codec);
17403 }
17404 /* ***************** Mode4 ******************************/
17405 static void alc663_mode4_unsol_event(struct hda_codec *codec,
17406                                            unsigned int res)
17407 {
17408         switch (res >> 26) {
17409         case ALC880_HP_EVENT:
17410                 alc663_21jd_two_speaker_automute(codec);
17411                 break;
17412         case ALC880_MIC_EVENT:
17413                 alc_mic_automute(codec);
17414                 break;
17415         }
17416 }
17417
17418 #define alc663_mode4_setup      alc663_mode1_setup
17419
17420 static void alc663_mode4_inithook(struct hda_codec *codec)
17421 {
17422         alc663_21jd_two_speaker_automute(codec);
17423         alc_mic_automute(codec);
17424 }
17425 /* ***************** Mode5 ******************************/
17426 static void alc663_mode5_unsol_event(struct hda_codec *codec,
17427                                            unsigned int res)
17428 {
17429         switch (res >> 26) {
17430         case ALC880_HP_EVENT:
17431                 alc663_15jd_two_speaker_automute(codec);
17432                 break;
17433         case ALC880_MIC_EVENT:
17434                 alc_mic_automute(codec);
17435                 break;
17436         }
17437 }
17438
17439 #define alc663_mode5_setup      alc663_mode1_setup
17440
17441 static void alc663_mode5_inithook(struct hda_codec *codec)
17442 {
17443         alc663_15jd_two_speaker_automute(codec);
17444         alc_mic_automute(codec);
17445 }
17446 /* ***************** Mode6 ******************************/
17447 static void alc663_mode6_unsol_event(struct hda_codec *codec,
17448                                            unsigned int res)
17449 {
17450         switch (res >> 26) {
17451         case ALC880_HP_EVENT:
17452                 alc663_two_hp_m2_speaker_automute(codec);
17453                 break;
17454         case ALC880_MIC_EVENT:
17455                 alc_mic_automute(codec);
17456                 break;
17457         }
17458 }
17459
17460 #define alc663_mode6_setup      alc663_mode1_setup
17461
17462 static void alc663_mode6_inithook(struct hda_codec *codec)
17463 {
17464         alc663_two_hp_m2_speaker_automute(codec);
17465         alc_mic_automute(codec);
17466 }
17467
17468 /* ***************** Mode7 ******************************/
17469 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17470                                            unsigned int res)
17471 {
17472         switch (res >> 26) {
17473         case ALC880_HP_EVENT:
17474                 alc663_two_hp_m7_speaker_automute(codec);
17475                 break;
17476         case ALC880_MIC_EVENT:
17477                 alc_mic_automute(codec);
17478                 break;
17479         }
17480 }
17481
17482 #define alc663_mode7_setup      alc663_mode1_setup
17483
17484 static void alc663_mode7_inithook(struct hda_codec *codec)
17485 {
17486         alc663_two_hp_m7_speaker_automute(codec);
17487         alc_mic_automute(codec);
17488 }
17489
17490 /* ***************** Mode8 ******************************/
17491 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17492                                            unsigned int res)
17493 {
17494         switch (res >> 26) {
17495         case ALC880_HP_EVENT:
17496                 alc663_two_hp_m8_speaker_automute(codec);
17497                 break;
17498         case ALC880_MIC_EVENT:
17499                 alc_mic_automute(codec);
17500                 break;
17501         }
17502 }
17503
17504 #define alc663_mode8_setup      alc663_m51va_setup
17505
17506 static void alc663_mode8_inithook(struct hda_codec *codec)
17507 {
17508         alc663_two_hp_m8_speaker_automute(codec);
17509         alc_mic_automute(codec);
17510 }
17511
17512 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17513 {
17514         unsigned int present;
17515         unsigned char bits;
17516
17517         present = snd_hda_jack_detect(codec, 0x21);
17518         bits = present ? HDA_AMP_MUTE : 0;
17519         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17520                                  HDA_AMP_MUTE, bits);
17521         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17522                                  HDA_AMP_MUTE, bits);
17523 }
17524
17525 static void alc663_g71v_front_automute(struct hda_codec *codec)
17526 {
17527         unsigned int present;
17528         unsigned char bits;
17529
17530         present = snd_hda_jack_detect(codec, 0x15);
17531         bits = present ? HDA_AMP_MUTE : 0;
17532         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17533                                  HDA_AMP_MUTE, bits);
17534 }
17535
17536 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17537                                            unsigned int res)
17538 {
17539         switch (res >> 26) {
17540         case ALC880_HP_EVENT:
17541                 alc663_g71v_hp_automute(codec);
17542                 break;
17543         case ALC880_FRONT_EVENT:
17544                 alc663_g71v_front_automute(codec);
17545                 break;
17546         case ALC880_MIC_EVENT:
17547                 alc_mic_automute(codec);
17548                 break;
17549         }
17550 }
17551
17552 #define alc663_g71v_setup       alc663_m51va_setup
17553
17554 static void alc663_g71v_inithook(struct hda_codec *codec)
17555 {
17556         alc663_g71v_front_automute(codec);
17557         alc663_g71v_hp_automute(codec);
17558         alc_mic_automute(codec);
17559 }
17560
17561 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17562                                            unsigned int res)
17563 {
17564         switch (res >> 26) {
17565         case ALC880_HP_EVENT:
17566                 alc663_m51va_speaker_automute(codec);
17567                 break;
17568         case ALC880_MIC_EVENT:
17569                 alc_mic_automute(codec);
17570                 break;
17571         }
17572 }
17573
17574 #define alc663_g50v_setup       alc663_m51va_setup
17575
17576 static void alc663_g50v_inithook(struct hda_codec *codec)
17577 {
17578         alc663_m51va_speaker_automute(codec);
17579         alc_mic_automute(codec);
17580 }
17581
17582 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17583         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17584         ALC262_HIPPO_MASTER_SWITCH,
17585
17586         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17587         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17588         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17589
17590         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17591         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17592         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17593         { } /* end */
17594 };
17595
17596 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17597         /* Master Playback automatically created from Speaker and Headphone */
17598         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17599         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17600         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17601         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17602
17603         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17604         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17605         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17606
17607         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17608         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17609         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17610         { } /* end */
17611 };
17612
17613 #ifdef CONFIG_SND_HDA_POWER_SAVE
17614 #define alc662_loopbacks        alc880_loopbacks
17615 #endif
17616
17617
17618 /* pcm configuration: identical with ALC880 */
17619 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
17620 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
17621 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
17622 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
17623
17624 /*
17625  * configuration and preset
17626  */
17627 static const char *alc662_models[ALC662_MODEL_LAST] = {
17628         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17629         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17630         [ALC662_3ST_6ch]        = "3stack-6ch",
17631         [ALC662_5ST_DIG]        = "6stack-dig",
17632         [ALC662_LENOVO_101E]    = "lenovo-101e",
17633         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17634         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17635         [ALC662_ECS] = "ecs",
17636         [ALC663_ASUS_M51VA] = "m51va",
17637         [ALC663_ASUS_G71V] = "g71v",
17638         [ALC663_ASUS_H13] = "h13",
17639         [ALC663_ASUS_G50V] = "g50v",
17640         [ALC663_ASUS_MODE1] = "asus-mode1",
17641         [ALC662_ASUS_MODE2] = "asus-mode2",
17642         [ALC663_ASUS_MODE3] = "asus-mode3",
17643         [ALC663_ASUS_MODE4] = "asus-mode4",
17644         [ALC663_ASUS_MODE5] = "asus-mode5",
17645         [ALC663_ASUS_MODE6] = "asus-mode6",
17646         [ALC663_ASUS_MODE7] = "asus-mode7",
17647         [ALC663_ASUS_MODE8] = "asus-mode8",
17648         [ALC272_DELL]           = "dell",
17649         [ALC272_DELL_ZM1]       = "dell-zm1",
17650         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17651         [ALC662_AUTO]           = "auto",
17652 };
17653
17654 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17655         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17656         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17657         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17658         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17659         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17660         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
17661         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17662         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17663         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17664         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17665         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17666         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17667         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17668         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17669         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17670         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17671         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17672         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17673         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17674         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17675         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17676         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17677         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17678         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17679         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17680         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17681         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17682         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17683         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17684         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17685         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17686         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17687         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17688         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17689         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17690         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17691         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17692         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17693         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17694         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17695         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17696         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
17697         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17698         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17699         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17700         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17701         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17702         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17703         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17704         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17705         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17706         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17707         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17708         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17709         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17710         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17711         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17712         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17713         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17714         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17715         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17716         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17717         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17718         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17719                       ALC662_3ST_6ch_DIG),
17720         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
17721         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17722         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17723                       ALC662_3ST_6ch_DIG),
17724         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
17725         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17726         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17727         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17728         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17729                                         ALC662_3ST_6ch_DIG),
17730         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17731                            ALC663_ASUS_H13),
17732         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17733         {}
17734 };
17735
17736 static struct alc_config_preset alc662_presets[] = {
17737         [ALC662_3ST_2ch_DIG] = {
17738                 .mixers = { alc662_3ST_2ch_mixer },
17739                 .init_verbs = { alc662_init_verbs },
17740                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17741                 .dac_nids = alc662_dac_nids,
17742                 .dig_out_nid = ALC662_DIGOUT_NID,
17743                 .dig_in_nid = ALC662_DIGIN_NID,
17744                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17745                 .channel_mode = alc662_3ST_2ch_modes,
17746                 .input_mux = &alc662_capture_source,
17747         },
17748         [ALC662_3ST_6ch_DIG] = {
17749                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17750                 .init_verbs = { alc662_init_verbs },
17751                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17752                 .dac_nids = alc662_dac_nids,
17753                 .dig_out_nid = ALC662_DIGOUT_NID,
17754                 .dig_in_nid = ALC662_DIGIN_NID,
17755                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17756                 .channel_mode = alc662_3ST_6ch_modes,
17757                 .need_dac_fix = 1,
17758                 .input_mux = &alc662_capture_source,
17759         },
17760         [ALC662_3ST_6ch] = {
17761                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17762                 .init_verbs = { alc662_init_verbs },
17763                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17764                 .dac_nids = alc662_dac_nids,
17765                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17766                 .channel_mode = alc662_3ST_6ch_modes,
17767                 .need_dac_fix = 1,
17768                 .input_mux = &alc662_capture_source,
17769         },
17770         [ALC662_5ST_DIG] = {
17771                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17772                 .init_verbs = { alc662_init_verbs },
17773                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17774                 .dac_nids = alc662_dac_nids,
17775                 .dig_out_nid = ALC662_DIGOUT_NID,
17776                 .dig_in_nid = ALC662_DIGIN_NID,
17777                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17778                 .channel_mode = alc662_5stack_modes,
17779                 .input_mux = &alc662_capture_source,
17780         },
17781         [ALC662_LENOVO_101E] = {
17782                 .mixers = { alc662_lenovo_101e_mixer },
17783                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17784                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17785                 .dac_nids = alc662_dac_nids,
17786                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17787                 .channel_mode = alc662_3ST_2ch_modes,
17788                 .input_mux = &alc662_lenovo_101e_capture_source,
17789                 .unsol_event = alc662_lenovo_101e_unsol_event,
17790                 .init_hook = alc662_lenovo_101e_all_automute,
17791         },
17792         [ALC662_ASUS_EEEPC_P701] = {
17793                 .mixers = { alc662_eeepc_p701_mixer },
17794                 .init_verbs = { alc662_init_verbs,
17795                                 alc662_eeepc_sue_init_verbs },
17796                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17797                 .dac_nids = alc662_dac_nids,
17798                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17799                 .channel_mode = alc662_3ST_2ch_modes,
17800                 .unsol_event = alc662_eeepc_unsol_event,
17801                 .setup = alc662_eeepc_setup,
17802                 .init_hook = alc662_eeepc_inithook,
17803         },
17804         [ALC662_ASUS_EEEPC_EP20] = {
17805                 .mixers = { alc662_eeepc_ep20_mixer,
17806                             alc662_chmode_mixer },
17807                 .init_verbs = { alc662_init_verbs,
17808                                 alc662_eeepc_ep20_sue_init_verbs },
17809                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17810                 .dac_nids = alc662_dac_nids,
17811                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17812                 .channel_mode = alc662_3ST_6ch_modes,
17813                 .input_mux = &alc662_lenovo_101e_capture_source,
17814                 .unsol_event = alc662_eeepc_unsol_event,
17815                 .setup = alc662_eeepc_ep20_setup,
17816                 .init_hook = alc662_eeepc_ep20_inithook,
17817         },
17818         [ALC662_ECS] = {
17819                 .mixers = { alc662_ecs_mixer },
17820                 .init_verbs = { alc662_init_verbs,
17821                                 alc662_ecs_init_verbs },
17822                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17823                 .dac_nids = alc662_dac_nids,
17824                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17825                 .channel_mode = alc662_3ST_2ch_modes,
17826                 .unsol_event = alc662_eeepc_unsol_event,
17827                 .setup = alc662_eeepc_setup,
17828                 .init_hook = alc662_eeepc_inithook,
17829         },
17830         [ALC663_ASUS_M51VA] = {
17831                 .mixers = { alc663_m51va_mixer },
17832                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17833                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17834                 .dac_nids = alc662_dac_nids,
17835                 .dig_out_nid = ALC662_DIGOUT_NID,
17836                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17837                 .channel_mode = alc662_3ST_2ch_modes,
17838                 .unsol_event = alc663_m51va_unsol_event,
17839                 .setup = alc663_m51va_setup,
17840                 .init_hook = alc663_m51va_inithook,
17841         },
17842         [ALC663_ASUS_G71V] = {
17843                 .mixers = { alc663_g71v_mixer },
17844                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17845                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17846                 .dac_nids = alc662_dac_nids,
17847                 .dig_out_nid = ALC662_DIGOUT_NID,
17848                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17849                 .channel_mode = alc662_3ST_2ch_modes,
17850                 .unsol_event = alc663_g71v_unsol_event,
17851                 .setup = alc663_g71v_setup,
17852                 .init_hook = alc663_g71v_inithook,
17853         },
17854         [ALC663_ASUS_H13] = {
17855                 .mixers = { alc663_m51va_mixer },
17856                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17857                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17858                 .dac_nids = alc662_dac_nids,
17859                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17860                 .channel_mode = alc662_3ST_2ch_modes,
17861                 .unsol_event = alc663_m51va_unsol_event,
17862                 .init_hook = alc663_m51va_inithook,
17863         },
17864         [ALC663_ASUS_G50V] = {
17865                 .mixers = { alc663_g50v_mixer },
17866                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17867                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17868                 .dac_nids = alc662_dac_nids,
17869                 .dig_out_nid = ALC662_DIGOUT_NID,
17870                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17871                 .channel_mode = alc662_3ST_6ch_modes,
17872                 .input_mux = &alc663_capture_source,
17873                 .unsol_event = alc663_g50v_unsol_event,
17874                 .setup = alc663_g50v_setup,
17875                 .init_hook = alc663_g50v_inithook,
17876         },
17877         [ALC663_ASUS_MODE1] = {
17878                 .mixers = { alc663_m51va_mixer },
17879                 .cap_mixer = alc662_auto_capture_mixer,
17880                 .init_verbs = { alc662_init_verbs,
17881                                 alc663_21jd_amic_init_verbs },
17882                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17883                 .hp_nid = 0x03,
17884                 .dac_nids = alc662_dac_nids,
17885                 .dig_out_nid = ALC662_DIGOUT_NID,
17886                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17887                 .channel_mode = alc662_3ST_2ch_modes,
17888                 .unsol_event = alc663_mode1_unsol_event,
17889                 .setup = alc663_mode1_setup,
17890                 .init_hook = alc663_mode1_inithook,
17891         },
17892         [ALC662_ASUS_MODE2] = {
17893                 .mixers = { alc662_1bjd_mixer },
17894                 .cap_mixer = alc662_auto_capture_mixer,
17895                 .init_verbs = { alc662_init_verbs,
17896                                 alc662_1bjd_amic_init_verbs },
17897                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17898                 .dac_nids = alc662_dac_nids,
17899                 .dig_out_nid = ALC662_DIGOUT_NID,
17900                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17901                 .channel_mode = alc662_3ST_2ch_modes,
17902                 .unsol_event = alc662_mode2_unsol_event,
17903                 .setup = alc662_mode2_setup,
17904                 .init_hook = alc662_mode2_inithook,
17905         },
17906         [ALC663_ASUS_MODE3] = {
17907                 .mixers = { alc663_two_hp_m1_mixer },
17908                 .cap_mixer = alc662_auto_capture_mixer,
17909                 .init_verbs = { alc662_init_verbs,
17910                                 alc663_two_hp_amic_m1_init_verbs },
17911                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17912                 .hp_nid = 0x03,
17913                 .dac_nids = alc662_dac_nids,
17914                 .dig_out_nid = ALC662_DIGOUT_NID,
17915                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17916                 .channel_mode = alc662_3ST_2ch_modes,
17917                 .unsol_event = alc663_mode3_unsol_event,
17918                 .setup = alc663_mode3_setup,
17919                 .init_hook = alc663_mode3_inithook,
17920         },
17921         [ALC663_ASUS_MODE4] = {
17922                 .mixers = { alc663_asus_21jd_clfe_mixer },
17923                 .cap_mixer = alc662_auto_capture_mixer,
17924                 .init_verbs = { alc662_init_verbs,
17925                                 alc663_21jd_amic_init_verbs},
17926                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17927                 .hp_nid = 0x03,
17928                 .dac_nids = alc662_dac_nids,
17929                 .dig_out_nid = ALC662_DIGOUT_NID,
17930                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17931                 .channel_mode = alc662_3ST_2ch_modes,
17932                 .unsol_event = alc663_mode4_unsol_event,
17933                 .setup = alc663_mode4_setup,
17934                 .init_hook = alc663_mode4_inithook,
17935         },
17936         [ALC663_ASUS_MODE5] = {
17937                 .mixers = { alc663_asus_15jd_clfe_mixer },
17938                 .cap_mixer = alc662_auto_capture_mixer,
17939                 .init_verbs = { alc662_init_verbs,
17940                                 alc663_15jd_amic_init_verbs },
17941                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17942                 .hp_nid = 0x03,
17943                 .dac_nids = alc662_dac_nids,
17944                 .dig_out_nid = ALC662_DIGOUT_NID,
17945                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17946                 .channel_mode = alc662_3ST_2ch_modes,
17947                 .unsol_event = alc663_mode5_unsol_event,
17948                 .setup = alc663_mode5_setup,
17949                 .init_hook = alc663_mode5_inithook,
17950         },
17951         [ALC663_ASUS_MODE6] = {
17952                 .mixers = { alc663_two_hp_m2_mixer },
17953                 .cap_mixer = alc662_auto_capture_mixer,
17954                 .init_verbs = { alc662_init_verbs,
17955                                 alc663_two_hp_amic_m2_init_verbs },
17956                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17957                 .hp_nid = 0x03,
17958                 .dac_nids = alc662_dac_nids,
17959                 .dig_out_nid = ALC662_DIGOUT_NID,
17960                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17961                 .channel_mode = alc662_3ST_2ch_modes,
17962                 .unsol_event = alc663_mode6_unsol_event,
17963                 .setup = alc663_mode6_setup,
17964                 .init_hook = alc663_mode6_inithook,
17965         },
17966         [ALC663_ASUS_MODE7] = {
17967                 .mixers = { alc663_mode7_mixer },
17968                 .cap_mixer = alc662_auto_capture_mixer,
17969                 .init_verbs = { alc662_init_verbs,
17970                                 alc663_mode7_init_verbs },
17971                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17972                 .hp_nid = 0x03,
17973                 .dac_nids = alc662_dac_nids,
17974                 .dig_out_nid = ALC662_DIGOUT_NID,
17975                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17976                 .channel_mode = alc662_3ST_2ch_modes,
17977                 .unsol_event = alc663_mode7_unsol_event,
17978                 .setup = alc663_mode7_setup,
17979                 .init_hook = alc663_mode7_inithook,
17980         },
17981         [ALC663_ASUS_MODE8] = {
17982                 .mixers = { alc663_mode8_mixer },
17983                 .cap_mixer = alc662_auto_capture_mixer,
17984                 .init_verbs = { alc662_init_verbs,
17985                                 alc663_mode8_init_verbs },
17986                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17987                 .hp_nid = 0x03,
17988                 .dac_nids = alc662_dac_nids,
17989                 .dig_out_nid = ALC662_DIGOUT_NID,
17990                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17991                 .channel_mode = alc662_3ST_2ch_modes,
17992                 .unsol_event = alc663_mode8_unsol_event,
17993                 .setup = alc663_mode8_setup,
17994                 .init_hook = alc663_mode8_inithook,
17995         },
17996         [ALC272_DELL] = {
17997                 .mixers = { alc663_m51va_mixer },
17998                 .cap_mixer = alc272_auto_capture_mixer,
17999                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18000                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18001                 .dac_nids = alc662_dac_nids,
18002                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18003                 .adc_nids = alc272_adc_nids,
18004                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18005                 .capsrc_nids = alc272_capsrc_nids,
18006                 .channel_mode = alc662_3ST_2ch_modes,
18007                 .unsol_event = alc663_m51va_unsol_event,
18008                 .setup = alc663_m51va_setup,
18009                 .init_hook = alc663_m51va_inithook,
18010         },
18011         [ALC272_DELL_ZM1] = {
18012                 .mixers = { alc663_m51va_mixer },
18013                 .cap_mixer = alc662_auto_capture_mixer,
18014                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18015                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18016                 .dac_nids = alc662_dac_nids,
18017                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18018                 .adc_nids = alc662_adc_nids,
18019                 .num_adc_nids = 1,
18020                 .capsrc_nids = alc662_capsrc_nids,
18021                 .channel_mode = alc662_3ST_2ch_modes,
18022                 .unsol_event = alc663_m51va_unsol_event,
18023                 .setup = alc663_m51va_setup,
18024                 .init_hook = alc663_m51va_inithook,
18025         },
18026         [ALC272_SAMSUNG_NC10] = {
18027                 .mixers = { alc272_nc10_mixer },
18028                 .init_verbs = { alc662_init_verbs,
18029                                 alc663_21jd_amic_init_verbs },
18030                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18031                 .dac_nids = alc272_dac_nids,
18032                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18033                 .channel_mode = alc662_3ST_2ch_modes,
18034                 /*.input_mux = &alc272_nc10_capture_source,*/
18035                 .unsol_event = alc663_mode4_unsol_event,
18036                 .setup = alc663_mode4_setup,
18037                 .init_hook = alc663_mode4_inithook,
18038         },
18039 };
18040
18041
18042 /*
18043  * BIOS auto configuration
18044  */
18045
18046 /* convert from MIX nid to DAC */
18047 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18048 {
18049         if (nid == 0x0f)
18050                 return 0x02;
18051         else if (nid >= 0x0c && nid <= 0x0e)
18052                 return nid - 0x0c + 0x02;
18053         else
18054                 return 0;
18055 }
18056
18057 /* get MIX nid connected to the given pin targeted to DAC */
18058 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18059                                    hda_nid_t dac)
18060 {
18061         hda_nid_t mix[4];
18062         int i, num;
18063
18064         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18065         for (i = 0; i < num; i++) {
18066                 if (alc662_mix_to_dac(mix[i]) == dac)
18067                         return mix[i];
18068         }
18069         return 0;
18070 }
18071
18072 /* look for an empty DAC slot */
18073 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18074 {
18075         struct alc_spec *spec = codec->spec;
18076         hda_nid_t srcs[5];
18077         int i, j, num;
18078
18079         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18080         if (num < 0)
18081                 return 0;
18082         for (i = 0; i < num; i++) {
18083                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18084                 if (!nid)
18085                         continue;
18086                 for (j = 0; j < spec->multiout.num_dacs; j++)
18087                         if (spec->multiout.dac_nids[j] == nid)
18088                                 break;
18089                 if (j >= spec->multiout.num_dacs)
18090                         return nid;
18091         }
18092         return 0;
18093 }
18094
18095 /* fill in the dac_nids table from the parsed pin configuration */
18096 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18097                                      const struct auto_pin_cfg *cfg)
18098 {
18099         struct alc_spec *spec = codec->spec;
18100         int i;
18101         hda_nid_t dac;
18102
18103         spec->multiout.dac_nids = spec->private_dac_nids;
18104         for (i = 0; i < cfg->line_outs; i++) {
18105                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18106                 if (!dac)
18107                         continue;
18108                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18109         }
18110         return 0;
18111 }
18112
18113 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18114                               hda_nid_t nid, unsigned int chs)
18115 {
18116         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18117                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18118 }
18119
18120 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18121                              hda_nid_t nid, unsigned int chs)
18122 {
18123         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18124                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18125 }
18126
18127 #define alc662_add_stereo_vol(spec, pfx, nid) \
18128         alc662_add_vol_ctl(spec, pfx, nid, 3)
18129 #define alc662_add_stereo_sw(spec, pfx, nid) \
18130         alc662_add_sw_ctl(spec, pfx, nid, 3)
18131
18132 /* add playback controls from the parsed DAC table */
18133 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18134                                              const struct auto_pin_cfg *cfg)
18135 {
18136         struct alc_spec *spec = codec->spec;
18137         static const char *chname[4] = {
18138                 "Front", "Surround", NULL /*CLFE*/, "Side"
18139         };
18140         hda_nid_t nid, mix;
18141         int i, err;
18142
18143         for (i = 0; i < cfg->line_outs; i++) {
18144                 nid = spec->multiout.dac_nids[i];
18145                 if (!nid)
18146                         continue;
18147                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18148                 if (!mix)
18149                         continue;
18150                 if (i == 2) {
18151                         /* Center/LFE */
18152                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18153                         if (err < 0)
18154                                 return err;
18155                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
18156                         if (err < 0)
18157                                 return err;
18158                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
18159                         if (err < 0)
18160                                 return err;
18161                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
18162                         if (err < 0)
18163                                 return err;
18164                 } else {
18165                         const char *pfx;
18166                         if (cfg->line_outs == 1 &&
18167                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
18168                                 if (cfg->hp_outs)
18169                                         pfx = "Speaker";
18170                                 else
18171                                         pfx = "PCM";
18172                         } else
18173                                 pfx = chname[i];
18174                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18175                         if (err < 0)
18176                                 return err;
18177                         if (cfg->line_outs == 1 &&
18178                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
18179                                 pfx = "Speaker";
18180                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18181                         if (err < 0)
18182                                 return err;
18183                 }
18184         }
18185         return 0;
18186 }
18187
18188 /* add playback controls for speaker and HP outputs */
18189 /* return DAC nid if any new DAC is assigned */
18190 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
18191                                         const char *pfx)
18192 {
18193         struct alc_spec *spec = codec->spec;
18194         hda_nid_t nid, mix;
18195         int err;
18196
18197         if (!pin)
18198                 return 0;
18199         nid = alc662_look_for_dac(codec, pin);
18200         if (!nid) {
18201                 /* the corresponding DAC is already occupied */
18202                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
18203                         return 0; /* no way */
18204                 /* create a switch only */
18205                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18206                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
18207         }
18208
18209         mix = alc662_dac_to_mix(codec, pin, nid);
18210         if (!mix)
18211                 return 0;
18212         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18213         if (err < 0)
18214                 return err;
18215         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18216         if (err < 0)
18217                 return err;
18218         return nid;
18219 }
18220
18221 /* create playback/capture controls for input pins */
18222 #define alc662_auto_create_input_ctls \
18223         alc882_auto_create_input_ctls
18224
18225 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
18226                                               hda_nid_t nid, int pin_type,
18227                                               hda_nid_t dac)
18228 {
18229         int i, num;
18230         hda_nid_t srcs[4];
18231
18232         alc_set_pin_output(codec, nid, pin_type);
18233         /* need the manual connection? */
18234         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
18235         if (num <= 1)
18236                 return;
18237         for (i = 0; i < num; i++) {
18238                 if (alc662_mix_to_dac(srcs[i]) != dac)
18239                         continue;
18240                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
18241                 return;
18242         }
18243 }
18244
18245 static void alc662_auto_init_multi_out(struct hda_codec *codec)
18246 {
18247         struct alc_spec *spec = codec->spec;
18248         int pin_type = get_pin_type(spec->autocfg.line_out_type);
18249         int i;
18250
18251         for (i = 0; i <= HDA_SIDE; i++) {
18252                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
18253                 if (nid)
18254                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
18255                                         spec->multiout.dac_nids[i]);
18256         }
18257 }
18258
18259 static void alc662_auto_init_hp_out(struct hda_codec *codec)
18260 {
18261         struct alc_spec *spec = codec->spec;
18262         hda_nid_t pin;
18263
18264         pin = spec->autocfg.hp_pins[0];
18265         if (pin)
18266                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
18267                                                   spec->multiout.hp_nid);
18268         pin = spec->autocfg.speaker_pins[0];
18269         if (pin)
18270                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
18271                                         spec->multiout.extra_out_nid[0]);
18272 }
18273
18274 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
18275
18276 static void alc662_auto_init_analog_input(struct hda_codec *codec)
18277 {
18278         struct alc_spec *spec = codec->spec;
18279         int i;
18280
18281         for (i = 0; i < AUTO_PIN_LAST; i++) {
18282                 hda_nid_t nid = spec->autocfg.input_pins[i];
18283                 if (alc_is_input_pin(codec, nid)) {
18284                         alc_set_input_pin(codec, nid, i);
18285                         if (nid != ALC662_PIN_CD_NID &&
18286                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
18287                                 snd_hda_codec_write(codec, nid, 0,
18288                                                     AC_VERB_SET_AMP_GAIN_MUTE,
18289                                                     AMP_OUT_MUTE);
18290                 }
18291         }
18292 }
18293
18294 #define alc662_auto_init_input_src      alc882_auto_init_input_src
18295
18296 static int alc662_parse_auto_config(struct hda_codec *codec)
18297 {
18298         struct alc_spec *spec = codec->spec;
18299         int err;
18300         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
18301
18302         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
18303                                            alc662_ignore);
18304         if (err < 0)
18305                 return err;
18306         if (!spec->autocfg.line_outs)
18307                 return 0; /* can't find valid BIOS pin config */
18308
18309         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
18310         if (err < 0)
18311                 return err;
18312         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
18313         if (err < 0)
18314                 return err;
18315         err = alc662_auto_create_extra_out(codec,
18316                                            spec->autocfg.speaker_pins[0],
18317                                            "Speaker");
18318         if (err < 0)
18319                 return err;
18320         if (err)
18321                 spec->multiout.extra_out_nid[0] = err;
18322         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
18323                                            "Headphone");
18324         if (err < 0)
18325                 return err;
18326         if (err)
18327                 spec->multiout.hp_nid = err;
18328         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
18329         if (err < 0)
18330                 return err;
18331
18332         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
18333
18334         if (spec->autocfg.dig_outs)
18335                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
18336
18337         if (spec->kctls.list)
18338                 add_mixer(spec, spec->kctls.list);
18339
18340         spec->num_mux_defs = 1;
18341         spec->input_mux = &spec->private_imux[0];
18342
18343         add_verb(spec, alc662_init_verbs);
18344         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18345             codec->vendor_id == 0x10ec0665)
18346                 add_verb(spec, alc663_init_verbs);
18347
18348         if (codec->vendor_id == 0x10ec0272)
18349                 add_verb(spec, alc272_init_verbs);
18350
18351         err = alc_auto_add_mic_boost(codec);
18352         if (err < 0)
18353                 return err;
18354
18355         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18356             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
18357             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
18358         else
18359             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
18360
18361         return 1;
18362 }
18363
18364 /* additional initialization for auto-configuration model */
18365 static void alc662_auto_init(struct hda_codec *codec)
18366 {
18367         struct alc_spec *spec = codec->spec;
18368         alc662_auto_init_multi_out(codec);
18369         alc662_auto_init_hp_out(codec);
18370         alc662_auto_init_analog_input(codec);
18371         alc662_auto_init_input_src(codec);
18372         if (spec->unsol_event)
18373                 alc_inithook(codec);
18374 }
18375
18376 static int patch_alc662(struct hda_codec *codec)
18377 {
18378         struct alc_spec *spec;
18379         int err, board_config;
18380
18381         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
18382         if (!spec)
18383                 return -ENOMEM;
18384
18385         codec->spec = spec;
18386
18387         alc_fix_pll_init(codec, 0x20, 0x04, 15);
18388
18389         if (alc_read_coef_idx(codec, 0)==0x8020){
18390                 kfree(codec->chip_name);
18391                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
18392                 if (!codec->chip_name) {
18393                         alc_free(codec);
18394                         return -ENOMEM;
18395                 }
18396         }
18397
18398         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
18399                                                   alc662_models,
18400                                                   alc662_cfg_tbl);
18401         if (board_config < 0) {
18402                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
18403                        codec->chip_name);
18404                 board_config = ALC662_AUTO;
18405         }
18406
18407         if (board_config == ALC662_AUTO) {
18408                 /* automatic parse from the BIOS config */
18409                 err = alc662_parse_auto_config(codec);
18410                 if (err < 0) {
18411                         alc_free(codec);
18412                         return err;
18413                 } else if (!err) {
18414                         printk(KERN_INFO
18415                                "hda_codec: Cannot set up configuration "
18416                                "from BIOS.  Using base mode...\n");
18417                         board_config = ALC662_3ST_2ch_DIG;
18418                 }
18419         }
18420
18421         err = snd_hda_attach_beep_device(codec, 0x1);
18422         if (err < 0) {
18423                 alc_free(codec);
18424                 return err;
18425         }
18426
18427         if (board_config != ALC662_AUTO)
18428                 setup_preset(codec, &alc662_presets[board_config]);
18429
18430         spec->stream_analog_playback = &alc662_pcm_analog_playback;
18431         spec->stream_analog_capture = &alc662_pcm_analog_capture;
18432
18433         spec->stream_digital_playback = &alc662_pcm_digital_playback;
18434         spec->stream_digital_capture = &alc662_pcm_digital_capture;
18435
18436         if (!spec->adc_nids) {
18437                 spec->adc_nids = alc662_adc_nids;
18438                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
18439         }
18440         if (!spec->capsrc_nids)
18441                 spec->capsrc_nids = alc662_capsrc_nids;
18442
18443         if (!spec->cap_mixer)
18444                 set_capture_mixer(codec);
18445
18446         switch (codec->vendor_id) {
18447         case 0x10ec0662:
18448                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
18449                 break;
18450         case 0x10ec0272:
18451         case 0x10ec0663:
18452         case 0x10ec0665:
18453                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
18454                 break;
18455         case 0x10ec0273:
18456                 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
18457                 break;
18458         }
18459         spec->vmaster_nid = 0x02;
18460
18461         codec->patch_ops = alc_patch_ops;
18462         if (board_config == ALC662_AUTO)
18463                 spec->init_hook = alc662_auto_init;
18464 #ifdef CONFIG_SND_HDA_POWER_SAVE
18465         if (!spec->loopback.amplist)
18466                 spec->loopback.amplist = alc662_loopbacks;
18467 #endif
18468
18469         return 0;
18470 }
18471
18472 static int patch_alc888(struct hda_codec *codec)
18473 {
18474         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
18475                 kfree(codec->chip_name);
18476                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
18477                 if (!codec->chip_name) {
18478                         alc_free(codec);
18479                         return -ENOMEM;
18480                 }
18481                 return patch_alc662(codec);
18482         }
18483         return patch_alc882(codec);
18484 }
18485
18486 /*
18487  * patch entries
18488  */
18489 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18490         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18491         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18492         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18493         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18494         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18495         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18496         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18497         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18498         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18499           .patch = patch_alc861 },
18500         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18501         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18502         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18503         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18504           .patch = patch_alc882 },
18505         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18506           .patch = patch_alc662 },
18507         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18508         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
18509         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
18510         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18511         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18512         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18513         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18514           .patch = patch_alc882 },
18515         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18516           .patch = patch_alc882 },
18517         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18518         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18519         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18520           .patch = patch_alc882 },
18521         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18522         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18523         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18524         {} /* terminator */
18525 };
18526
18527 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18528
18529 MODULE_LICENSE("GPL");
18530 MODULE_DESCRIPTION("Realtek HD-audio codec");
18531
18532 static struct hda_codec_preset_list realtek_list = {
18533         .preset = snd_hda_preset_realtek,
18534         .owner = THIS_MODULE,
18535 };
18536
18537 static int __init patch_realtek_init(void)
18538 {
18539         return snd_hda_add_codec_preset(&realtek_list);
18540 }
18541
18542 static void __exit patch_realtek_exit(void)
18543 {
18544         snd_hda_delete_codec_preset(&realtek_list);
18545 }
18546
18547 module_init(patch_realtek_init)
18548 module_exit(patch_realtek_exit)