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_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC662_AUTO,
 192         ALC662_MODEL_LAST,
 193 };
 194
 195 /* ALC882 models */
 196 enum {
 197         ALC882_3ST_DIG,
 198         ALC882_6ST_DIG,
 199         ALC882_ARIMA,
 200         ALC882_W2JC,
 201         ALC882_TARGA,
 202         ALC882_ASUS_A7J,
 203         ALC882_ASUS_A7M,
 204         ALC885_MACPRO,
 205         ALC885_MBP3,
 206         ALC885_IMAC24,
 207         ALC882_AUTO,
 208         ALC882_MODEL_LAST,
 209 };
 210
 211 /* ALC883 models */
 212 enum {
 213         ALC883_3ST_2ch_DIG,
 214         ALC883_3ST_6ch_DIG,
 215         ALC883_3ST_6ch,
 216         ALC883_6ST_DIG,
 217         ALC883_TARGA_DIG,
 218         ALC883_TARGA_2ch_DIG,
 219         ALC883_ACER,
 220         ALC883_ACER_ASPIRE,
 221         ALC888_ACER_ASPIRE_4930G,
 222         ALC883_MEDION,
 223         ALC883_MEDION_MD2,
 224         ALC883_LAPTOP_EAPD,
 225         ALC883_LENOVO_101E_2ch,
 226         ALC883_LENOVO_NB0763,
 227         ALC888_LENOVO_MS7195_DIG,
 228         ALC888_LENOVO_SKY,
 229         ALC883_HAIER_W66,
 230         ALC888_3ST_HP,
 231         ALC888_6ST_DELL,
 232         ALC883_MITAC,
 233         ALC883_CLEVO_M720,
 234         ALC883_FUJITSU_PI2515,
 235         ALC888_FUJITSU_XA3530,
 236         ALC883_3ST_6ch_INTEL,
 237         ALC888_ASUS_M90V,
 238         ALC888_ASUS_EEE1601,
 239         ALC1200_ASUS_P5Q,
 240         ALC883_AUTO,
 241         ALC883_MODEL_LAST,
 242 };
 243
 244 /* styles of capture selection */
 245 enum {
 246         CAPT_MUX = 0,   /* only mux based */
 247         CAPT_MIX,       /* only mixer based */
 248         CAPT_1MUX_MIX,  /* first mux and other mixers */
 249 };
 250
 251 /* for GPIO Poll */
 252 #define GPIO_MASK       0x03
 253
 254 struct alc_spec {
 255         /* codec parameterization */
 256         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 257         unsigned int num_mixers;
 258         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 259         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 260
 261         const struct hda_verb *init_verbs[5];   /* initialization verbs
 262                                                  * don't forget NULL
 263                                                  * termination!
 264                                                  */
 265         unsigned int num_init_verbs;
 266
 267         char *stream_name_analog;       /* analog PCM stream */
 268         struct hda_pcm_stream *stream_analog_playback;
 269         struct hda_pcm_stream *stream_analog_capture;
 270         struct hda_pcm_stream *stream_analog_alt_playback;
 271         struct hda_pcm_stream *stream_analog_alt_capture;
 272
 273         char *stream_name_digital;      /* digital PCM stream */
 274         struct hda_pcm_stream *stream_digital_playback;
 275         struct hda_pcm_stream *stream_digital_capture;
 276
 277         /* playback */
 278         struct hda_multi_out multiout;  /* playback set-up
 279                                          * max_channels, dacs must be set
 280                                          * dig_out_nid and hp_nid are optional
 281                                          */
 282         hda_nid_t alt_dac_nid;
 283         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 284         int dig_out_type;
 285
 286         /* capture */
 287         unsigned int num_adc_nids;
 288         hda_nid_t *adc_nids;
 289         hda_nid_t *capsrc_nids;
 290         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 291         int capture_style;              /* capture style (CAPT_*) */
 292
 293         /* capture source */
 294         unsigned int num_mux_defs;
 295         const struct hda_input_mux *input_mux;
 296         unsigned int cur_mux[3];
 297
 298         /* channel model */
 299         const struct hda_channel_mode *channel_mode;
 300         int num_channel_mode;
 301         int need_dac_fix;
 302
 303         /* PCM information */
 304         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 305
 306         /* dynamic controls, init_verbs and input_mux */
 307         struct auto_pin_cfg autocfg;
 308         struct snd_array kctls;
 309         struct hda_input_mux private_imux[3];
 310         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 311
 312         /* hooks */
 313         void (*init_hook)(struct hda_codec *codec);
 314         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 315
 316         /* for pin sensing */
 317         unsigned int sense_updated: 1;
 318         unsigned int jack_present: 1;
 319         unsigned int master_sw: 1;
 320
 321         /* other flags */
 322         unsigned int no_analog :1; /* digital I/O only */
 323
 324         /* for virtual master */
 325         hda_nid_t vmaster_nid;
 326 #ifdef CONFIG_SND_HDA_POWER_SAVE
 327         struct hda_loopback_check loopback;
 328 #endif
 329
 330         /* for PLL fix */
 331         hda_nid_t pll_nid;
 332         unsigned int pll_coef_idx, pll_coef_bit;
 333
 334 #ifdef SND_HDA_NEEDS_RESUME
 335 #define ALC_MAX_PINS    16
 336         unsigned int num_pins;
 337         hda_nid_t pin_nids[ALC_MAX_PINS];
 338         unsigned int pin_cfgs[ALC_MAX_PINS];
 339 #endif
 340 };
 341
 342 /*
 343  * configuration template - to be copied to the spec instance
 344  */
 345 struct alc_config_preset {
 346         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 347                                              * with spec
 348                                              */
 349         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 350         const struct hda_verb *init_verbs[5];
 351         unsigned int num_dacs;
 352         hda_nid_t *dac_nids;
 353         hda_nid_t dig_out_nid;          /* optional */
 354         hda_nid_t hp_nid;               /* optional */
 355         hda_nid_t *slave_dig_outs;
 356         unsigned int num_adc_nids;
 357         hda_nid_t *adc_nids;
 358         hda_nid_t *capsrc_nids;
 359         hda_nid_t dig_in_nid;
 360         unsigned int num_channel_mode;
 361         const struct hda_channel_mode *channel_mode;
 362         int need_dac_fix;
 363         unsigned int num_mux_defs;
 364         const struct hda_input_mux *input_mux;
 365         void (*unsol_event)(struct hda_codec *, unsigned int);
 366         void (*init_hook)(struct hda_codec *);
 367 #ifdef CONFIG_SND_HDA_POWER_SAVE
 368         struct hda_amp_list *loopbacks;
 369 #endif
 370 };
 371
 372
 373 /*
 374  * input MUX handling
 375  */
 376 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 377                              struct snd_ctl_elem_info *uinfo)
 378 {
 379         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 380         struct alc_spec *spec = codec->spec;
 381         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 382         if (mux_idx >= spec->num_mux_defs)
 383                 mux_idx = 0;
 384         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 385 }
 386
 387 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 388                             struct snd_ctl_elem_value *ucontrol)
 389 {
 390         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 391         struct alc_spec *spec = codec->spec;
 392         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 393
 394         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 395         return 0;
 396 }
 397
 398 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 399                             struct snd_ctl_elem_value *ucontrol)
 400 {
 401         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 402         struct alc_spec *spec = codec->spec;
 403         const struct hda_input_mux *imux;
 404         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 405         unsigned int mux_idx;
 406         hda_nid_t nid = spec->capsrc_nids ?
 407                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 408
 409         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 410         imux = &spec->input_mux[mux_idx];
 411
 412         if (spec->capture_style &&
 413             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 414                 /* Matrix-mixer style (e.g. ALC882) */
 415                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 416                 unsigned int i, idx;
 417
 418                 idx = ucontrol->value.enumerated.item[0];
 419                 if (idx >= imux->num_items)
 420                         idx = imux->num_items - 1;
 421                 if (*cur_val == idx)
 422                         return 0;
 423                 for (i = 0; i < imux->num_items; i++) {
 424                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 425                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 426                                                  imux->items[i].index,
 427                                                  HDA_AMP_MUTE, v);
 428                 }
 429                 *cur_val = idx;
 430                 return 1;
 431         } else {
 432                 /* MUX style (e.g. ALC880) */
 433                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 434                                              &spec->cur_mux[adc_idx]);
 435         }
 436 }
 437
 438 /*
 439  * channel mode setting
 440  */
 441 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 442                             struct snd_ctl_elem_info *uinfo)
 443 {
 444         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 445         struct alc_spec *spec = codec->spec;
 446         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 447                                     spec->num_channel_mode);
 448 }
 449
 450 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 451                            struct snd_ctl_elem_value *ucontrol)
 452 {
 453         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 454         struct alc_spec *spec = codec->spec;
 455         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 456                                    spec->num_channel_mode,
 457                                    spec->multiout.max_channels);
 458 }
 459
 460 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 461                            struct snd_ctl_elem_value *ucontrol)
 462 {
 463         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 464         struct alc_spec *spec = codec->spec;
 465         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 466                                       spec->num_channel_mode,
 467                                       &spec->multiout.max_channels);
 468         if (err >= 0 && spec->need_dac_fix)
 469                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 470         return err;
 471 }
 472
 473 /*
 474  * Control the mode of pin widget settings via the mixer.  "pc" is used
 475  * instead of "%" to avoid consequences of accidently treating the % as
 476  * being part of a format specifier.  Maximum allowed length of a value is
 477  * 63 characters plus NULL terminator.
 478  *
 479  * Note: some retasking pin complexes seem to ignore requests for input
 480  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 481  * are requested.  Therefore order this list so that this behaviour will not
 482  * cause problems when mixer clients move through the enum sequentially.
 483  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 484  * March 2006.
 485  */
 486 static char *alc_pin_mode_names[] = {
 487         "Mic 50pc bias", "Mic 80pc bias",
 488         "Line in", "Line out", "Headphone out",
 489 };
 490 static unsigned char alc_pin_mode_values[] = {
 491         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 492 };
 493 /* The control can present all 5 options, or it can limit the options based
 494  * in the pin being assumed to be exclusively an input or an output pin.  In
 495  * addition, "input" pins may or may not process the mic bias option
 496  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 497  * accept requests for bias as of chip versions up to March 2006) and/or
 498  * wiring in the computer.
 499  */
 500 #define ALC_PIN_DIR_IN              0x00
 501 #define ALC_PIN_DIR_OUT             0x01
 502 #define ALC_PIN_DIR_INOUT           0x02
 503 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 504 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 505
 506 /* Info about the pin modes supported by the different pin direction modes.
 507  * For each direction the minimum and maximum values are given.
 508  */
 509 static signed char alc_pin_mode_dir_info[5][2] = {
 510         { 0, 2 },    /* ALC_PIN_DIR_IN */
 511         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 512         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 513         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 514         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 515 };
 516 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 517 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 518 #define alc_pin_mode_n_items(_dir) \
 519         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 520
 521 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 522                              struct snd_ctl_elem_info *uinfo)
 523 {
 524         unsigned int item_num = uinfo->value.enumerated.item;
 525         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 526
 527         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 528         uinfo->count = 1;
 529         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 530
 531         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 532                 item_num = alc_pin_mode_min(dir);
 533         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 534         return 0;
 535 }
 536
 537 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 538                             struct snd_ctl_elem_value *ucontrol)
 539 {
 540         unsigned int i;
 541         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 542         hda_nid_t nid = kcontrol->private_value & 0xffff;
 543         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 544         long *valp = ucontrol->value.integer.value;
 545         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 546                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 547                                                  0x00);
 548
 549         /* Find enumerated value for current pinctl setting */
 550         i = alc_pin_mode_min(dir);
 551         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 552                 i++;
 553         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 554         return 0;
 555 }
 556
 557 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 558                             struct snd_ctl_elem_value *ucontrol)
 559 {
 560         signed int change;
 561         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 562         hda_nid_t nid = kcontrol->private_value & 0xffff;
 563         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 564         long val = *ucontrol->value.integer.value;
 565         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 566                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 567                                                  0x00);
 568
 569         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 570                 val = alc_pin_mode_min(dir);
 571
 572         change = pinctl != alc_pin_mode_values[val];
 573         if (change) {
 574                 /* Set pin mode to that requested */
 575                 snd_hda_codec_write_cache(codec, nid, 0,
 576                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 577                                           alc_pin_mode_values[val]);
 578
 579                 /* Also enable the retasking pin's input/output as required
 580                  * for the requested pin mode.  Enum values of 2 or less are
 581                  * input modes.
 582                  *
 583                  * Dynamically switching the input/output buffers probably
 584                  * reduces noise slightly (particularly on input) so we'll
 585                  * do it.  However, having both input and output buffers
 586                  * enabled simultaneously doesn't seem to be problematic if
 587                  * this turns out to be necessary in the future.
 588                  */
 589                 if (val <= 2) {
 590                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 591                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 592                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 593                                                  HDA_AMP_MUTE, 0);
 594                 } else {
 595                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 596                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 597                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 598                                                  HDA_AMP_MUTE, 0);
 599                 }
 600         }
 601         return change;
 602 }
 603
 604 #define ALC_PIN_MODE(xname, nid, dir) \
 605         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 606           .info = alc_pin_mode_info, \
 607           .get = alc_pin_mode_get, \
 608           .put = alc_pin_mode_put, \
 609           .private_value = nid | (dir<<16) }
 610
 611 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 612  * together using a mask with more than one bit set.  This control is
 613  * currently used only by the ALC260 test model.  At this stage they are not
 614  * needed for any "production" models.
 615  */
 616 #ifdef CONFIG_SND_DEBUG
 617 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 618
 619 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 620                              struct snd_ctl_elem_value *ucontrol)
 621 {
 622         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 623         hda_nid_t nid = kcontrol->private_value & 0xffff;
 624         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 625         long *valp = ucontrol->value.integer.value;
 626         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 627                                               AC_VERB_GET_GPIO_DATA, 0x00);
 628
 629         *valp = (val & mask) != 0;
 630         return 0;
 631 }
 632 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 633                              struct snd_ctl_elem_value *ucontrol)
 634 {
 635         signed int change;
 636         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 637         hda_nid_t nid = kcontrol->private_value & 0xffff;
 638         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 639         long val = *ucontrol->value.integer.value;
 640         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 641                                                     AC_VERB_GET_GPIO_DATA,
 642                                                     0x00);
 643
 644         /* Set/unset the masked GPIO bit(s) as needed */
 645         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 646         if (val == 0)
 647                 gpio_data &= ~mask;
 648         else
 649                 gpio_data |= mask;
 650         snd_hda_codec_write_cache(codec, nid, 0,
 651                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 652
 653         return change;
 654 }
 655 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 656         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 657           .info = alc_gpio_data_info, \
 658           .get = alc_gpio_data_get, \
 659           .put = alc_gpio_data_put, \
 660           .private_value = nid | (mask<<16) }
 661 #endif   /* CONFIG_SND_DEBUG */
 662
 663 /* A switch control to allow the enabling of the digital IO pins on the
 664  * ALC260.  This is incredibly simplistic; the intention of this control is
 665  * to provide something in the test model allowing digital outputs to be
 666  * identified if present.  If models are found which can utilise these
 667  * outputs a more complete mixer control can be devised for those models if
 668  * necessary.
 669  */
 670 #ifdef CONFIG_SND_DEBUG
 671 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 672
 673 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 674                               struct snd_ctl_elem_value *ucontrol)
 675 {
 676         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 677         hda_nid_t nid = kcontrol->private_value & 0xffff;
 678         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 679         long *valp = ucontrol->value.integer.value;
 680         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 681                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 682
 683         *valp = (val & mask) != 0;
 684         return 0;
 685 }
 686 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 687                               struct snd_ctl_elem_value *ucontrol)
 688 {
 689         signed int change;
 690         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 691         hda_nid_t nid = kcontrol->private_value & 0xffff;
 692         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 693         long val = *ucontrol->value.integer.value;
 694         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 695                                                     AC_VERB_GET_DIGI_CONVERT_1,
 696                                                     0x00);
 697
 698         /* Set/unset the masked control bit(s) as needed */
 699         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 700         if (val==0)
 701                 ctrl_data &= ~mask;
 702         else
 703                 ctrl_data |= mask;
 704         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 705                                   ctrl_data);
 706
 707         return change;
 708 }
 709 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 710         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 711           .info = alc_spdif_ctrl_info, \
 712           .get = alc_spdif_ctrl_get, \
 713           .put = alc_spdif_ctrl_put, \
 714           .private_value = nid | (mask<<16) }
 715 #endif   /* CONFIG_SND_DEBUG */
 716
 717 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 718  * Again, this is only used in the ALC26x test models to help identify when
 719  * the EAPD line must be asserted for features to work.
 720  */
 721 #ifdef CONFIG_SND_DEBUG
 722 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 723
 724 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 725                               struct snd_ctl_elem_value *ucontrol)
 726 {
 727         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 728         hda_nid_t nid = kcontrol->private_value & 0xffff;
 729         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 730         long *valp = ucontrol->value.integer.value;
 731         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 732                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 733
 734         *valp = (val & mask) != 0;
 735         return 0;
 736 }
 737
 738 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 739                               struct snd_ctl_elem_value *ucontrol)
 740 {
 741         int change;
 742         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 743         hda_nid_t nid = kcontrol->private_value & 0xffff;
 744         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 745         long val = *ucontrol->value.integer.value;
 746         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 747                                                     AC_VERB_GET_EAPD_BTLENABLE,
 748                                                     0x00);
 749
 750         /* Set/unset the masked control bit(s) as needed */
 751         change = (!val ? 0 : mask) != (ctrl_data & mask);
 752         if (!val)
 753                 ctrl_data &= ~mask;
 754         else
 755                 ctrl_data |= mask;
 756         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 757                                   ctrl_data);
 758
 759         return change;
 760 }
 761
 762 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 763         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 764           .info = alc_eapd_ctrl_info, \
 765           .get = alc_eapd_ctrl_get, \
 766           .put = alc_eapd_ctrl_put, \
 767           .private_value = nid | (mask<<16) }
 768 #endif   /* CONFIG_SND_DEBUG */
 769
 770 /*
 771  */
 772 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 773 {
 774         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 775                 return;
 776         spec->mixers[spec->num_mixers++] = mix;
 777 }
 778
 779 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 780 {
 781         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 782                 return;
 783         spec->init_verbs[spec->num_init_verbs++] = verb;
 784 }
 785
 786 #ifdef CONFIG_PROC_FS
 787 /*
 788  * hook for proc
 789  */
 790 static void print_realtek_coef(struct snd_info_buffer *buffer,
 791                                struct hda_codec *codec, hda_nid_t nid)
 792 {
 793         int coeff;
 794
 795         if (nid != 0x20)
 796                 return;
 797         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 798         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 799         coeff = snd_hda_codec_read(codec, nid, 0,
 800                                    AC_VERB_GET_COEF_INDEX, 0);
 801         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 802 }
 803 #else
 804 #define print_realtek_coef      NULL
 805 #endif
 806
 807 /*
 808  * set up from the preset table
 809  */
 810 static void setup_preset(struct alc_spec *spec,
 811                          const struct alc_config_preset *preset)
 812 {
 813         int i;
 814
 815         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 816                 add_mixer(spec, preset->mixers[i]);
 817         spec->cap_mixer = preset->cap_mixer;
 818         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 819              i++)
 820                 add_verb(spec, preset->init_verbs[i]);
 821
 822         spec->channel_mode = preset->channel_mode;
 823         spec->num_channel_mode = preset->num_channel_mode;
 824         spec->need_dac_fix = preset->need_dac_fix;
 825
 826         spec->multiout.max_channels = spec->channel_mode[0].channels;
 827
 828         spec->multiout.num_dacs = preset->num_dacs;
 829         spec->multiout.dac_nids = preset->dac_nids;
 830         spec->multiout.dig_out_nid = preset->dig_out_nid;
 831         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 832         spec->multiout.hp_nid = preset->hp_nid;
 833
 834         spec->num_mux_defs = preset->num_mux_defs;
 835         if (!spec->num_mux_defs)
 836                 spec->num_mux_defs = 1;
 837         spec->input_mux = preset->input_mux;
 838
 839         spec->num_adc_nids = preset->num_adc_nids;
 840         spec->adc_nids = preset->adc_nids;
 841         spec->capsrc_nids = preset->capsrc_nids;
 842         spec->dig_in_nid = preset->dig_in_nid;
 843
 844         spec->unsol_event = preset->unsol_event;
 845         spec->init_hook = preset->init_hook;
 846 #ifdef CONFIG_SND_HDA_POWER_SAVE
 847         spec->loopback.amplist = preset->loopbacks;
 848 #endif
 849 }
 850
 851 /* Enable GPIO mask and set output */
 852 static struct hda_verb alc_gpio1_init_verbs[] = {
 853         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 854         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 855         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 856         { }
 857 };
 858
 859 static struct hda_verb alc_gpio2_init_verbs[] = {
 860         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 861         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 862         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 863         { }
 864 };
 865
 866 static struct hda_verb alc_gpio3_init_verbs[] = {
 867         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 868         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 869         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 870         { }
 871 };
 872
 873 /*
 874  * Fix hardware PLL issue
 875  * On some codecs, the analog PLL gating control must be off while
 876  * the default value is 1.
 877  */
 878 static void alc_fix_pll(struct hda_codec *codec)
 879 {
 880         struct alc_spec *spec = codec->spec;
 881         unsigned int val;
 882
 883         if (!spec->pll_nid)
 884                 return;
 885         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 886                             spec->pll_coef_idx);
 887         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 888                                  AC_VERB_GET_PROC_COEF, 0);
 889         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 890                             spec->pll_coef_idx);
 891         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 892                             val & ~(1 << spec->pll_coef_bit));
 893 }
 894
 895 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 896                              unsigned int coef_idx, unsigned int coef_bit)
 897 {
 898         struct alc_spec *spec = codec->spec;
 899         spec->pll_nid = nid;
 900         spec->pll_coef_idx = coef_idx;
 901         spec->pll_coef_bit = coef_bit;
 902         alc_fix_pll(codec);
 903 }
 904
 905 static void alc_sku_automute(struct hda_codec *codec)
 906 {
 907         struct alc_spec *spec = codec->spec;
 908         unsigned int present;
 909         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 910         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 911
 912         /* need to execute and sync at first */
 913         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 914         present = snd_hda_codec_read(codec, hp_nid, 0,
 915                                      AC_VERB_GET_PIN_SENSE, 0);
 916         spec->jack_present = (present & 0x80000000) != 0;
 917         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 918                             spec->jack_present ? 0 : PIN_OUT);
 919 }
 920
 921 #if 0 /* it's broken in some acses -- temporarily disabled */
 922 static void alc_mic_automute(struct hda_codec *codec)
 923 {
 924         struct alc_spec *spec = codec->spec;
 925         unsigned int present;
 926         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 927         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 928         unsigned int mix_nid = spec->capsrc_nids[0];
 929         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 930
 931         capsrc_idx_mic = mic_nid - 0x18;
 932         capsrc_idx_fmic = fmic_nid - 0x18;
 933         present = snd_hda_codec_read(codec, mic_nid, 0,
 934                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 935         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 936                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 937         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 938                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 939         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 940                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 941 }
 942 #else
 943 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 944 #endif /* disabled */
 945
 946 /* unsolicited event for HP jack sensing */
 947 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 948 {
 949         if (codec->vendor_id == 0x10ec0880)
 950                 res >>= 28;
 951         else
 952                 res >>= 26;
 953         if (res == ALC880_HP_EVENT)
 954                 alc_sku_automute(codec);
 955
 956         if (res == ALC880_MIC_EVENT)
 957                 alc_mic_automute(codec);
 958 }
 959
 960 static void alc_inithook(struct hda_codec *codec)
 961 {
 962         alc_sku_automute(codec);
 963         alc_mic_automute(codec);
 964 }
 965
 966 /* additional initialization for ALC888 variants */
 967 static void alc888_coef_init(struct hda_codec *codec)
 968 {
 969         unsigned int tmp;
 970
 971         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 972         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 973         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 974         if ((tmp & 0xf0) == 2)
 975                 /* alc888S-VC */
 976                 snd_hda_codec_read(codec, 0x20, 0,
 977                                    AC_VERB_SET_PROC_COEF, 0x830);
 978          else
 979                  /* alc888-VB */
 980                  snd_hda_codec_read(codec, 0x20, 0,
 981                                     AC_VERB_SET_PROC_COEF, 0x3030);
 982 }
 983
 984 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 985  *      31 ~ 16 :       Manufacture ID
 986  *      15 ~ 8  :       SKU ID
 987  *      7  ~ 0  :       Assembly ID
 988  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 989  */
 990 static void alc_subsystem_id(struct hda_codec *codec,
 991                              unsigned int porta, unsigned int porte,
 992                              unsigned int portd)
 993 {
 994         unsigned int ass, tmp, i;
 995         unsigned nid;
 996         struct alc_spec *spec = codec->spec;
 997
 998         ass = codec->subsystem_id & 0xffff;
 999         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1000                 goto do_sku;
1001
1002         /*
1003          * 31~30        : port conetcivity
1004          * 29~21        : reserve
1005          * 20           : PCBEEP input
1006          * 19~16        : Check sum (15:1)
1007          * 15~1         : Custom
1008          * 0            : override
1009         */
1010         nid = 0x1d;
1011         if (codec->vendor_id == 0x10ec0260)
1012                 nid = 0x17;
1013         ass = snd_hda_codec_read(codec, nid, 0,
1014                                  AC_VERB_GET_CONFIG_DEFAULT, 0);
1015         if (!(ass & 1) && !(ass & 0x100000))
1016                 return;
1017         if ((ass >> 30) != 1)   /* no physical connection */
1018                 return;
1019
1020         /* check sum */
1021         tmp = 0;
1022         for (i = 1; i < 16; i++) {
1023                 if ((ass >> i) & 1)
1024                         tmp++;
1025         }
1026         if (((ass >> 16) & 0xf) != tmp)
1027                 return;
1028 do_sku:
1029         /*
1030          * 0 : override
1031          * 1 :  Swap Jack
1032          * 2 : 0 --> Desktop, 1 --> Laptop
1033          * 3~5 : External Amplifier control
1034          * 7~6 : Reserved
1035         */
1036         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1037         switch (tmp) {
1038         case 1:
1039                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1040                 break;
1041         case 3:
1042                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1043                 break;
1044         case 7:
1045                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1046                 break;
1047         case 5: /* set EAPD output high */
1048                 switch (codec->vendor_id) {
1049                 case 0x10ec0260:
1050                         snd_hda_codec_write(codec, 0x0f, 0,
1051                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1052                         snd_hda_codec_write(codec, 0x10, 0,
1053                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1054                         break;
1055                 case 0x10ec0262:
1056                 case 0x10ec0267:
1057                 case 0x10ec0268:
1058                 case 0x10ec0269:
1059                 case 0x10ec0272:
1060                 case 0x10ec0660:
1061                 case 0x10ec0662:
1062                 case 0x10ec0663:
1063                 case 0x10ec0862:
1064                 case 0x10ec0889:
1065                         snd_hda_codec_write(codec, 0x14, 0,
1066                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1067                         snd_hda_codec_write(codec, 0x15, 0,
1068                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1069                         break;
1070                 }
1071                 switch (codec->vendor_id) {
1072                 case 0x10ec0260:
1073                         snd_hda_codec_write(codec, 0x1a, 0,
1074                                             AC_VERB_SET_COEF_INDEX, 7);
1075                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1076                                                  AC_VERB_GET_PROC_COEF, 0);
1077                         snd_hda_codec_write(codec, 0x1a, 0,
1078                                             AC_VERB_SET_COEF_INDEX, 7);
1079                         snd_hda_codec_write(codec, 0x1a, 0,
1080                                             AC_VERB_SET_PROC_COEF,
1081                                             tmp | 0x2010);
1082                         break;
1083                 case 0x10ec0262:
1084                 case 0x10ec0880:
1085                 case 0x10ec0882:
1086                 case 0x10ec0883:
1087                 case 0x10ec0885:
1088                 case 0x10ec0887:
1089                 case 0x10ec0889:
1090                         snd_hda_codec_write(codec, 0x20, 0,
1091                                             AC_VERB_SET_COEF_INDEX, 7);
1092                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1093                                                  AC_VERB_GET_PROC_COEF, 0);
1094                         snd_hda_codec_write(codec, 0x20, 0,
1095                                             AC_VERB_SET_COEF_INDEX, 7);
1096                         snd_hda_codec_write(codec, 0x20, 0,
1097                                             AC_VERB_SET_PROC_COEF,
1098                                             tmp | 0x2010);
1099                         break;
1100                 case 0x10ec0888:
1101                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1102                         break;
1103                 case 0x10ec0267:
1104                 case 0x10ec0268:
1105                         snd_hda_codec_write(codec, 0x20, 0,
1106                                             AC_VERB_SET_COEF_INDEX, 7);
1107                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1108                                                  AC_VERB_GET_PROC_COEF, 0);
1109                         snd_hda_codec_write(codec, 0x20, 0,
1110                                             AC_VERB_SET_COEF_INDEX, 7);
1111                         snd_hda_codec_write(codec, 0x20, 0,
1112                                             AC_VERB_SET_PROC_COEF,
1113                                             tmp | 0x3000);
1114                         break;
1115                 }
1116         default:
1117                 break;
1118         }
1119
1120         /* is laptop or Desktop and enable the function "Mute internal speaker
1121          * when the external headphone out jack is plugged"
1122          */
1123         if (!(ass & 0x8000))
1124                 return;
1125         /*
1126          * 10~8 : Jack location
1127          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1128          * 14~13: Resvered
1129          * 15   : 1 --> enable the function "Mute internal speaker
1130          *              when the external headphone out jack is plugged"
1131          */
1132         if (!spec->autocfg.speaker_pins[0]) {
1133                 if (spec->autocfg.line_out_pins[0])
1134                         spec->autocfg.speaker_pins[0] =
1135                                 spec->autocfg.line_out_pins[0];
1136                 else
1137                         return;
1138         }
1139
1140         if (!spec->autocfg.hp_pins[0]) {
1141                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1142                 if (tmp == 0)
1143                         spec->autocfg.hp_pins[0] = porta;
1144                 else if (tmp == 1)
1145                         spec->autocfg.hp_pins[0] = porte;
1146                 else if (tmp == 2)
1147                         spec->autocfg.hp_pins[0] = portd;
1148                 else
1149                         return;
1150         }
1151         if (spec->autocfg.hp_pins[0])
1152                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1153                         AC_VERB_SET_UNSOLICITED_ENABLE,
1154                         AC_USRSP_EN | ALC880_HP_EVENT);
1155
1156 #if 0 /* it's broken in some acses -- temporarily disabled */
1157         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1158                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1159                 snd_hda_codec_write(codec,
1160                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1161                         AC_VERB_SET_UNSOLICITED_ENABLE,
1162                         AC_USRSP_EN | ALC880_MIC_EVENT);
1163 #endif /* disabled */
1164
1165         spec->unsol_event = alc_sku_unsol_event;
1166 }
1167
1168 /*
1169  * Fix-up pin default configurations
1170  */
1171
1172 struct alc_pincfg {
1173         hda_nid_t nid;
1174         u32 val;
1175 };
1176
1177 static void alc_fix_pincfg(struct hda_codec *codec,
1178                            const struct snd_pci_quirk *quirk,
1179                            const struct alc_pincfg **pinfix)
1180 {
1181         const struct alc_pincfg *cfg;
1182
1183         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1184         if (!quirk)
1185                 return;
1186
1187         cfg = pinfix[quirk->value];
1188         for (; cfg->nid; cfg++) {
1189                 int i;
1190                 u32 val = cfg->val;
1191                 for (i = 0; i < 4; i++) {
1192                         snd_hda_codec_write(codec, cfg->nid, 0,
1193                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1194                                     val & 0xff);
1195                         val >>= 8;
1196                 }
1197         }
1198 }
1199
1200 /*
1201  * ALC888
1202  */
1203
1204 /*
1205  * 2ch mode
1206  */
1207 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1208 /* Mic-in jack as mic in */
1209         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1210         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1211 /* Line-in jack as Line in */
1212         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1213         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1214 /* Line-Out as Front */
1215         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1216         { } /* end */
1217 };
1218
1219 /*
1220  * 4ch mode
1221  */
1222 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1223 /* Mic-in jack as mic in */
1224         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1225         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1226 /* Line-in jack as Surround */
1227         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1228         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1229 /* Line-Out as Front */
1230         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1231         { } /* end */
1232 };
1233
1234 /*
1235  * 6ch mode
1236  */
1237 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1238 /* Mic-in jack as CLFE */
1239         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1240         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1241 /* Line-in jack as Surround */
1242         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1243         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1244 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1245         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1246         { } /* end */
1247 };
1248
1249 /*
1250  * 8ch mode
1251  */
1252 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1253 /* Mic-in jack as CLFE */
1254         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1255         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1256 /* Line-in jack as Surround */
1257         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1258         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1259 /* Line-Out as Side */
1260         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1261         { } /* end */
1262 };
1263
1264 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1265         { 2, alc888_4ST_ch2_intel_init },
1266         { 4, alc888_4ST_ch4_intel_init },
1267         { 6, alc888_4ST_ch6_intel_init },
1268         { 8, alc888_4ST_ch8_intel_init },
1269 };
1270
1271 /*
1272  * ALC888 Fujitsu Siemens Amillo xa3530
1273  */
1274
1275 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1276 /* Front Mic: set to PIN_IN (empty by default) */
1277         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1278 /* Connect Internal HP to Front */
1279         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1280         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1281         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1282 /* Connect Bass HP to Front */
1283         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1284         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1285         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1286 /* Connect Line-Out side jack (SPDIF) to Side */
1287         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1288         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1289         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1290 /* Connect Mic jack to CLFE */
1291         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1292         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1293         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1294 /* Connect Line-in jack to Surround */
1295         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1296         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1297         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1298 /* Connect HP out jack to Front */
1299         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1300         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1301         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1302 /* Enable unsolicited event for HP jack and Line-out jack */
1303         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1304         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1305         {}
1306 };
1307
1308 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1309 {
1310         unsigned int present;
1311         unsigned int bits;
1312         /* Line out presence */
1313         present = snd_hda_codec_read(codec, 0x17, 0,
1314                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1315         /* HP out presence */
1316         present = present || snd_hda_codec_read(codec, 0x1b, 0,
1317                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1318         bits = present ? HDA_AMP_MUTE : 0;
1319         /* Toggle internal speakers muting */
1320         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1321                                  HDA_AMP_MUTE, bits);
1322         /* Toggle internal bass muting */
1323         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1324                                  HDA_AMP_MUTE, bits);
1325 }
1326
1327 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1328                 unsigned int res)
1329 {
1330         if (res >> 26 == ALC880_HP_EVENT)
1331                 alc888_fujitsu_xa3530_automute(codec);
1332 }
1333
1334
1335 /*
1336  * ALC888 Acer Aspire 4930G model
1337  */
1338
1339 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1340 /* Front Mic: set to PIN_IN (empty by default) */
1341         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1342 /* Unselect Front Mic by default in input mixer 3 */
1343         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1344 /* Enable unsolicited event for HP jack */
1345         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1346 /* Connect Internal HP to front */
1347         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1348         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1349         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1350 /* Connect HP out to front */
1351         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1352         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1353         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1354         { }
1355 };
1356
1357 static struct hda_input_mux alc888_2_capture_sources[2] = {
1358         /* Front mic only available on one ADC */
1359         {
1360                 .num_items = 4,
1361                 .items = {
1362                         { "Mic", 0x0 },
1363                         { "Line", 0x2 },
1364                         { "CD", 0x4 },
1365                         { "Front Mic", 0xb },
1366                 },
1367         },
1368         {
1369                 .num_items = 3,
1370                 .items = {
1371                         { "Mic", 0x0 },
1372                         { "Line", 0x2 },
1373                         { "CD", 0x4 },
1374                 },
1375         }
1376 };
1377
1378 static struct snd_kcontrol_new alc888_base_mixer[] = {
1379         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1380         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1381         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1382         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1383         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1384                 HDA_OUTPUT),
1385         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1386         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1387         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1388         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1389         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1390         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1391         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1392         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1393         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1394         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1395         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1396         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1397         { } /* end */
1398 };
1399
1400 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1401 {
1402         unsigned int present;
1403         unsigned int bits;
1404         present = snd_hda_codec_read(codec, 0x15, 0,
1405                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1406         bits = present ? HDA_AMP_MUTE : 0;
1407         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1408                                  HDA_AMP_MUTE, bits);
1409 }
1410
1411 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1412                 unsigned int res)
1413 {
1414         if (res >> 26 == ALC880_HP_EVENT)
1415                 alc888_acer_aspire_4930g_automute(codec);
1416 }
1417
1418 /*
1419  * ALC880 3-stack model
1420  *
1421  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1422  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1423  *                 F-Mic = 0x1b, HP = 0x19
1424  */
1425
1426 static hda_nid_t alc880_dac_nids[4] = {
1427         /* front, rear, clfe, rear_surr */
1428         0x02, 0x05, 0x04, 0x03
1429 };
1430
1431 static hda_nid_t alc880_adc_nids[3] = {
1432         /* ADC0-2 */
1433         0x07, 0x08, 0x09,
1434 };
1435
1436 /* The datasheet says the node 0x07 is connected from inputs,
1437  * but it shows zero connection in the real implementation on some devices.
1438  * Note: this is a 915GAV bug, fixed on 915GLV
1439  */
1440 static hda_nid_t alc880_adc_nids_alt[2] = {
1441         /* ADC1-2 */
1442         0x08, 0x09,
1443 };
1444
1445 #define ALC880_DIGOUT_NID       0x06
1446 #define ALC880_DIGIN_NID        0x0a
1447
1448 static struct hda_input_mux alc880_capture_source = {
1449         .num_items = 4,
1450         .items = {
1451                 { "Mic", 0x0 },
1452                 { "Front Mic", 0x3 },
1453                 { "Line", 0x2 },
1454                 { "CD", 0x4 },
1455         },
1456 };
1457
1458 /* channel source setting (2/6 channel selection for 3-stack) */
1459 /* 2ch mode */
1460 static struct hda_verb alc880_threestack_ch2_init[] = {
1461         /* set line-in to input, mute it */
1462         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1463         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1464         /* set mic-in to input vref 80%, mute it */
1465         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1466         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1467         { } /* end */
1468 };
1469
1470 /* 6ch mode */
1471 static struct hda_verb alc880_threestack_ch6_init[] = {
1472         /* set line-in to output, unmute it */
1473         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1474         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1475         /* set mic-in to output, unmute it */
1476         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1477         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1478         { } /* end */
1479 };
1480
1481 static struct hda_channel_mode alc880_threestack_modes[2] = {
1482         { 2, alc880_threestack_ch2_init },
1483         { 6, alc880_threestack_ch6_init },
1484 };
1485
1486 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1487         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1488         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1489         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1490         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1491         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1492         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1493         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1494         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1495         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1496         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1497         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1498         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1499         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1500         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1501         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1502         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1503         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1504         {
1505                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1506                 .name = "Channel Mode",
1507                 .info = alc_ch_mode_info,
1508                 .get = alc_ch_mode_get,
1509                 .put = alc_ch_mode_put,
1510         },
1511         { } /* end */
1512 };
1513
1514 /* capture mixer elements */
1515 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1516                             struct snd_ctl_elem_info *uinfo)
1517 {
1518         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1519         struct alc_spec *spec = codec->spec;
1520         int err;
1521
1522         mutex_lock(&codec->control_mutex);
1523         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1524                                                       HDA_INPUT);
1525         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1526         mutex_unlock(&codec->control_mutex);
1527         return err;
1528 }
1529
1530 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1531                            unsigned int size, unsigned int __user *tlv)
1532 {
1533         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1534         struct alc_spec *spec = codec->spec;
1535         int err;
1536
1537         mutex_lock(&codec->control_mutex);
1538         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1539                                                       HDA_INPUT);
1540         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1541         mutex_unlock(&codec->control_mutex);
1542         return err;
1543 }
1544
1545 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1546                              struct snd_ctl_elem_value *ucontrol);
1547
1548 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1549                                  struct snd_ctl_elem_value *ucontrol,
1550                                  getput_call_t func)
1551 {
1552         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1553         struct alc_spec *spec = codec->spec;
1554         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1555         int err;
1556
1557         mutex_lock(&codec->control_mutex);
1558         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1559                                                       3, 0, HDA_INPUT);
1560         err = func(kcontrol, ucontrol);
1561         mutex_unlock(&codec->control_mutex);
1562         return err;
1563 }
1564
1565 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1566                            struct snd_ctl_elem_value *ucontrol)
1567 {
1568         return alc_cap_getput_caller(kcontrol, ucontrol,
1569                                      snd_hda_mixer_amp_volume_get);
1570 }
1571
1572 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1573                            struct snd_ctl_elem_value *ucontrol)
1574 {
1575         return alc_cap_getput_caller(kcontrol, ucontrol,
1576                                      snd_hda_mixer_amp_volume_put);
1577 }
1578
1579 /* capture mixer elements */
1580 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1581
1582 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1583                           struct snd_ctl_elem_value *ucontrol)
1584 {
1585         return alc_cap_getput_caller(kcontrol, ucontrol,
1586                                      snd_hda_mixer_amp_switch_get);
1587 }
1588
1589 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1590                           struct snd_ctl_elem_value *ucontrol)
1591 {
1592         return alc_cap_getput_caller(kcontrol, ucontrol,
1593                                      snd_hda_mixer_amp_switch_put);
1594 }
1595
1596 #define DEFINE_CAPMIX(num) \
1597 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1598         { \
1599                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1600                 .name = "Capture Switch", \
1601                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1602                 .count = num, \
1603                 .info = alc_cap_sw_info, \
1604                 .get = alc_cap_sw_get, \
1605                 .put = alc_cap_sw_put, \
1606         }, \
1607         { \
1608                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1609                 .name = "Capture Volume", \
1610                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1611                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1612                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1613                 .count = num, \
1614                 .info = alc_cap_vol_info, \
1615                 .get = alc_cap_vol_get, \
1616                 .put = alc_cap_vol_put, \
1617                 .tlv = { .c = alc_cap_vol_tlv }, \
1618         }, \
1619         { \
1620                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1621                 /* .name = "Capture Source", */ \
1622                 .name = "Input Source", \
1623                 .count = num, \
1624                 .info = alc_mux_enum_info, \
1625                 .get = alc_mux_enum_get, \
1626                 .put = alc_mux_enum_put, \
1627         }, \
1628         { } /* end */ \
1629 }
1630
1631 /* up to three ADCs */
1632 DEFINE_CAPMIX(1);
1633 DEFINE_CAPMIX(2);
1634 DEFINE_CAPMIX(3);
1635
1636
1637 /*
1638  * ALC880 5-stack model
1639  *
1640  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1641  *      Side = 0x02 (0xd)
1642  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1643  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1644  */
1645
1646 /* additional mixers to alc880_three_stack_mixer */
1647 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1648         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1649         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1650         { } /* end */
1651 };
1652
1653 /* channel source setting (6/8 channel selection for 5-stack) */
1654 /* 6ch mode */
1655 static struct hda_verb alc880_fivestack_ch6_init[] = {
1656         /* set line-in to input, mute it */
1657         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1658         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1659         { } /* end */
1660 };
1661
1662 /* 8ch mode */
1663 static struct hda_verb alc880_fivestack_ch8_init[] = {
1664         /* set line-in to output, unmute it */
1665         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1666         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1667         { } /* end */
1668 };
1669
1670 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1671         { 6, alc880_fivestack_ch6_init },
1672         { 8, alc880_fivestack_ch8_init },
1673 };
1674
1675
1676 /*
1677  * ALC880 6-stack model
1678  *
1679  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1680  *      Side = 0x05 (0x0f)
1681  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1682  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1683  */
1684
1685 static hda_nid_t alc880_6st_dac_nids[4] = {
1686         /* front, rear, clfe, rear_surr */
1687         0x02, 0x03, 0x04, 0x05
1688 };
1689
1690 static struct hda_input_mux alc880_6stack_capture_source = {
1691         .num_items = 4,
1692         .items = {
1693                 { "Mic", 0x0 },
1694                 { "Front Mic", 0x1 },
1695                 { "Line", 0x2 },
1696                 { "CD", 0x4 },
1697         },
1698 };
1699
1700 /* fixed 8-channels */
1701 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1702         { 8, NULL },
1703 };
1704
1705 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1706         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1707         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1708         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1709         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1710         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1711         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1712         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1713         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1714         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1715         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1716         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1717         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1718         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1719         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1720         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1721         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1722         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1723         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1724         {
1725                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1726                 .name = "Channel Mode",
1727                 .info = alc_ch_mode_info,
1728                 .get = alc_ch_mode_get,
1729                 .put = alc_ch_mode_put,
1730         },
1731         { } /* end */
1732 };
1733
1734
1735 /*
1736  * ALC880 W810 model
1737  *
1738  * W810 has rear IO for:
1739  * Front (DAC 02)
1740  * Surround (DAC 03)
1741  * Center/LFE (DAC 04)
1742  * Digital out (06)
1743  *
1744  * The system also has a pair of internal speakers, and a headphone jack.
1745  * These are both connected to Line2 on the codec, hence to DAC 02.
1746  *
1747  * There is a variable resistor to control the speaker or headphone
1748  * volume. This is a hardware-only device without a software API.
1749  *
1750  * Plugging headphones in will disable the internal speakers. This is
1751  * implemented in hardware, not via the driver using jack sense. In
1752  * a similar fashion, plugging into the rear socket marked "front" will
1753  * disable both the speakers and headphones.
1754  *
1755  * For input, there's a microphone jack, and an "audio in" jack.
1756  * These may not do anything useful with this driver yet, because I
1757  * haven't setup any initialization verbs for these yet...
1758  */
1759
1760 static hda_nid_t alc880_w810_dac_nids[3] = {
1761         /* front, rear/surround, clfe */
1762         0x02, 0x03, 0x04
1763 };
1764
1765 /* fixed 6 channels */
1766 static struct hda_channel_mode alc880_w810_modes[1] = {
1767         { 6, NULL }
1768 };
1769
1770 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1771 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1772         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1773         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1774         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1775         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1776         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1777         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1778         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1779         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1780         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1781         { } /* end */
1782 };
1783
1784
1785 /*
1786  * Z710V model
1787  *
1788  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1789  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1790  *                 Line = 0x1a
1791  */
1792
1793 static hda_nid_t alc880_z71v_dac_nids[1] = {
1794         0x02
1795 };
1796 #define ALC880_Z71V_HP_DAC      0x03
1797
1798 /* fixed 2 channels */
1799 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1800         { 2, NULL }
1801 };
1802
1803 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1804         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1805         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1806         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1807         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1808         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1809         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1811         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1812         { } /* end */
1813 };
1814
1815
1816 /*
1817  * ALC880 F1734 model
1818  *
1819  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1820  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1821  */
1822
1823 static hda_nid_t alc880_f1734_dac_nids[1] = {
1824         0x03
1825 };
1826 #define ALC880_F1734_HP_DAC     0x02
1827
1828 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1829         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1830         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1831         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1832         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1833         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1834         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1835         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1836         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1837         { } /* end */
1838 };
1839
1840 static struct hda_input_mux alc880_f1734_capture_source = {
1841         .num_items = 2,
1842         .items = {
1843                 { "Mic", 0x1 },
1844                 { "CD", 0x4 },
1845         },
1846 };
1847
1848
1849 /*
1850  * ALC880 ASUS model
1851  *
1852  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1853  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1854  *  Mic = 0x18, Line = 0x1a
1855  */
1856
1857 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1858 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1859
1860 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1861         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1862         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1863         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1864         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1865         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1866         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1867         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1868         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1869         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1870         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1871         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1872         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1873         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1874         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1875         {
1876                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1877                 .name = "Channel Mode",
1878                 .info = alc_ch_mode_info,
1879                 .get = alc_ch_mode_get,
1880                 .put = alc_ch_mode_put,
1881         },
1882         { } /* end */
1883 };
1884
1885 /*
1886  * ALC880 ASUS W1V model
1887  *
1888  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1889  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1890  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1891  */
1892
1893 /* additional mixers to alc880_asus_mixer */
1894 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1895         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1896         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1897         { } /* end */
1898 };
1899
1900 /* TCL S700 */
1901 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1902         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1903         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1904         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1905         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1906         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1907         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1908         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1909         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1910         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1911         { } /* end */
1912 };
1913
1914 /* Uniwill */
1915 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1916         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1917         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1918         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1919         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1920         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1921         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1922         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1923         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1924         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1925         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1926         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1927         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1928         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1929         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1930         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1931         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1932         {
1933                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1934                 .name = "Channel Mode",
1935                 .info = alc_ch_mode_info,
1936                 .get = alc_ch_mode_get,
1937                 .put = alc_ch_mode_put,
1938         },
1939         { } /* end */
1940 };
1941
1942 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1943         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1944         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1945         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1946         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1947         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1948         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1949         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1950         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1951         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1952         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1953         { } /* end */
1954 };
1955
1956 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1957         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1958         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1959         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1960         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1961         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1962         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1963         { } /* end */
1964 };
1965
1966 /*
1967  * virtual master controls
1968  */
1969
1970 /*
1971  * slave controls for virtual master
1972  */
1973 static const char *alc_slave_vols[] = {
1974         "Front Playback Volume",
1975         "Surround Playback Volume",
1976         "Center Playback Volume",
1977         "LFE Playback Volume",
1978         "Side Playback Volume",
1979         "Headphone Playback Volume",
1980         "Speaker Playback Volume",
1981         "Mono Playback Volume",
1982         "Line-Out Playback Volume",
1983         "PCM Playback Volume",
1984         NULL,
1985 };
1986
1987 static const char *alc_slave_sws[] = {
1988         "Front Playback Switch",
1989         "Surround Playback Switch",
1990         "Center Playback Switch",
1991         "LFE Playback Switch",
1992         "Side Playback Switch",
1993         "Headphone Playback Switch",
1994         "Speaker Playback Switch",
1995         "Mono Playback Switch",
1996         "IEC958 Playback Switch",
1997         NULL,
1998 };
1999
2000 /*
2001  * build control elements
2002  */
2003
2004 static void alc_free_kctls(struct hda_codec *codec);
2005
2006 /* additional beep mixers; the actual parameters are overwritten at build */
2007 static struct snd_kcontrol_new alc_beep_mixer[] = {
2008         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2009         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2010         { } /* end */
2011 };
2012
2013 static int alc_build_controls(struct hda_codec *codec)
2014 {
2015         struct alc_spec *spec = codec->spec;
2016         int err;
2017         int i;
2018
2019         for (i = 0; i < spec->num_mixers; i++) {
2020                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2021                 if (err < 0)
2022                         return err;
2023         }
2024         if (spec->cap_mixer) {
2025                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2026                 if (err < 0)
2027                         return err;
2028         }
2029         if (spec->multiout.dig_out_nid) {
2030                 err = snd_hda_create_spdif_out_ctls(codec,
2031                                                     spec->multiout.dig_out_nid);
2032                 if (err < 0)
2033                         return err;
2034                 if (!spec->no_analog) {
2035                         err = snd_hda_create_spdif_share_sw(codec,
2036                                                             &spec->multiout);
2037                         if (err < 0)
2038                                 return err;
2039                         spec->multiout.share_spdif = 1;
2040                 }
2041         }
2042         if (spec->dig_in_nid) {
2043                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2044                 if (err < 0)
2045                         return err;
2046         }
2047
2048         /* create beep controls if needed */
2049         if (spec->beep_amp) {
2050                 struct snd_kcontrol_new *knew;
2051                 for (knew = alc_beep_mixer; knew->name; knew++) {
2052                         struct snd_kcontrol *kctl;
2053                         kctl = snd_ctl_new1(knew, codec);
2054                         if (!kctl)
2055                                 return -ENOMEM;
2056                         kctl->private_value = spec->beep_amp;
2057                         err = snd_hda_ctl_add(codec, kctl);
2058                         if (err < 0)
2059                                 return err;
2060                 }
2061         }
2062
2063         /* if we have no master control, let's create it */
2064         if (!spec->no_analog &&
2065             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2066                 unsigned int vmaster_tlv[4];
2067                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2068                                         HDA_OUTPUT, vmaster_tlv);
2069                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2070                                           vmaster_tlv, alc_slave_vols);
2071                 if (err < 0)
2072                         return err;
2073         }
2074         if (!spec->no_analog &&
2075             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2076                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2077                                           NULL, alc_slave_sws);
2078                 if (err < 0)
2079                         return err;
2080         }
2081
2082         alc_free_kctls(codec); /* no longer needed */
2083         return 0;
2084 }
2085
2086
2087 /*
2088  * initialize the codec volumes, etc
2089  */
2090
2091 /*
2092  * generic initialization of ADC, input mixers and output mixers
2093  */
2094 static struct hda_verb alc880_volume_init_verbs[] = {
2095         /*
2096          * Unmute ADC0-2 and set the default input to mic-in
2097          */
2098         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2099         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2100         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2101         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2102         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2103         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2104
2105         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2106          * mixer widget
2107          * Note: PASD motherboards uses the Line In 2 as the input for front
2108          * panel mic (mic 2)
2109          */
2110         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2111         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2116         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2117         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2118
2119         /*
2120          * Set up output mixers (0x0c - 0x0f)
2121          */
2122         /* set vol=0 to output mixers */
2123         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2124         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2125         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2126         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2127         /* set up input amps for analog loopback */
2128         /* Amp Indices: DAC = 0, mixer = 1 */
2129         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2130         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2131         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2132         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2133         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2134         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2135         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2136         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2137
2138         { }
2139 };
2140
2141 /*
2142  * 3-stack pin configuration:
2143  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2144  */
2145 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2146         /*
2147          * preset connection lists of input pins
2148          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2149          */
2150         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2151         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2152         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2153
2154         /*
2155          * Set pin mode and muting
2156          */
2157         /* set front pin widgets 0x14 for output */
2158         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2159         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2160         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2161         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2162         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2163         /* Mic2 (as headphone out) for HP output */
2164         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2165         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2166         /* Line In pin widget for input */
2167         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2168         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2169         /* Line2 (as front mic) pin widget for input and vref at 80% */
2170         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2171         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2172         /* CD pin widget for input */
2173         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2174
2175         { }
2176 };
2177
2178 /*
2179  * 5-stack pin configuration:
2180  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2181  * line-in/side = 0x1a, f-mic = 0x1b
2182  */
2183 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2184         /*
2185          * preset connection lists of input pins
2186          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2187          */
2188         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2189         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2190
2191         /*
2192          * Set pin mode and muting
2193          */
2194         /* set pin widgets 0x14-0x17 for output */
2195         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2196         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2197         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2198         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2199         /* unmute pins for output (no gain on this amp) */
2200         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2201         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2202         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2203         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2204
2205         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2206         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2207         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2208         /* Mic2 (as headphone out) for HP output */
2209         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2210         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2211         /* Line In pin widget for input */
2212         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2213         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2214         /* Line2 (as front mic) pin widget for input and vref at 80% */
2215         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2216         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2217         /* CD pin widget for input */
2218         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2219
2220         { }
2221 };
2222
2223 /*
2224  * W810 pin configuration:
2225  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2226  */
2227 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2228         /* hphone/speaker input selector: front DAC */
2229         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2230
2231         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2232         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2233         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2234         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2235         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2236         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2237
2238         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2239         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2240
2241         { }
2242 };
2243
2244 /*
2245  * Z71V pin configuration:
2246  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2247  */
2248 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2249         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2250         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2251         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2252         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2253
2254         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2255         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2256         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2257         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2258
2259         { }
2260 };
2261
2262 /*
2263  * 6-stack pin configuration:
2264  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2265  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2266  */
2267 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2268         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2269
2270         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2271         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2272         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2273         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2274         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2275         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2276         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2277         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2278
2279         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2280         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2281         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2282         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2283         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2284         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2285         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2286         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2287         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2288
2289         { }
2290 };
2291
2292 /*
2293  * Uniwill pin configuration:
2294  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2295  * line = 0x1a
2296  */
2297 static struct hda_verb alc880_uniwill_init_verbs[] = {
2298         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2299
2300         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2301         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2302         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2303         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2304         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2305         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2306         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2307         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2308         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2310         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2311         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2312         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2313         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2314
2315         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2316         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2317         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2318         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2319         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2320         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2321         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2322         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2323         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2324
2325         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2326         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2327
2328         { }
2329 };
2330
2331 /*
2332 * Uniwill P53
2333 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2334  */
2335 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2336         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2337
2338         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2339         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2340         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2341         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2342         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2343         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2344         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2346         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2347         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2348         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2349         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2350
2351         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2352         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2353         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2354         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2355         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2356         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2357
2358         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2359         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2360
2361         { }
2362 };
2363
2364 static struct hda_verb alc880_beep_init_verbs[] = {
2365         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2366         { }
2367 };
2368
2369 /* toggle speaker-output according to the hp-jack state */
2370 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2371 {
2372         unsigned int present;
2373         unsigned char bits;
2374
2375         present = snd_hda_codec_read(codec, 0x14, 0,
2376                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2377         bits = present ? HDA_AMP_MUTE : 0;
2378         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2379                                  HDA_AMP_MUTE, bits);
2380         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2381                                  HDA_AMP_MUTE, bits);
2382 }
2383
2384 /* auto-toggle front mic */
2385 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2386 {
2387         unsigned int present;
2388         unsigned char bits;
2389
2390         present = snd_hda_codec_read(codec, 0x18, 0,
2391                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2392         bits = present ? HDA_AMP_MUTE : 0;
2393         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2394 }
2395
2396 static void alc880_uniwill_automute(struct hda_codec *codec)
2397 {
2398         alc880_uniwill_hp_automute(codec);
2399         alc880_uniwill_mic_automute(codec);
2400 }
2401
2402 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2403                                        unsigned int res)
2404 {
2405         /* Looks like the unsol event is incompatible with the standard
2406          * definition.  4bit tag is placed at 28 bit!
2407          */
2408         switch (res >> 28) {
2409         case ALC880_HP_EVENT:
2410                 alc880_uniwill_hp_automute(codec);
2411                 break;
2412         case ALC880_MIC_EVENT:
2413                 alc880_uniwill_mic_automute(codec);
2414                 break;
2415         }
2416 }
2417
2418 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2419 {
2420         unsigned int present;
2421         unsigned char bits;
2422
2423         present = snd_hda_codec_read(codec, 0x14, 0,
2424                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2425         bits = present ? HDA_AMP_MUTE : 0;
2426         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2427 }
2428
2429 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2430 {
2431         unsigned int present;
2432
2433         present = snd_hda_codec_read(codec, 0x21, 0,
2434                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2435         present &= HDA_AMP_VOLMASK;
2436         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2437                                  HDA_AMP_VOLMASK, present);
2438         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2439                                  HDA_AMP_VOLMASK, present);
2440 }
2441
2442 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2443                                            unsigned int res)
2444 {
2445         /* Looks like the unsol event is incompatible with the standard
2446          * definition.  4bit tag is placed at 28 bit!
2447          */
2448         if ((res >> 28) == ALC880_HP_EVENT)
2449                 alc880_uniwill_p53_hp_automute(codec);
2450         if ((res >> 28) == ALC880_DCVOL_EVENT)
2451                 alc880_uniwill_p53_dcvol_automute(codec);
2452 }
2453
2454 /*
2455  * F1734 pin configuration:
2456  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2457  */
2458 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2459         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2460         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2461         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2462         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2463         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2464
2465         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2466         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2467         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2468         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2469
2470         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2471         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2472         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2473         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2474         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2475         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2476         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2477         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2478         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2479
2480         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2481         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2482
2483         { }
2484 };
2485
2486 /*
2487  * ASUS pin configuration:
2488  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2489  */
2490 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2491         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2492         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2493         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2494         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2495
2496         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2497         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2498         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2499         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2500         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2501         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2502         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2503         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2504
2505         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2506         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2507         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2508         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2509         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2510         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2511         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2512         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2513         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2514
2515         { }
2516 };
2517
2518 /* Enable GPIO mask and set output */
2519 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2520 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2521
2522 /* Clevo m520g init */
2523 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2524         /* headphone output */
2525         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2526         /* line-out */
2527         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2528         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2529         /* Line-in */
2530         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2531         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2532         /* CD */
2533         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2534         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2535         /* Mic1 (rear panel) */
2536         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2537         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2538         /* Mic2 (front panel) */
2539         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2540         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2541         /* headphone */
2542         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2543         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2544         /* change to EAPD mode */
2545         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2546         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2547
2548         { }
2549 };
2550
2551 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2552         /* change to EAPD mode */
2553         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2554         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2555
2556         /* Headphone output */
2557         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2558         /* Front output*/
2559         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2560         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2561
2562         /* Line In pin widget for input */
2563         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2564         /* CD pin widget for input */
2565         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2566         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2567         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2568
2569         /* change to EAPD mode */
2570         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2571         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2572
2573         { }
2574 };
2575
2576 /*
2577  * LG m1 express dual
2578  *
2579  * Pin assignment:
2580  *   Rear Line-In/Out (blue): 0x14
2581  *   Build-in Mic-In: 0x15
2582  *   Speaker-out: 0x17
2583  *   HP-Out (green): 0x1b
2584  *   Mic-In/Out (red): 0x19
2585  *   SPDIF-Out: 0x1e
2586  */
2587
2588 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2589 static hda_nid_t alc880_lg_dac_nids[3] = {
2590         0x05, 0x02, 0x03
2591 };
2592
2593 /* seems analog CD is not working */
2594 static struct hda_input_mux alc880_lg_capture_source = {
2595         .num_items = 3,
2596         .items = {
2597                 { "Mic", 0x1 },
2598                 { "Line", 0x5 },
2599                 { "Internal Mic", 0x6 },
2600         },
2601 };
2602
2603 /* 2,4,6 channel modes */
2604 static struct hda_verb alc880_lg_ch2_init[] = {
2605         /* set line-in and mic-in to input */
2606         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2607         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2608         { }
2609 };
2610
2611 static struct hda_verb alc880_lg_ch4_init[] = {
2612         /* set line-in to out and mic-in to input */
2613         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2614         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2615         { }
2616 };
2617
2618 static struct hda_verb alc880_lg_ch6_init[] = {
2619         /* set line-in and mic-in to output */
2620         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2621         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2622         { }
2623 };
2624
2625 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2626         { 2, alc880_lg_ch2_init },
2627         { 4, alc880_lg_ch4_init },
2628         { 6, alc880_lg_ch6_init },
2629 };
2630
2631 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2632         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2633         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2634         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2635         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2636         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2637         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2638         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2639         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2640         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2641         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2642         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2643         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2644         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2645         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2646         {
2647                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2648                 .name = "Channel Mode",
2649                 .info = alc_ch_mode_info,
2650                 .get = alc_ch_mode_get,
2651                 .put = alc_ch_mode_put,
2652         },
2653         { } /* end */
2654 };
2655
2656 static struct hda_verb alc880_lg_init_verbs[] = {
2657         /* set capture source to mic-in */
2658         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2659         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2660         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2661         /* mute all amp mixer inputs */
2662         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2663         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2664         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2665         /* line-in to input */
2666         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2667         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2668         /* built-in mic */
2669         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2670         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2671         /* speaker-out */
2672         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2673         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2674         /* mic-in to input */
2675         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2676         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2677         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2678         /* HP-out */
2679         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2680         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2681         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2682         /* jack sense */
2683         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2684         { }
2685 };
2686
2687 /* toggle speaker-output according to the hp-jack state */
2688 static void alc880_lg_automute(struct hda_codec *codec)
2689 {
2690         unsigned int present;
2691         unsigned char bits;
2692
2693         present = snd_hda_codec_read(codec, 0x1b, 0,
2694                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2695         bits = present ? HDA_AMP_MUTE : 0;
2696         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2697                                  HDA_AMP_MUTE, bits);
2698 }
2699
2700 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2701 {
2702         /* Looks like the unsol event is incompatible with the standard
2703          * definition.  4bit tag is placed at 28 bit!
2704          */
2705         if ((res >> 28) == 0x01)
2706                 alc880_lg_automute(codec);
2707 }
2708
2709 /*
2710  * LG LW20
2711  *
2712  * Pin assignment:
2713  *   Speaker-out: 0x14
2714  *   Mic-In: 0x18
2715  *   Built-in Mic-In: 0x19
2716  *   Line-In: 0x1b
2717  *   HP-Out: 0x1a
2718  *   SPDIF-Out: 0x1e
2719  */
2720
2721 static struct hda_input_mux alc880_lg_lw_capture_source = {
2722         .num_items = 3,
2723         .items = {
2724                 { "Mic", 0x0 },
2725                 { "Internal Mic", 0x1 },
2726                 { "Line In", 0x2 },
2727         },
2728 };
2729
2730 #define alc880_lg_lw_modes alc880_threestack_modes
2731
2732 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2733         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2734         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2735         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2736         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2737         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2738         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2739         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2740         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2741         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2742         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2743         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2744         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2745         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2746         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2747         {
2748                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2749                 .name = "Channel Mode",
2750                 .info = alc_ch_mode_info,
2751                 .get = alc_ch_mode_get,
2752                 .put = alc_ch_mode_put,
2753         },
2754         { } /* end */
2755 };
2756
2757 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2758         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2759         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2760         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2761
2762         /* set capture source to mic-in */
2763         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2764         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2765         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2766         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2767         /* speaker-out */
2768         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2769         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2770         /* HP-out */
2771         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2772         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2773         /* mic-in to input */
2774         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2775         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2776         /* built-in mic */
2777         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2778         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2779         /* jack sense */
2780         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2781         { }
2782 };
2783
2784 /* toggle speaker-output according to the hp-jack state */
2785 static void alc880_lg_lw_automute(struct hda_codec *codec)
2786 {
2787         unsigned int present;
2788         unsigned char bits;
2789
2790         present = snd_hda_codec_read(codec, 0x1b, 0,
2791                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2792         bits = present ? HDA_AMP_MUTE : 0;
2793         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2794                                  HDA_AMP_MUTE, bits);
2795 }
2796
2797 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2798 {
2799         /* Looks like the unsol event is incompatible with the standard
2800          * definition.  4bit tag is placed at 28 bit!
2801          */
2802         if ((res >> 28) == 0x01)
2803                 alc880_lg_lw_automute(codec);
2804 }
2805
2806 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2807         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2808         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2810         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2811         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2812         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2813         { } /* end */
2814 };
2815
2816 static struct hda_input_mux alc880_medion_rim_capture_source = {
2817         .num_items = 2,
2818         .items = {
2819                 { "Mic", 0x0 },
2820                 { "Internal Mic", 0x1 },
2821         },
2822 };
2823
2824 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2825         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2826
2827         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2828         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2829
2830         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2831         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2832         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2833         /* Mic2 (as headphone out) for HP output */
2834         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2835         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2836         /* Internal Speaker */
2837         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2838         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2839
2840         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2841         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2842
2843         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2844         { }
2845 };
2846
2847 /* toggle speaker-output according to the hp-jack state */
2848 static void alc880_medion_rim_automute(struct hda_codec *codec)
2849 {
2850         unsigned int present;
2851         unsigned char bits;
2852
2853         present = snd_hda_codec_read(codec, 0x14, 0,
2854                                      AC_VERB_GET_PIN_SENSE, 0)
2855                 & AC_PINSENSE_PRESENCE;
2856         bits = present ? HDA_AMP_MUTE : 0;
2857         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2858                                  HDA_AMP_MUTE, bits);
2859         if (present)
2860                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2861         else
2862                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2863 }
2864
2865 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2866                                           unsigned int res)
2867 {
2868         /* Looks like the unsol event is incompatible with the standard
2869          * definition.  4bit tag is placed at 28 bit!
2870          */
2871         if ((res >> 28) == ALC880_HP_EVENT)
2872                 alc880_medion_rim_automute(codec);
2873 }
2874
2875 #ifdef CONFIG_SND_HDA_POWER_SAVE
2876 static struct hda_amp_list alc880_loopbacks[] = {
2877         { 0x0b, HDA_INPUT, 0 },
2878         { 0x0b, HDA_INPUT, 1 },
2879         { 0x0b, HDA_INPUT, 2 },
2880         { 0x0b, HDA_INPUT, 3 },
2881         { 0x0b, HDA_INPUT, 4 },
2882         { } /* end */
2883 };
2884
2885 static struct hda_amp_list alc880_lg_loopbacks[] = {
2886         { 0x0b, HDA_INPUT, 1 },
2887         { 0x0b, HDA_INPUT, 6 },
2888         { 0x0b, HDA_INPUT, 7 },
2889         { } /* end */
2890 };
2891 #endif
2892
2893 /*
2894  * Common callbacks
2895  */
2896
2897 static int alc_init(struct hda_codec *codec)
2898 {
2899         struct alc_spec *spec = codec->spec;
2900         unsigned int i;
2901
2902         alc_fix_pll(codec);
2903         if (codec->vendor_id == 0x10ec0888)
2904                 alc888_coef_init(codec);
2905
2906         for (i = 0; i < spec->num_init_verbs; i++)
2907                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2908
2909         if (spec->init_hook)
2910                 spec->init_hook(codec);
2911
2912         return 0;
2913 }
2914
2915 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2916 {
2917         struct alc_spec *spec = codec->spec;
2918
2919         if (spec->unsol_event)
2920                 spec->unsol_event(codec, res);
2921 }
2922
2923 #ifdef CONFIG_SND_HDA_POWER_SAVE
2924 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2925 {
2926         struct alc_spec *spec = codec->spec;
2927         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2928 }
2929 #endif
2930
2931 /*
2932  * Analog playback callbacks
2933  */
2934 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2935                                     struct hda_codec *codec,
2936                                     struct snd_pcm_substream *substream)
2937 {
2938         struct alc_spec *spec = codec->spec;
2939         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2940                                              hinfo);
2941 }
2942
2943 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2944                                        struct hda_codec *codec,
2945                                        unsigned int stream_tag,
2946                                        unsigned int format,
2947                                        struct snd_pcm_substream *substream)
2948 {
2949         struct alc_spec *spec = codec->spec;
2950         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2951                                                 stream_tag, format, substream);
2952 }
2953
2954 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2955                                        struct hda_codec *codec,
2956                                        struct snd_pcm_substream *substream)
2957 {
2958         struct alc_spec *spec = codec->spec;
2959         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2960 }
2961
2962 /*
2963  * Digital out
2964  */
2965 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2966                                         struct hda_codec *codec,
2967                                         struct snd_pcm_substream *substream)
2968 {
2969         struct alc_spec *spec = codec->spec;
2970         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2971 }
2972
2973 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2974                                            struct hda_codec *codec,
2975                                            unsigned int stream_tag,
2976                                            unsigned int format,
2977                                            struct snd_pcm_substream *substream)
2978 {
2979         struct alc_spec *spec = codec->spec;
2980         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2981                                              stream_tag, format, substream);
2982 }
2983
2984 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2985                                            struct hda_codec *codec,
2986                                            struct snd_pcm_substream *substream)
2987 {
2988         struct alc_spec *spec = codec->spec;
2989         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2990 }
2991
2992 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2993                                          struct hda_codec *codec,
2994                                          struct snd_pcm_substream *substream)
2995 {
2996         struct alc_spec *spec = codec->spec;
2997         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2998 }
2999
3000 /*
3001  * Analog capture
3002  */
3003 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3004                                       struct hda_codec *codec,
3005                                       unsigned int stream_tag,
3006                                       unsigned int format,
3007                                       struct snd_pcm_substream *substream)
3008 {
3009         struct alc_spec *spec = codec->spec;
3010
3011         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3012                                    stream_tag, 0, format);
3013         return 0;
3014 }
3015
3016 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3017                                       struct hda_codec *codec,
3018                                       struct snd_pcm_substream *substream)
3019 {
3020         struct alc_spec *spec = codec->spec;
3021
3022         snd_hda_codec_cleanup_stream(codec,
3023                                      spec->adc_nids[substream->number + 1]);
3024         return 0;
3025 }
3026
3027
3028 /*
3029  */
3030 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3031         .substreams = 1,
3032         .channels_min = 2,
3033         .channels_max = 8,
3034         /* NID is set in alc_build_pcms */
3035         .ops = {
3036                 .open = alc880_playback_pcm_open,
3037                 .prepare = alc880_playback_pcm_prepare,
3038                 .cleanup = alc880_playback_pcm_cleanup
3039         },
3040 };
3041
3042 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3043         .substreams = 1,
3044         .channels_min = 2,
3045         .channels_max = 2,
3046         /* NID is set in alc_build_pcms */
3047 };
3048
3049 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3050         .substreams = 1,
3051         .channels_min = 2,
3052         .channels_max = 2,
3053         /* NID is set in alc_build_pcms */
3054 };
3055
3056 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3057         .substreams = 2, /* can be overridden */
3058         .channels_min = 2,
3059         .channels_max = 2,
3060         /* NID is set in alc_build_pcms */
3061         .ops = {
3062                 .prepare = alc880_alt_capture_pcm_prepare,
3063                 .cleanup = alc880_alt_capture_pcm_cleanup
3064         },
3065 };
3066
3067 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3068         .substreams = 1,
3069         .channels_min = 2,
3070         .channels_max = 2,
3071         /* NID is set in alc_build_pcms */
3072         .ops = {
3073                 .open = alc880_dig_playback_pcm_open,
3074                 .close = alc880_dig_playback_pcm_close,
3075                 .prepare = alc880_dig_playback_pcm_prepare,
3076                 .cleanup = alc880_dig_playback_pcm_cleanup
3077         },
3078 };
3079
3080 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3081         .substreams = 1,
3082         .channels_min = 2,
3083         .channels_max = 2,
3084         /* NID is set in alc_build_pcms */
3085 };
3086
3087 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3088 static struct hda_pcm_stream alc_pcm_null_stream = {
3089         .substreams = 0,
3090         .channels_min = 0,
3091         .channels_max = 0,
3092 };
3093
3094 static int alc_build_pcms(struct hda_codec *codec)
3095 {
3096         struct alc_spec *spec = codec->spec;
3097         struct hda_pcm *info = spec->pcm_rec;
3098         int i;
3099
3100         codec->num_pcms = 1;
3101         codec->pcm_info = info;
3102
3103         if (spec->no_analog)
3104                 goto skip_analog;
3105
3106         info->name = spec->stream_name_analog;
3107         if (spec->stream_analog_playback) {
3108                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3109                         return -EINVAL;
3110                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3111                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3112         }
3113         if (spec->stream_analog_capture) {
3114                 if (snd_BUG_ON(!spec->adc_nids))
3115                         return -EINVAL;
3116                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3117                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3118         }
3119
3120         if (spec->channel_mode) {
3121                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3122                 for (i = 0; i < spec->num_channel_mode; i++) {
3123                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3124                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3125                         }
3126                 }
3127         }
3128
3129  skip_analog:
3130         /* SPDIF for stream index #1 */
3131         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3132                 codec->num_pcms = 2;
3133                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3134                 info = spec->pcm_rec + 1;
3135                 info->name = spec->stream_name_digital;
3136                 if (spec->dig_out_type)
3137                         info->pcm_type = spec->dig_out_type;
3138                 else
3139                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3140                 if (spec->multiout.dig_out_nid &&
3141                     spec->stream_digital_playback) {
3142                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3143                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3144                 }
3145                 if (spec->dig_in_nid &&
3146                     spec->stream_digital_capture) {
3147                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3148                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3149                 }
3150                 /* FIXME: do we need this for all Realtek codec models? */
3151                 codec->spdif_status_reset = 1;
3152         }
3153
3154         if (spec->no_analog)
3155                 return 0;
3156
3157         /* If the use of more than one ADC is requested for the current
3158          * model, configure a second analog capture-only PCM.
3159          */
3160         /* Additional Analaog capture for index #2 */
3161         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3162             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3163                 codec->num_pcms = 3;
3164                 info = spec->pcm_rec + 2;
3165                 info->name = spec->stream_name_analog;
3166                 if (spec->alt_dac_nid) {
3167                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3168                                 *spec->stream_analog_alt_playback;
3169                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3170                                 spec->alt_dac_nid;
3171                 } else {
3172                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3173                                 alc_pcm_null_stream;
3174                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3175                 }
3176                 if (spec->num_adc_nids > 1) {
3177                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3178                                 *spec->stream_analog_alt_capture;
3179                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3180                                 spec->adc_nids[1];
3181                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3182                                 spec->num_adc_nids - 1;
3183                 } else {
3184                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3185                                 alc_pcm_null_stream;
3186                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3187                 }
3188         }
3189
3190         return 0;
3191 }
3192
3193 static void alc_free_kctls(struct hda_codec *codec)
3194 {
3195         struct alc_spec *spec = codec->spec;
3196
3197         if (spec->kctls.list) {
3198                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3199                 int i;
3200                 for (i = 0; i < spec->kctls.used; i++)
3201                         kfree(kctl[i].name);
3202         }
3203         snd_array_free(&spec->kctls);
3204 }
3205
3206 static void alc_free(struct hda_codec *codec)
3207 {
3208         struct alc_spec *spec = codec->spec;
3209
3210         if (!spec)
3211                 return;
3212
3213         alc_free_kctls(codec);
3214         kfree(spec);
3215         snd_hda_detach_beep_device(codec);
3216 }
3217
3218 #ifdef SND_HDA_NEEDS_RESUME
3219 static void store_pin_configs(struct hda_codec *codec)
3220 {
3221         struct alc_spec *spec = codec->spec;
3222         hda_nid_t nid, end_nid;
3223
3224         end_nid = codec->start_nid + codec->num_nodes;
3225         for (nid = codec->start_nid; nid < end_nid; nid++) {
3226                 unsigned int wid_caps = get_wcaps(codec, nid);
3227                 unsigned int wid_type =
3228                         (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3229                 if (wid_type != AC_WID_PIN)
3230                         continue;
3231                 if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
3232                         break;
3233                 spec->pin_nids[spec->num_pins] = nid;
3234                 spec->pin_cfgs[spec->num_pins] =
3235                         snd_hda_codec_read(codec, nid, 0,
3236                                            AC_VERB_GET_CONFIG_DEFAULT, 0);
3237                 spec->num_pins++;
3238         }
3239 }
3240
3241 static void resume_pin_configs(struct hda_codec *codec)
3242 {
3243         struct alc_spec *spec = codec->spec;
3244         int i;
3245
3246         for (i = 0; i < spec->num_pins; i++) {
3247                 hda_nid_t pin_nid = spec->pin_nids[i];
3248                 unsigned int pin_config = spec->pin_cfgs[i];
3249                 snd_hda_codec_write(codec, pin_nid, 0,
3250                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
3251                                     pin_config & 0x000000ff);
3252                 snd_hda_codec_write(codec, pin_nid, 0,
3253                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
3254                                     (pin_config & 0x0000ff00) >> 8);
3255                 snd_hda_codec_write(codec, pin_nid, 0,
3256                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
3257                                     (pin_config & 0x00ff0000) >> 16);
3258                 snd_hda_codec_write(codec, pin_nid, 0,
3259                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
3260                                     pin_config >> 24);
3261         }
3262 }
3263
3264 static int alc_resume(struct hda_codec *codec)
3265 {
3266         resume_pin_configs(codec);
3267         codec->patch_ops.init(codec);
3268         snd_hda_codec_resume_amp(codec);
3269         snd_hda_codec_resume_cache(codec);
3270         return 0;
3271 }
3272 #else
3273 #define store_pin_configs(codec)
3274 #endif
3275
3276 /*
3277  */
3278 static struct hda_codec_ops alc_patch_ops = {
3279         .build_controls = alc_build_controls,
3280         .build_pcms = alc_build_pcms,
3281         .init = alc_init,
3282         .free = alc_free,
3283         .unsol_event = alc_unsol_event,
3284 #ifdef SND_HDA_NEEDS_RESUME
3285         .resume = alc_resume,
3286 #endif
3287 #ifdef CONFIG_SND_HDA_POWER_SAVE
3288         .check_power_status = alc_check_power_status,
3289 #endif
3290 };
3291
3292
3293 /*
3294  * Test configuration for debugging
3295  *
3296  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3297  * enum controls.
3298  */
3299 #ifdef CONFIG_SND_DEBUG
3300 static hda_nid_t alc880_test_dac_nids[4] = {
3301         0x02, 0x03, 0x04, 0x05
3302 };
3303
3304 static struct hda_input_mux alc880_test_capture_source = {
3305         .num_items = 7,
3306         .items = {
3307                 { "In-1", 0x0 },
3308                 { "In-2", 0x1 },
3309                 { "In-3", 0x2 },
3310                 { "In-4", 0x3 },
3311                 { "CD", 0x4 },
3312                 { "Front", 0x5 },
3313                 { "Surround", 0x6 },
3314         },
3315 };
3316
3317 static struct hda_channel_mode alc880_test_modes[4] = {
3318         { 2, NULL },
3319         { 4, NULL },
3320         { 6, NULL },
3321         { 8, NULL },
3322 };
3323
3324 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3325                                  struct snd_ctl_elem_info *uinfo)
3326 {
3327         static char *texts[] = {
3328                 "N/A", "Line Out", "HP Out",
3329                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3330         };
3331         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3332         uinfo->count = 1;
3333         uinfo->value.enumerated.items = 8;
3334         if (uinfo->value.enumerated.item >= 8)
3335                 uinfo->value.enumerated.item = 7;
3336         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3337         return 0;
3338 }
3339
3340 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3341                                 struct snd_ctl_elem_value *ucontrol)
3342 {
3343         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3344         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3345         unsigned int pin_ctl, item = 0;
3346
3347         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3348                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3349         if (pin_ctl & AC_PINCTL_OUT_EN) {
3350                 if (pin_ctl & AC_PINCTL_HP_EN)
3351                         item = 2;
3352                 else
3353                         item = 1;
3354         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3355                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3356                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3357                 case AC_PINCTL_VREF_50:  item = 4; break;
3358                 case AC_PINCTL_VREF_GRD: item = 5; break;
3359                 case AC_PINCTL_VREF_80:  item = 6; break;
3360                 case AC_PINCTL_VREF_100: item = 7; break;
3361                 }
3362         }
3363         ucontrol->value.enumerated.item[0] = item;
3364         return 0;
3365 }
3366
3367 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3368                                 struct snd_ctl_elem_value *ucontrol)
3369 {
3370         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3371         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3372         static unsigned int ctls[] = {
3373                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3374                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3375                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3376                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3377                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3378                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3379         };
3380         unsigned int old_ctl, new_ctl;
3381
3382         old_ctl = snd_hda_codec_read(codec, nid, 0,
3383                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3384         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3385         if (old_ctl != new_ctl) {
3386                 int val;
3387                 snd_hda_codec_write_cache(codec, nid, 0,
3388                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3389                                           new_ctl);
3390                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3391                         HDA_AMP_MUTE : 0;
3392                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3393                                          HDA_AMP_MUTE, val);
3394                 return 1;
3395         }
3396         return 0;
3397 }
3398
3399 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3400                                  struct snd_ctl_elem_info *uinfo)
3401 {
3402         static char *texts[] = {
3403                 "Front", "Surround", "CLFE", "Side"
3404         };
3405         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3406         uinfo->count = 1;
3407         uinfo->value.enumerated.items = 4;
3408         if (uinfo->value.enumerated.item >= 4)
3409                 uinfo->value.enumerated.item = 3;
3410         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3411         return 0;
3412 }
3413
3414 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3415                                 struct snd_ctl_elem_value *ucontrol)
3416 {
3417         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3418         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3419         unsigned int sel;
3420
3421         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3422         ucontrol->value.enumerated.item[0] = sel & 3;
3423         return 0;
3424 }
3425
3426 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3427                                 struct snd_ctl_elem_value *ucontrol)
3428 {
3429         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3430         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3431         unsigned int sel;
3432
3433         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3434         if (ucontrol->value.enumerated.item[0] != sel) {
3435                 sel = ucontrol->value.enumerated.item[0] & 3;
3436                 snd_hda_codec_write_cache(codec, nid, 0,
3437                                           AC_VERB_SET_CONNECT_SEL, sel);
3438                 return 1;
3439         }
3440         return 0;
3441 }
3442
3443 #define PIN_CTL_TEST(xname,nid) {                       \
3444                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3445                         .name = xname,                 \
3446                         .info = alc_test_pin_ctl_info, \
3447                         .get = alc_test_pin_ctl_get,   \
3448                         .put = alc_test_pin_ctl_put,   \
3449                         .private_value = nid           \
3450                         }
3451
3452 #define PIN_SRC_TEST(xname,nid) {                       \
3453                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3454                         .name = xname,                 \
3455                         .info = alc_test_pin_src_info, \
3456                         .get = alc_test_pin_src_get,   \
3457                         .put = alc_test_pin_src_put,   \
3458                         .private_value = nid           \
3459                         }
3460
3461 static struct snd_kcontrol_new alc880_test_mixer[] = {
3462         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3463         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3464         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3465         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3466         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3467         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3468         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3469         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3470         PIN_CTL_TEST("Front Pin Mode", 0x14),
3471         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3472         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3473         PIN_CTL_TEST("Side Pin Mode", 0x17),
3474         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3475         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3476         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3477         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3478         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3479         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3480         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3481         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3482         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3483         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3484         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3485         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3486         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3487         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3488         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3489         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3490         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3491         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3492         {
3493                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3494                 .name = "Channel Mode",
3495                 .info = alc_ch_mode_info,
3496                 .get = alc_ch_mode_get,
3497                 .put = alc_ch_mode_put,
3498         },
3499         { } /* end */
3500 };
3501
3502 static struct hda_verb alc880_test_init_verbs[] = {
3503         /* Unmute inputs of 0x0c - 0x0f */
3504         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3505         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3506         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3507         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3508         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3509         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3510         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3511         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3512         /* Vol output for 0x0c-0x0f */
3513         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3514         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3515         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3516         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3517         /* Set output pins 0x14-0x17 */
3518         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3519         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3520         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3521         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3522         /* Unmute output pins 0x14-0x17 */
3523         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3525         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3526         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3527         /* Set input pins 0x18-0x1c */
3528         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3529         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3530         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3531         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3532         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3533         /* Mute input pins 0x18-0x1b */
3534         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3535         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3536         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3537         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3538         /* ADC set up */
3539         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3540         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3541         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3542         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3543         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3544         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3545         /* Analog input/passthru */
3546         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3547         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3548         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3549         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3550         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3551         { }
3552 };
3553 #endif
3554
3555 /*
3556  */
3557
3558 static const char *alc880_models[ALC880_MODEL_LAST] = {
3559         [ALC880_3ST]            = "3stack",
3560         [ALC880_TCL_S700]       = "tcl",
3561         [ALC880_3ST_DIG]        = "3stack-digout",
3562         [ALC880_CLEVO]          = "clevo",
3563         [ALC880_5ST]            = "5stack",
3564         [ALC880_5ST_DIG]        = "5stack-digout",
3565         [ALC880_W810]           = "w810",
3566         [ALC880_Z71V]           = "z71v",
3567         [ALC880_6ST]            = "6stack",
3568         [ALC880_6ST_DIG]        = "6stack-digout",
3569         [ALC880_ASUS]           = "asus",
3570         [ALC880_ASUS_W1V]       = "asus-w1v",
3571         [ALC880_ASUS_DIG]       = "asus-dig",
3572         [ALC880_ASUS_DIG2]      = "asus-dig2",
3573         [ALC880_UNIWILL_DIG]    = "uniwill",
3574         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3575         [ALC880_FUJITSU]        = "fujitsu",
3576         [ALC880_F1734]          = "F1734",
3577         [ALC880_LG]             = "lg",
3578         [ALC880_LG_LW]          = "lg-lw",
3579         [ALC880_MEDION_RIM]     = "medion",
3580 #ifdef CONFIG_SND_DEBUG
3581         [ALC880_TEST]           = "test",
3582 #endif
3583         [ALC880_AUTO]           = "auto",
3584 };
3585
3586 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3587         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3588         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3589         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3590         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3591         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3592         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3593         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3594         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3595         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3596         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3597         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3598         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3599         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3600         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3601         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3602         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3603         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3604         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3605         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3606         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3607         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3608         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3609         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3610         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3611         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3612         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3613         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3614         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3615         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3616         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3617         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3618         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3619         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3620         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3621         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3622         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3623         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3624         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3625         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3626         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3627         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3628         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3629         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3630         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3631         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3632         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3633         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3634         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3635         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3636         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3637         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3638         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3639         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3640         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3641         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3642         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3643         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3644         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3645         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3646         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3647         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3648         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3649         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3650         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3651         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3652         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3653         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3654         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3655         /* default Intel */
3656         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3657         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3658         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3659         {}
3660 };
3661
3662 /*
3663  * ALC880 codec presets
3664  */
3665 static struct alc_config_preset alc880_presets[] = {
3666         [ALC880_3ST] = {
3667                 .mixers = { alc880_three_stack_mixer },
3668                 .init_verbs = { alc880_volume_init_verbs,
3669                                 alc880_pin_3stack_init_verbs },
3670                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3671                 .dac_nids = alc880_dac_nids,
3672                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3673                 .channel_mode = alc880_threestack_modes,
3674                 .need_dac_fix = 1,
3675                 .input_mux = &alc880_capture_source,
3676         },
3677         [ALC880_3ST_DIG] = {
3678                 .mixers = { alc880_three_stack_mixer },
3679                 .init_verbs = { alc880_volume_init_verbs,
3680                                 alc880_pin_3stack_init_verbs },
3681                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3682                 .dac_nids = alc880_dac_nids,
3683                 .dig_out_nid = ALC880_DIGOUT_NID,
3684                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3685                 .channel_mode = alc880_threestack_modes,
3686                 .need_dac_fix = 1,
3687                 .input_mux = &alc880_capture_source,
3688         },
3689         [ALC880_TCL_S700] = {
3690                 .mixers = { alc880_tcl_s700_mixer },
3691                 .init_verbs = { alc880_volume_init_verbs,
3692                                 alc880_pin_tcl_S700_init_verbs,
3693                                 alc880_gpio2_init_verbs },
3694                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3695                 .dac_nids = alc880_dac_nids,
3696                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3697                 .num_adc_nids = 1, /* single ADC */
3698                 .hp_nid = 0x03,
3699                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3700                 .channel_mode = alc880_2_jack_modes,
3701                 .input_mux = &alc880_capture_source,
3702         },
3703         [ALC880_5ST] = {
3704                 .mixers = { alc880_three_stack_mixer,
3705                             alc880_five_stack_mixer},
3706                 .init_verbs = { alc880_volume_init_verbs,
3707                                 alc880_pin_5stack_init_verbs },
3708                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3709                 .dac_nids = alc880_dac_nids,
3710                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3711                 .channel_mode = alc880_fivestack_modes,
3712                 .input_mux = &alc880_capture_source,
3713         },
3714         [ALC880_5ST_DIG] = {
3715                 .mixers = { alc880_three_stack_mixer,
3716                             alc880_five_stack_mixer },
3717                 .init_verbs = { alc880_volume_init_verbs,
3718                                 alc880_pin_5stack_init_verbs },
3719                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3720                 .dac_nids = alc880_dac_nids,
3721                 .dig_out_nid = ALC880_DIGOUT_NID,
3722                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3723                 .channel_mode = alc880_fivestack_modes,
3724                 .input_mux = &alc880_capture_source,
3725         },
3726         [ALC880_6ST] = {
3727                 .mixers = { alc880_six_stack_mixer },
3728                 .init_verbs = { alc880_volume_init_verbs,
3729                                 alc880_pin_6stack_init_verbs },
3730                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3731                 .dac_nids = alc880_6st_dac_nids,
3732                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3733                 .channel_mode = alc880_sixstack_modes,
3734                 .input_mux = &alc880_6stack_capture_source,
3735         },
3736         [ALC880_6ST_DIG] = {
3737                 .mixers = { alc880_six_stack_mixer },
3738                 .init_verbs = { alc880_volume_init_verbs,
3739                                 alc880_pin_6stack_init_verbs },
3740                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3741                 .dac_nids = alc880_6st_dac_nids,
3742                 .dig_out_nid = ALC880_DIGOUT_NID,
3743                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3744                 .channel_mode = alc880_sixstack_modes,
3745                 .input_mux = &alc880_6stack_capture_source,
3746         },
3747         [ALC880_W810] = {
3748                 .mixers = { alc880_w810_base_mixer },
3749                 .init_verbs = { alc880_volume_init_verbs,
3750                                 alc880_pin_w810_init_verbs,
3751                                 alc880_gpio2_init_verbs },
3752                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3753                 .dac_nids = alc880_w810_dac_nids,
3754                 .dig_out_nid = ALC880_DIGOUT_NID,
3755                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3756                 .channel_mode = alc880_w810_modes,
3757                 .input_mux = &alc880_capture_source,
3758         },
3759         [ALC880_Z71V] = {
3760                 .mixers = { alc880_z71v_mixer },
3761                 .init_verbs = { alc880_volume_init_verbs,
3762                                 alc880_pin_z71v_init_verbs },
3763                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3764                 .dac_nids = alc880_z71v_dac_nids,
3765                 .dig_out_nid = ALC880_DIGOUT_NID,
3766                 .hp_nid = 0x03,
3767                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3768                 .channel_mode = alc880_2_jack_modes,
3769                 .input_mux = &alc880_capture_source,
3770         },
3771         [ALC880_F1734] = {
3772                 .mixers = { alc880_f1734_mixer },
3773                 .init_verbs = { alc880_volume_init_verbs,
3774                                 alc880_pin_f1734_init_verbs },
3775                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3776                 .dac_nids = alc880_f1734_dac_nids,
3777                 .hp_nid = 0x02,
3778                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3779                 .channel_mode = alc880_2_jack_modes,
3780                 .input_mux = &alc880_f1734_capture_source,
3781                 .unsol_event = alc880_uniwill_p53_unsol_event,
3782                 .init_hook = alc880_uniwill_p53_hp_automute,
3783         },
3784         [ALC880_ASUS] = {
3785                 .mixers = { alc880_asus_mixer },
3786                 .init_verbs = { alc880_volume_init_verbs,
3787                                 alc880_pin_asus_init_verbs,
3788                                 alc880_gpio1_init_verbs },
3789                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3790                 .dac_nids = alc880_asus_dac_nids,
3791                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3792                 .channel_mode = alc880_asus_modes,
3793                 .need_dac_fix = 1,
3794                 .input_mux = &alc880_capture_source,
3795         },
3796         [ALC880_ASUS_DIG] = {
3797                 .mixers = { alc880_asus_mixer },
3798                 .init_verbs = { alc880_volume_init_verbs,
3799                                 alc880_pin_asus_init_verbs,
3800                                 alc880_gpio1_init_verbs },
3801                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3802                 .dac_nids = alc880_asus_dac_nids,
3803                 .dig_out_nid = ALC880_DIGOUT_NID,
3804                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3805                 .channel_mode = alc880_asus_modes,
3806                 .need_dac_fix = 1,
3807                 .input_mux = &alc880_capture_source,
3808         },
3809         [ALC880_ASUS_DIG2] = {
3810                 .mixers = { alc880_asus_mixer },
3811                 .init_verbs = { alc880_volume_init_verbs,
3812                                 alc880_pin_asus_init_verbs,
3813                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3814                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3815                 .dac_nids = alc880_asus_dac_nids,
3816                 .dig_out_nid = ALC880_DIGOUT_NID,
3817                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3818                 .channel_mode = alc880_asus_modes,
3819                 .need_dac_fix = 1,
3820                 .input_mux = &alc880_capture_source,
3821         },
3822         [ALC880_ASUS_W1V] = {
3823                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3824                 .init_verbs = { alc880_volume_init_verbs,
3825                                 alc880_pin_asus_init_verbs,
3826                                 alc880_gpio1_init_verbs },
3827                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3828                 .dac_nids = alc880_asus_dac_nids,
3829                 .dig_out_nid = ALC880_DIGOUT_NID,
3830                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3831                 .channel_mode = alc880_asus_modes,
3832                 .need_dac_fix = 1,
3833                 .input_mux = &alc880_capture_source,
3834         },
3835         [ALC880_UNIWILL_DIG] = {
3836                 .mixers = { alc880_asus_mixer },
3837                 .init_verbs = { alc880_volume_init_verbs,
3838                                 alc880_pin_asus_init_verbs },
3839                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3840                 .dac_nids = alc880_asus_dac_nids,
3841                 .dig_out_nid = ALC880_DIGOUT_NID,
3842                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3843                 .channel_mode = alc880_asus_modes,
3844                 .need_dac_fix = 1,
3845                 .input_mux = &alc880_capture_source,
3846         },
3847         [ALC880_UNIWILL] = {
3848                 .mixers = { alc880_uniwill_mixer },
3849                 .init_verbs = { alc880_volume_init_verbs,
3850                                 alc880_uniwill_init_verbs },
3851                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3852                 .dac_nids = alc880_asus_dac_nids,
3853                 .dig_out_nid = ALC880_DIGOUT_NID,
3854                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3855                 .channel_mode = alc880_threestack_modes,
3856                 .need_dac_fix = 1,
3857                 .input_mux = &alc880_capture_source,
3858                 .unsol_event = alc880_uniwill_unsol_event,
3859                 .init_hook = alc880_uniwill_automute,
3860         },
3861         [ALC880_UNIWILL_P53] = {
3862                 .mixers = { alc880_uniwill_p53_mixer },
3863                 .init_verbs = { alc880_volume_init_verbs,
3864                                 alc880_uniwill_p53_init_verbs },
3865                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3866                 .dac_nids = alc880_asus_dac_nids,
3867                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3868                 .channel_mode = alc880_threestack_modes,
3869                 .input_mux = &alc880_capture_source,
3870                 .unsol_event = alc880_uniwill_p53_unsol_event,
3871                 .init_hook = alc880_uniwill_p53_hp_automute,
3872         },
3873         [ALC880_FUJITSU] = {
3874                 .mixers = { alc880_fujitsu_mixer },
3875                 .init_verbs = { alc880_volume_init_verbs,
3876                                 alc880_uniwill_p53_init_verbs,
3877                                 alc880_beep_init_verbs },
3878                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3879                 .dac_nids = alc880_dac_nids,
3880                 .dig_out_nid = ALC880_DIGOUT_NID,
3881                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3882                 .channel_mode = alc880_2_jack_modes,
3883                 .input_mux = &alc880_capture_source,
3884                 .unsol_event = alc880_uniwill_p53_unsol_event,
3885                 .init_hook = alc880_uniwill_p53_hp_automute,
3886         },
3887         [ALC880_CLEVO] = {
3888                 .mixers = { alc880_three_stack_mixer },
3889                 .init_verbs = { alc880_volume_init_verbs,
3890                                 alc880_pin_clevo_init_verbs },
3891                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3892                 .dac_nids = alc880_dac_nids,
3893                 .hp_nid = 0x03,
3894                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3895                 .channel_mode = alc880_threestack_modes,
3896                 .need_dac_fix = 1,
3897                 .input_mux = &alc880_capture_source,
3898         },
3899         [ALC880_LG] = {
3900                 .mixers = { alc880_lg_mixer },
3901                 .init_verbs = { alc880_volume_init_verbs,
3902                                 alc880_lg_init_verbs },
3903                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3904                 .dac_nids = alc880_lg_dac_nids,
3905                 .dig_out_nid = ALC880_DIGOUT_NID,
3906                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3907                 .channel_mode = alc880_lg_ch_modes,
3908                 .need_dac_fix = 1,
3909                 .input_mux = &alc880_lg_capture_source,
3910                 .unsol_event = alc880_lg_unsol_event,
3911                 .init_hook = alc880_lg_automute,
3912 #ifdef CONFIG_SND_HDA_POWER_SAVE
3913                 .loopbacks = alc880_lg_loopbacks,
3914 #endif
3915         },
3916         [ALC880_LG_LW] = {
3917                 .mixers = { alc880_lg_lw_mixer },
3918                 .init_verbs = { alc880_volume_init_verbs,
3919                                 alc880_lg_lw_init_verbs },
3920                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3921                 .dac_nids = alc880_dac_nids,
3922                 .dig_out_nid = ALC880_DIGOUT_NID,
3923                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3924                 .channel_mode = alc880_lg_lw_modes,
3925                 .input_mux = &alc880_lg_lw_capture_source,
3926                 .unsol_event = alc880_lg_lw_unsol_event,
3927                 .init_hook = alc880_lg_lw_automute,
3928         },
3929         [ALC880_MEDION_RIM] = {
3930                 .mixers = { alc880_medion_rim_mixer },
3931                 .init_verbs = { alc880_volume_init_verbs,
3932                                 alc880_medion_rim_init_verbs,
3933                                 alc_gpio2_init_verbs },
3934                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3935                 .dac_nids = alc880_dac_nids,
3936                 .dig_out_nid = ALC880_DIGOUT_NID,
3937                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3938                 .channel_mode = alc880_2_jack_modes,
3939                 .input_mux = &alc880_medion_rim_capture_source,
3940                 .unsol_event = alc880_medion_rim_unsol_event,
3941                 .init_hook = alc880_medion_rim_automute,
3942         },
3943 #ifdef CONFIG_SND_DEBUG
3944         [ALC880_TEST] = {
3945                 .mixers = { alc880_test_mixer },
3946                 .init_verbs = { alc880_test_init_verbs },
3947                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3948                 .dac_nids = alc880_test_dac_nids,
3949                 .dig_out_nid = ALC880_DIGOUT_NID,
3950                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3951                 .channel_mode = alc880_test_modes,
3952                 .input_mux = &alc880_test_capture_source,
3953         },
3954 #endif
3955 };
3956
3957 /*
3958  * Automatic parse of I/O pins from the BIOS configuration
3959  */
3960
3961 enum {
3962         ALC_CTL_WIDGET_VOL,
3963         ALC_CTL_WIDGET_MUTE,
3964         ALC_CTL_BIND_MUTE,
3965 };
3966 static struct snd_kcontrol_new alc880_control_templates[] = {
3967         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3968         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3969         HDA_BIND_MUTE(NULL, 0, 0, 0),
3970 };
3971
3972 /* add dynamic controls */
3973 static int add_control(struct alc_spec *spec, int type, const char *name,
3974                        unsigned long val)
3975 {
3976         struct snd_kcontrol_new *knew;
3977
3978         snd_array_init(&spec->kctls, sizeof(*knew), 32);
3979         knew = snd_array_new(&spec->kctls);
3980         if (!knew)
3981                 return -ENOMEM;
3982         *knew = alc880_control_templates[type];
3983         knew->name = kstrdup(name, GFP_KERNEL);
3984         if (!knew->name)
3985                 return -ENOMEM;
3986         knew->private_value = val;
3987         return 0;
3988 }
3989
3990 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3991 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3992 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3993 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3994 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3995 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3996 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3997 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3998 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3999 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4000 #define ALC880_PIN_CD_NID               0x1c
4001
4002 /* fill in the dac_nids table from the parsed pin configuration */
4003 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4004                                      const struct auto_pin_cfg *cfg)
4005 {
4006         hda_nid_t nid;
4007         int assigned[4];
4008         int i, j;
4009
4010         memset(assigned, 0, sizeof(assigned));
4011         spec->multiout.dac_nids = spec->private_dac_nids;
4012
4013         /* check the pins hardwired to audio widget */
4014         for (i = 0; i < cfg->line_outs; i++) {
4015                 nid = cfg->line_out_pins[i];
4016                 if (alc880_is_fixed_pin(nid)) {
4017                         int idx = alc880_fixed_pin_idx(nid);
4018                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4019                         assigned[idx] = 1;
4020                 }
4021         }
4022         /* left pins can be connect to any audio widget */
4023         for (i = 0; i < cfg->line_outs; i++) {
4024                 nid = cfg->line_out_pins[i];
4025                 if (alc880_is_fixed_pin(nid))
4026                         continue;
4027                 /* search for an empty channel */
4028                 for (j = 0; j < cfg->line_outs; j++) {
4029                         if (!assigned[j]) {
4030                                 spec->multiout.dac_nids[i] =
4031                                         alc880_idx_to_dac(j);
4032                                 assigned[j] = 1;
4033                                 break;
4034                         }
4035                 }
4036         }
4037         spec->multiout.num_dacs = cfg->line_outs;
4038         return 0;
4039 }
4040
4041 /* add playback controls from the parsed DAC table */
4042 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4043                                              const struct auto_pin_cfg *cfg)
4044 {
4045         char name[32];
4046         static const char *chname[4] = {
4047                 "Front", "Surround", NULL /*CLFE*/, "Side"
4048         };
4049         hda_nid_t nid;
4050         int i, err;
4051
4052         for (i = 0; i < cfg->line_outs; i++) {
4053                 if (!spec->multiout.dac_nids[i])
4054                         continue;
4055                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4056                 if (i == 2) {
4057                         /* Center/LFE */
4058                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4059                                           "Center Playback Volume",
4060                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4061                                                               HDA_OUTPUT));
4062                         if (err < 0)
4063                                 return err;
4064                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4065                                           "LFE Playback Volume",
4066                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4067                                                               HDA_OUTPUT));
4068                         if (err < 0)
4069                                 return err;
4070                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4071                                           "Center Playback Switch",
4072                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4073                                                               HDA_INPUT));
4074                         if (err < 0)
4075                                 return err;
4076                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4077                                           "LFE Playback Switch",
4078                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4079                                                               HDA_INPUT));
4080                         if (err < 0)
4081                                 return err;
4082                 } else {
4083                         sprintf(name, "%s Playback Volume", chname[i]);
4084                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4085                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4086                                                               HDA_OUTPUT));
4087                         if (err < 0)
4088                                 return err;
4089                         sprintf(name, "%s Playback Switch", chname[i]);
4090                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4091                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4092                                                               HDA_INPUT));
4093                         if (err < 0)
4094                                 return err;
4095                 }
4096         }
4097         return 0;
4098 }
4099
4100 /* add playback controls for speaker and HP outputs */
4101 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4102                                         const char *pfx)
4103 {
4104         hda_nid_t nid;
4105         int err;
4106         char name[32];
4107
4108         if (!pin)
4109                 return 0;
4110
4111         if (alc880_is_fixed_pin(pin)) {
4112                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4113                 /* specify the DAC as the extra output */
4114                 if (!spec->multiout.hp_nid)
4115                         spec->multiout.hp_nid = nid;
4116                 else
4117                         spec->multiout.extra_out_nid[0] = nid;
4118                 /* control HP volume/switch on the output mixer amp */
4119                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4120                 sprintf(name, "%s Playback Volume", pfx);
4121                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4122                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4123                 if (err < 0)
4124                         return err;
4125                 sprintf(name, "%s Playback Switch", pfx);
4126                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4127                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4128                 if (err < 0)
4129                         return err;
4130         } else if (alc880_is_multi_pin(pin)) {
4131                 /* set manual connection */
4132                 /* we have only a switch on HP-out PIN */
4133                 sprintf(name, "%s Playback Switch", pfx);
4134                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4135                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4136                 if (err < 0)
4137                         return err;
4138         }
4139         return 0;
4140 }
4141
4142 /* create input playback/capture controls for the given pin */
4143 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4144                             const char *ctlname,
4145                             int idx, hda_nid_t mix_nid)
4146 {
4147         char name[32];
4148         int err;
4149
4150         sprintf(name, "%s Playback Volume", ctlname);
4151         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4152                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4153         if (err < 0)
4154                 return err;
4155         sprintf(name, "%s Playback Switch", ctlname);
4156         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4157                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4158         if (err < 0)
4159                 return err;
4160         return 0;
4161 }
4162
4163 /* create playback/capture controls for input pins */
4164 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4165                                                 const struct auto_pin_cfg *cfg)
4166 {
4167         struct hda_input_mux *imux = &spec->private_imux[0];
4168         int i, err, idx;
4169
4170         for (i = 0; i < AUTO_PIN_LAST; i++) {
4171                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4172                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4173                         err = new_analog_input(spec, cfg->input_pins[i],
4174                                                auto_pin_cfg_labels[i],
4175                                                idx, 0x0b);
4176                         if (err < 0)
4177                                 return err;
4178                         imux->items[imux->num_items].label =
4179                                 auto_pin_cfg_labels[i];
4180                         imux->items[imux->num_items].index =
4181                                 alc880_input_pin_idx(cfg->input_pins[i]);
4182                         imux->num_items++;
4183                 }
4184         }
4185         return 0;
4186 }
4187
4188 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4189                                unsigned int pin_type)
4190 {
4191         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4192                             pin_type);
4193         /* unmute pin */
4194         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4195                             AMP_OUT_UNMUTE);
4196 }
4197
4198 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4199                                               hda_nid_t nid, int pin_type,
4200                                               int dac_idx)
4201 {
4202         alc_set_pin_output(codec, nid, pin_type);
4203         /* need the manual connection? */
4204         if (alc880_is_multi_pin(nid)) {
4205                 struct alc_spec *spec = codec->spec;
4206                 int idx = alc880_multi_pin_idx(nid);
4207                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4208                                     AC_VERB_SET_CONNECT_SEL,
4209                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4210         }
4211 }
4212
4213 static int get_pin_type(int line_out_type)
4214 {
4215         if (line_out_type == AUTO_PIN_HP_OUT)
4216                 return PIN_HP;
4217         else
4218                 return PIN_OUT;
4219 }
4220
4221 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4222 {
4223         struct alc_spec *spec = codec->spec;
4224         int i;
4225
4226         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4227         for (i = 0; i < spec->autocfg.line_outs; i++) {
4228                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4229                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4230                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4231         }
4232 }
4233
4234 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4235 {
4236         struct alc_spec *spec = codec->spec;
4237         hda_nid_t pin;
4238
4239         pin = spec->autocfg.speaker_pins[0];
4240         if (pin) /* connect to front */
4241                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4242         pin = spec->autocfg.hp_pins[0];
4243         if (pin) /* connect to front */
4244                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4245 }
4246
4247 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4248 {
4249         struct alc_spec *spec = codec->spec;
4250         int i;
4251
4252         for (i = 0; i < AUTO_PIN_LAST; i++) {
4253                 hda_nid_t nid = spec->autocfg.input_pins[i];
4254                 if (alc880_is_input_pin(nid)) {
4255                         snd_hda_codec_write(codec, nid, 0,
4256                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
4257                                             i <= AUTO_PIN_FRONT_MIC ?
4258                                             PIN_VREF80 : PIN_IN);
4259                         if (nid != ALC880_PIN_CD_NID)
4260                                 snd_hda_codec_write(codec, nid, 0,
4261                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4262                                                     AMP_OUT_MUTE);
4263                 }
4264         }
4265 }
4266
4267 /* parse the BIOS configuration and set up the alc_spec */
4268 /* return 1 if successful, 0 if the proper config is not found,
4269  * or a negative error code
4270  */
4271 static int alc880_parse_auto_config(struct hda_codec *codec)
4272 {
4273         struct alc_spec *spec = codec->spec;
4274         int i, err;
4275         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4276
4277         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4278                                            alc880_ignore);
4279         if (err < 0)
4280                 return err;
4281         if (!spec->autocfg.line_outs)
4282                 return 0; /* can't find valid BIOS pin config */
4283
4284         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4285         if (err < 0)
4286                 return err;
4287         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4288         if (err < 0)
4289                 return err;
4290         err = alc880_auto_create_extra_out(spec,
4291                                            spec->autocfg.speaker_pins[0],
4292                                            "Speaker");
4293         if (err < 0)
4294                 return err;
4295         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4296                                            "Headphone");
4297         if (err < 0)
4298                 return err;
4299         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4300         if (err < 0)
4301                 return err;
4302
4303         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4304
4305         /* check multiple SPDIF-out (for recent codecs) */
4306         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4307                 hda_nid_t dig_nid;
4308                 err = snd_hda_get_connections(codec,
4309                                               spec->autocfg.dig_out_pins[i],
4310                                               &dig_nid, 1);
4311                 if (err < 0)
4312                         continue;
4313                 if (!i)
4314                         spec->multiout.dig_out_nid = dig_nid;
4315                 else {
4316                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4317                         spec->slave_dig_outs[i - 1] = dig_nid;
4318                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4319                                 break;
4320                 }
4321         }
4322         if (spec->autocfg.dig_in_pin)
4323                 spec->dig_in_nid = ALC880_DIGIN_NID;
4324
4325         if (spec->kctls.list)
4326                 add_mixer(spec, spec->kctls.list);
4327
4328         add_verb(spec, alc880_volume_init_verbs);
4329
4330         spec->num_mux_defs = 1;
4331         spec->input_mux = &spec->private_imux[0];
4332
4333         store_pin_configs(codec);
4334         return 1;
4335 }
4336
4337 /* additional initialization for auto-configuration model */
4338 static void alc880_auto_init(struct hda_codec *codec)
4339 {
4340         struct alc_spec *spec = codec->spec;
4341         alc880_auto_init_multi_out(codec);
4342         alc880_auto_init_extra_out(codec);
4343         alc880_auto_init_analog_input(codec);
4344         if (spec->unsol_event)
4345                 alc_inithook(codec);
4346 }
4347
4348 static void set_capture_mixer(struct alc_spec *spec)
4349 {
4350         static struct snd_kcontrol_new *caps[3] = {
4351                 alc_capture_mixer1,
4352                 alc_capture_mixer2,
4353                 alc_capture_mixer3,
4354         };
4355         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
4356                 spec->cap_mixer = caps[spec->num_adc_nids - 1];
4357 }
4358
4359 #define set_beep_amp(spec, nid, idx, dir) \
4360         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4361
4362 /*
4363  * OK, here we have finally the patch for ALC880
4364  */
4365
4366 static int patch_alc880(struct hda_codec *codec)
4367 {
4368         struct alc_spec *spec;
4369         int board_config;
4370         int err;
4371
4372         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4373         if (spec == NULL)
4374                 return -ENOMEM;
4375
4376         codec->spec = spec;
4377
4378         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4379                                                   alc880_models,
4380                                                   alc880_cfg_tbl);
4381         if (board_config < 0) {
4382                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4383                        "trying auto-probe from BIOS...\n");
4384                 board_config = ALC880_AUTO;
4385         }
4386
4387         if (board_config == ALC880_AUTO) {
4388                 /* automatic parse from the BIOS config */
4389                 err = alc880_parse_auto_config(codec);
4390                 if (err < 0) {
4391                         alc_free(codec);
4392                         return err;
4393                 } else if (!err) {
4394                         printk(KERN_INFO
4395                                "hda_codec: Cannot set up configuration "
4396                                "from BIOS.  Using 3-stack mode...\n");
4397                         board_config = ALC880_3ST;
4398                 }
4399         }
4400
4401         err = snd_hda_attach_beep_device(codec, 0x1);
4402         if (err < 0) {
4403                 alc_free(codec);
4404                 return err;
4405         }
4406
4407         if (board_config != ALC880_AUTO)
4408                 setup_preset(spec, &alc880_presets[board_config]);
4409
4410         spec->stream_name_analog = "ALC880 Analog";
4411         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4412         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4413         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4414
4415         spec->stream_name_digital = "ALC880 Digital";
4416         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4417         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4418
4419         if (!spec->adc_nids && spec->input_mux) {
4420                 /* check whether NID 0x07 is valid */
4421                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4422                 /* get type */
4423                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4424                 if (wcap != AC_WID_AUD_IN) {
4425                         spec->adc_nids = alc880_adc_nids_alt;
4426                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4427                 } else {
4428                         spec->adc_nids = alc880_adc_nids;
4429                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4430                 }
4431         }
4432         set_capture_mixer(spec);
4433         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4434
4435         spec->vmaster_nid = 0x0c;
4436
4437         codec->patch_ops = alc_patch_ops;
4438         if (board_config == ALC880_AUTO)
4439                 spec->init_hook = alc880_auto_init;
4440 #ifdef CONFIG_SND_HDA_POWER_SAVE
4441         if (!spec->loopback.amplist)
4442                 spec->loopback.amplist = alc880_loopbacks;
4443 #endif
4444         codec->proc_widget_hook = print_realtek_coef;
4445
4446         return 0;
4447 }
4448
4449
4450 /*
4451  * ALC260 support
4452  */
4453
4454 static hda_nid_t alc260_dac_nids[1] = {
4455         /* front */
4456         0x02,
4457 };
4458
4459 static hda_nid_t alc260_adc_nids[1] = {
4460         /* ADC0 */
4461         0x04,
4462 };
4463
4464 static hda_nid_t alc260_adc_nids_alt[1] = {
4465         /* ADC1 */
4466         0x05,
4467 };
4468
4469 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4470  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4471  */
4472 static hda_nid_t alc260_dual_adc_nids[2] = {
4473         /* ADC0, ADC1 */
4474         0x04, 0x05
4475 };
4476
4477 #define ALC260_DIGOUT_NID       0x03
4478 #define ALC260_DIGIN_NID        0x06
4479
4480 static struct hda_input_mux alc260_capture_source = {
4481         .num_items = 4,
4482         .items = {
4483                 { "Mic", 0x0 },
4484                 { "Front Mic", 0x1 },
4485                 { "Line", 0x2 },
4486                 { "CD", 0x4 },
4487         },
4488 };
4489
4490 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4491  * headphone jack and the internal CD lines since these are the only pins at
4492  * which audio can appear.  For flexibility, also allow the option of
4493  * recording the mixer output on the second ADC (ADC0 doesn't have a
4494  * connection to the mixer output).
4495  */
4496 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4497         {
4498                 .num_items = 3,
4499                 .items = {
4500                         { "Mic/Line", 0x0 },
4501                         { "CD", 0x4 },
4502                         { "Headphone", 0x2 },
4503                 },
4504         },
4505         {
4506                 .num_items = 4,
4507                 .items = {
4508                         { "Mic/Line", 0x0 },
4509                         { "CD", 0x4 },
4510                         { "Headphone", 0x2 },
4511                         { "Mixer", 0x5 },
4512                 },
4513         },
4514
4515 };
4516
4517 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4518  * the Fujitsu S702x, but jacks are marked differently.
4519  */
4520 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4521         {
4522                 .num_items = 4,
4523                 .items = {
4524                         { "Mic", 0x0 },
4525                         { "Line", 0x2 },
4526                         { "CD", 0x4 },
4527                         { "Headphone", 0x5 },
4528                 },
4529         },
4530         {
4531                 .num_items = 5,
4532                 .items = {
4533                         { "Mic", 0x0 },
4534                         { "Line", 0x2 },
4535                         { "CD", 0x4 },
4536                         { "Headphone", 0x6 },
4537                         { "Mixer", 0x5 },
4538                 },
4539         },
4540 };
4541
4542 /* Maxdata Favorit 100XS */
4543 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4544         {
4545                 .num_items = 2,
4546                 .items = {
4547                         { "Line/Mic", 0x0 },
4548                         { "CD", 0x4 },
4549                 },
4550         },
4551         {
4552                 .num_items = 3,
4553                 .items = {
4554                         { "Line/Mic", 0x0 },
4555                         { "CD", 0x4 },
4556                         { "Mixer", 0x5 },
4557                 },
4558         },
4559 };
4560
4561 /*
4562  * This is just place-holder, so there's something for alc_build_pcms to look
4563  * at when it calculates the maximum number of channels. ALC260 has no mixer
4564  * element which allows changing the channel mode, so the verb list is
4565  * never used.
4566  */
4567 static struct hda_channel_mode alc260_modes[1] = {
4568         { 2, NULL },
4569 };
4570
4571
4572 /* Mixer combinations
4573  *
4574  * basic: base_output + input + pc_beep + capture
4575  * HP: base_output + input + capture_alt
4576  * HP_3013: hp_3013 + input + capture
4577  * fujitsu: fujitsu + capture
4578  * acer: acer + capture
4579  */
4580
4581 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4582         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4583         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4584         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4585         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4586         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4587         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4588         { } /* end */
4589 };
4590
4591 static struct snd_kcontrol_new alc260_input_mixer[] = {
4592         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4593         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4594         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4595         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4596         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4597         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4598         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4599         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4600         { } /* end */
4601 };
4602
4603 /* update HP, line and mono out pins according to the master switch */
4604 static void alc260_hp_master_update(struct hda_codec *codec,
4605                                     hda_nid_t hp, hda_nid_t line,
4606                                     hda_nid_t mono)
4607 {
4608         struct alc_spec *spec = codec->spec;
4609         unsigned int val = spec->master_sw ? PIN_HP : 0;
4610         /* change HP and line-out pins */
4611         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4612                             val);
4613         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4614                             val);
4615         /* mono (speaker) depending on the HP jack sense */
4616         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4617         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4618                             val);
4619 }
4620
4621 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4622                                    struct snd_ctl_elem_value *ucontrol)
4623 {
4624         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4625         struct alc_spec *spec = codec->spec;
4626         *ucontrol->value.integer.value = spec->master_sw;
4627         return 0;
4628 }
4629
4630 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4631                                    struct snd_ctl_elem_value *ucontrol)
4632 {
4633         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4634         struct alc_spec *spec = codec->spec;
4635         int val = !!*ucontrol->value.integer.value;
4636         hda_nid_t hp, line, mono;
4637
4638         if (val == spec->master_sw)
4639                 return 0;
4640         spec->master_sw = val;
4641         hp = (kcontrol->private_value >> 16) & 0xff;
4642         line = (kcontrol->private_value >> 8) & 0xff;
4643         mono = kcontrol->private_value & 0xff;
4644         alc260_hp_master_update(codec, hp, line, mono);
4645         return 1;
4646 }
4647
4648 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4649         {
4650                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4651                 .name = "Master Playback Switch",
4652                 .info = snd_ctl_boolean_mono_info,
4653                 .get = alc260_hp_master_sw_get,
4654                 .put = alc260_hp_master_sw_put,
4655                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4656         },
4657         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4658         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4659         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4660         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4661         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4662                               HDA_OUTPUT),
4663         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4664         { } /* end */
4665 };
4666
4667 static struct hda_verb alc260_hp_unsol_verbs[] = {
4668         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4669         {},
4670 };
4671
4672 static void alc260_hp_automute(struct hda_codec *codec)
4673 {
4674         struct alc_spec *spec = codec->spec;
4675         unsigned int present;
4676
4677         present = snd_hda_codec_read(codec, 0x10, 0,
4678                                      AC_VERB_GET_PIN_SENSE, 0);
4679         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4680         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4681 }
4682
4683 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4684 {
4685         if ((res >> 26) == ALC880_HP_EVENT)
4686                 alc260_hp_automute(codec);
4687 }
4688
4689 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4690         {
4691                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4692                 .name = "Master Playback Switch",
4693                 .info = snd_ctl_boolean_mono_info,
4694                 .get = alc260_hp_master_sw_get,
4695                 .put = alc260_hp_master_sw_put,
4696                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4697         },
4698         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4699         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4700         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4701         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4702         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4703         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4704         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4705         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4706         { } /* end */
4707 };
4708
4709 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4710         .ops = &snd_hda_bind_vol,
4711         .values = {
4712                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4713                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4714                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4715                 0
4716         },
4717 };
4718
4719 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4720         .ops = &snd_hda_bind_sw,
4721         .values = {
4722                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4723                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4724                 0
4725         },
4726 };
4727
4728 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4729         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4730         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4731         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4732         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4733         { } /* end */
4734 };
4735
4736 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4737         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4738         {},
4739 };
4740
4741 static void alc260_hp_3013_automute(struct hda_codec *codec)
4742 {
4743         struct alc_spec *spec = codec->spec;
4744         unsigned int present;
4745
4746         present = snd_hda_codec_read(codec, 0x15, 0,
4747                                      AC_VERB_GET_PIN_SENSE, 0);
4748         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4749         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4750 }
4751
4752 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4753                                        unsigned int res)
4754 {
4755         if ((res >> 26) == ALC880_HP_EVENT)
4756                 alc260_hp_3013_automute(codec);
4757 }
4758
4759 static void alc260_hp_3012_automute(struct hda_codec *codec)
4760 {
4761         unsigned int present, bits;
4762
4763         present = snd_hda_codec_read(codec, 0x10, 0,
4764                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4765
4766         bits = present ? 0 : PIN_OUT;
4767         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4768                             bits);
4769         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4770                             bits);
4771         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4772                             bits);
4773 }
4774
4775 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4776                                        unsigned int res)
4777 {
4778         if ((res >> 26) == ALC880_HP_EVENT)
4779                 alc260_hp_3012_automute(codec);
4780 }
4781
4782 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4783  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4784  */
4785 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4786         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4787         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4788         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4789         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4790         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4791         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4792         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4793         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4794         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4795         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4796         { } /* end */
4797 };
4798
4799 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4800  * versions of the ALC260 don't act on requests to enable mic bias from NID
4801  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4802  * datasheet doesn't mention this restriction.  At this stage it's not clear
4803  * whether this behaviour is intentional or is a hardware bug in chip
4804  * revisions available in early 2006.  Therefore for now allow the
4805  * "Headphone Jack Mode" control to span all choices, but if it turns out
4806  * that the lack of mic bias for this NID is intentional we could change the
4807  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4808  *
4809  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4810  * don't appear to make the mic bias available from the "line" jack, even
4811  * though the NID used for this jack (0x14) can supply it.  The theory is
4812  * that perhaps Acer have included blocking capacitors between the ALC260
4813  * and the output jack.  If this turns out to be the case for all such
4814  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4815  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4816  *
4817  * The C20x Tablet series have a mono internal speaker which is controlled
4818  * via the chip's Mono sum widget and pin complex, so include the necessary
4819  * controls for such models.  On models without a "mono speaker" the control
4820  * won't do anything.
4821  */
4822 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4823         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4824         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4825         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4826         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4827                               HDA_OUTPUT),
4828         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4829                            HDA_INPUT),
4830         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4831         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4832         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4833         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4834         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4835         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4836         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4837         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4838         { } /* end */
4839 };
4840
4841 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4842  */
4843 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4844         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4845         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4846         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4847         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4848         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4849         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4850         { } /* end */
4851 };
4852
4853 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4854  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4855  */
4856 static struct snd_kcontrol_new alc260_will_mixer[] = {
4857         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4858         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4859         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4860         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4861         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4862         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4863         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4864         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4865         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4866         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4867         { } /* end */
4868 };
4869
4870 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4871  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4872  */
4873 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4874         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4875         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4876         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4877         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4878         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4879         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4880         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4881         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4882         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4883         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4884         { } /* end */
4885 };
4886
4887 /*
4888  * initialization verbs
4889  */
4890 static struct hda_verb alc260_init_verbs[] = {
4891         /* Line In pin widget for input */
4892         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4893         /* CD pin widget for input */
4894         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4895         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4896         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4897         /* Mic2 (front panel) pin widget for input and vref at 80% */
4898         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4899         /* LINE-2 is used for line-out in rear */
4900         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4901         /* select line-out */
4902         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4903         /* LINE-OUT pin */
4904         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4905         /* enable HP */
4906         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4907         /* enable Mono */
4908         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4909         /* mute capture amp left and right */
4910         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4911         /* set connection select to line in (default select for this ADC) */
4912         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4913         /* mute capture amp left and right */
4914         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4915         /* set connection select to line in (default select for this ADC) */
4916         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4917         /* set vol=0 Line-Out mixer amp left and right */
4918         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4919         /* unmute pin widget amp left and right (no gain on this amp) */
4920         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4921         /* set vol=0 HP mixer amp left and right */
4922         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4923         /* unmute pin widget amp left and right (no gain on this amp) */
4924         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4925         /* set vol=0 Mono mixer amp left and right */
4926         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4927         /* unmute pin widget amp left and right (no gain on this amp) */
4928         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4929         /* unmute LINE-2 out pin */
4930         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4931         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4932          * Line In 2 = 0x03
4933          */
4934         /* mute analog inputs */
4935         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4936         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4937         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4938         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4939         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4940         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4941         /* mute Front out path */
4942         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4943         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4944         /* mute Headphone out path */
4945         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4946         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4947         /* mute Mono out path */
4948         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4949         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4950         { }
4951 };
4952
4953 #if 0 /* should be identical with alc260_init_verbs? */
4954 static struct hda_verb alc260_hp_init_verbs[] = {
4955         /* Headphone and output */
4956         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4957         /* mono output */
4958         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4959         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4960         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4961         /* Mic2 (front panel) pin widget for input and vref at 80% */
4962         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4963         /* Line In pin widget for input */
4964         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4965         /* Line-2 pin widget for output */
4966         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4967         /* CD pin widget for input */
4968         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4969         /* unmute amp left and right */
4970         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4971         /* set connection select to line in (default select for this ADC) */
4972         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4973         /* unmute Line-Out mixer amp left and right (volume = 0) */
4974         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4975         /* mute pin widget amp left and right (no gain on this amp) */
4976         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4977         /* unmute HP mixer amp left and right (volume = 0) */
4978         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4979         /* mute pin widget amp left and right (no gain on this amp) */
4980         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4981         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4982          * Line In 2 = 0x03
4983          */
4984         /* mute analog inputs */
4985         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4986         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4987         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4988         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4989         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4990         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4991         /* Unmute Front out path */
4992         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4993         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4994         /* Unmute Headphone out path */
4995         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4996         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4997         /* Unmute Mono out path */
4998         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4999         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5000         { }
5001 };
5002 #endif
5003
5004 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5005         /* Line out and output */
5006         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5007         /* mono output */
5008         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5009         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5010         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5011         /* Mic2 (front panel) pin widget for input and vref at 80% */
5012         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5013         /* Line In pin widget for input */
5014         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5015         /* Headphone pin widget for output */
5016         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5017         /* CD pin widget for input */
5018         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5019         /* unmute amp left and right */
5020         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5021         /* set connection select to line in (default select for this ADC) */
5022         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5023         /* unmute Line-Out mixer amp left and right (volume = 0) */
5024         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5025         /* mute pin widget amp left and right (no gain on this amp) */
5026         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5027         /* unmute HP mixer amp left and right (volume = 0) */
5028         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5029         /* mute pin widget amp left and right (no gain on this amp) */
5030         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5031         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5032          * Line In 2 = 0x03
5033          */
5034         /* mute analog inputs */
5035         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5036         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5037         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5038         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5039         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5040         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5041         /* Unmute Front out path */
5042         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5043         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5044         /* Unmute Headphone out path */
5045         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5046         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5047         /* Unmute Mono out path */
5048         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5049         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5050         { }
5051 };
5052
5053 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5054  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5055  * audio = 0x16, internal speaker = 0x10.
5056  */
5057 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5058         /* Disable all GPIOs */
5059         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5060         /* Internal speaker is connected to headphone pin */
5061         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5062         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5063         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5064         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5065         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5066         /* Ensure all other unused pins are disabled and muted. */
5067         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5068         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5069         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5070         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5071         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5072         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5073         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5074         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5075
5076         /* Disable digital (SPDIF) pins */
5077         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5078         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5079
5080         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5081          * when acting as an output.
5082          */
5083         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5084
5085         /* Start with output sum widgets muted and their output gains at min */
5086         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5087         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5088         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5089         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5090         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5091         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5092         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5093         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5094         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5095
5096         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5097         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5098         /* Unmute Line1 pin widget output buffer since it starts as an output.
5099          * If the pin mode is changed by the user the pin mode control will
5100          * take care of enabling the pin's input/output buffers as needed.
5101          * Therefore there's no need to enable the input buffer at this
5102          * stage.
5103          */
5104         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5105         /* Unmute input buffer of pin widget used for Line-in (no equiv
5106          * mixer ctrl)
5107          */
5108         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5109
5110         /* Mute capture amp left and right */
5111         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5112         /* Set ADC connection select to match default mixer setting - line
5113          * in (on mic1 pin)
5114          */
5115         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5116
5117         /* Do the same for the second ADC: mute capture input amp and
5118          * set ADC connection to line in (on mic1 pin)
5119          */
5120         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5121         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5122
5123         /* Mute all inputs to mixer widget (even unconnected ones) */
5124         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5125         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5126         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5127         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5128         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5129         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5130         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5131         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5132
5133         { }
5134 };
5135
5136 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5137  * similar laptops (adapted from Fujitsu init verbs).
5138  */
5139 static struct hda_verb alc260_acer_init_verbs[] = {
5140         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5141          * the headphone jack.  Turn this on and rely on the standard mute
5142          * methods whenever the user wants to turn these outputs off.
5143          */
5144         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5145         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5146         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5147         /* Internal speaker/Headphone jack is connected to Line-out pin */
5148         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5149         /* Internal microphone/Mic jack is connected to Mic1 pin */
5150         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5151         /* Line In jack is connected to Line1 pin */
5152         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5153         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5154         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5155         /* Ensure all other unused pins are disabled and muted. */
5156         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5157         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5158         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5159         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5160         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5161         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5162         /* Disable digital (SPDIF) pins */
5163         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5164         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5165
5166         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5167          * bus when acting as outputs.
5168          */
5169         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5170         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5171
5172         /* Start with output sum widgets muted and their output gains at min */
5173         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5174         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5175         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5176         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5177         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5178         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5179         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5180         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5181         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5182
5183         /* Unmute Line-out pin widget amp left and right
5184          * (no equiv mixer ctrl)
5185          */
5186         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5187         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5188         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5189         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5190          * inputs. If the pin mode is changed by the user the pin mode control
5191          * will take care of enabling the pin's input/output buffers as needed.
5192          * Therefore there's no need to enable the input buffer at this
5193          * stage.
5194          */
5195         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5196         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5197
5198         /* Mute capture amp left and right */
5199         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5200         /* Set ADC connection select to match default mixer setting - mic
5201          * (on mic1 pin)
5202          */
5203         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5204
5205         /* Do similar with the second ADC: mute capture input amp and
5206          * set ADC connection to mic to match ALSA's default state.
5207          */
5208         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5209         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5210
5211         /* Mute all inputs to mixer widget (even unconnected ones) */
5212         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5213         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5214         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5215         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5216         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5217         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5218         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5219         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5220
5221         { }
5222 };
5223
5224 /* Initialisation sequence for Maxdata Favorit 100XS
5225  * (adapted from Acer init verbs).
5226  */
5227 static struct hda_verb alc260_favorit100_init_verbs[] = {
5228         /* GPIO 0 enables the output jack.
5229          * Turn this on and rely on the standard mute
5230          * methods whenever the user wants to turn these outputs off.
5231          */
5232         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5233         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5234         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5235         /* Line/Mic input jack is connected to Mic1 pin */
5236         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5237         /* Ensure all other unused pins are disabled and muted. */
5238         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5239         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5240         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5241         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5242         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5243         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5244         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5245         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5246         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5247         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5248         /* Disable digital (SPDIF) pins */
5249         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5250         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5251
5252         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5253          * bus when acting as outputs.
5254          */
5255         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5256         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5257
5258         /* Start with output sum widgets muted and their output gains at min */
5259         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5260         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5261         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5262         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5263         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5264         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5265         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5266         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5267         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5268
5269         /* Unmute Line-out pin widget amp left and right
5270          * (no equiv mixer ctrl)
5271          */
5272         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5273         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5274          * inputs. If the pin mode is changed by the user the pin mode control
5275          * will take care of enabling the pin's input/output buffers as needed.
5276          * Therefore there's no need to enable the input buffer at this
5277          * stage.
5278          */
5279         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5280
5281         /* Mute capture amp left and right */
5282         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5283         /* Set ADC connection select to match default mixer setting - mic
5284          * (on mic1 pin)
5285          */
5286         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5287
5288         /* Do similar with the second ADC: mute capture input amp and
5289          * set ADC connection to mic to match ALSA's default state.
5290          */
5291         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5292         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5293
5294         /* Mute all inputs to mixer widget (even unconnected ones) */
5295         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5296         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5297         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5298         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5299         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5300         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5301         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5302         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5303
5304         { }
5305 };
5306
5307 static struct hda_verb alc260_will_verbs[] = {
5308         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5309         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5310         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5311         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5312         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5313         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5314         {}
5315 };
5316
5317 static struct hda_verb alc260_replacer_672v_verbs[] = {
5318         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5319         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5320         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5321
5322         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5323         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5324         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5325
5326         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5327         {}
5328 };
5329
5330 /* toggle speaker-output according to the hp-jack state */
5331 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5332 {
5333         unsigned int present;
5334
5335         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5336         present = snd_hda_codec_read(codec, 0x0f, 0,
5337                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5338         if (present) {
5339                 snd_hda_codec_write_cache(codec, 0x01, 0,
5340                                           AC_VERB_SET_GPIO_DATA, 1);
5341                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5342                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5343                                           PIN_HP);
5344         } else {
5345                 snd_hda_codec_write_cache(codec, 0x01, 0,
5346                                           AC_VERB_SET_GPIO_DATA, 0);
5347                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5348                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5349                                           PIN_OUT);
5350         }
5351 }
5352
5353 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5354                                        unsigned int res)
5355 {
5356         if ((res >> 26) == ALC880_HP_EVENT)
5357                 alc260_replacer_672v_automute(codec);
5358 }
5359
5360 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5361         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5362         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5363         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5364         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5365         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5366         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5367         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5368         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5369         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5370         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5371         {}
5372 };
5373
5374 /* Test configuration for debugging, modelled after the ALC880 test
5375  * configuration.
5376  */
5377 #ifdef CONFIG_SND_DEBUG
5378 static hda_nid_t alc260_test_dac_nids[1] = {
5379         0x02,
5380 };
5381 static hda_nid_t alc260_test_adc_nids[2] = {
5382         0x04, 0x05,
5383 };
5384 /* For testing the ALC260, each input MUX needs its own definition since
5385  * the signal assignments are different.  This assumes that the first ADC
5386  * is NID 0x04.
5387  */
5388 static struct hda_input_mux alc260_test_capture_sources[2] = {
5389         {
5390                 .num_items = 7,
5391                 .items = {
5392                         { "MIC1 pin", 0x0 },
5393                         { "MIC2 pin", 0x1 },
5394                         { "LINE1 pin", 0x2 },
5395                         { "LINE2 pin", 0x3 },
5396                         { "CD pin", 0x4 },
5397                         { "LINE-OUT pin", 0x5 },
5398                         { "HP-OUT pin", 0x6 },
5399                 },
5400         },
5401         {
5402                 .num_items = 8,
5403                 .items = {
5404                         { "MIC1 pin", 0x0 },
5405                         { "MIC2 pin", 0x1 },
5406                         { "LINE1 pin", 0x2 },
5407                         { "LINE2 pin", 0x3 },
5408                         { "CD pin", 0x4 },
5409                         { "Mixer", 0x5 },
5410                         { "LINE-OUT pin", 0x6 },
5411                         { "HP-OUT pin", 0x7 },
5412                 },
5413         },
5414 };
5415 static struct snd_kcontrol_new alc260_test_mixer[] = {
5416         /* Output driver widgets */
5417         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5418         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5419         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5420         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5421         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5422         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5423
5424         /* Modes for retasking pin widgets
5425          * Note: the ALC260 doesn't seem to act on requests to enable mic
5426          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5427          * mention this restriction.  At this stage it's not clear whether
5428          * this behaviour is intentional or is a hardware bug in chip
5429          * revisions available at least up until early 2006.  Therefore for
5430          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5431          * choices, but if it turns out that the lack of mic bias for these
5432          * NIDs is intentional we could change their modes from
5433          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5434          */
5435         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5436         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5437         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5438         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5439         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5440         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5441
5442         /* Loopback mixer controls */
5443         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5444         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5445         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5446         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5447         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5448         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5449         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5450         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5451         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5452         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5453         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5454         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5455         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5456         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5457
5458         /* Controls for GPIO pins, assuming they are configured as outputs */
5459         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5460         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5461         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5462         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5463
5464         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5465          * is ambigious as to which NID is which; testing on laptops which
5466          * make this output available should provide clarification.
5467          */
5468         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5469         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5470
5471         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5472          * this output to turn on an external amplifier.
5473          */
5474         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5475         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5476
5477         { } /* end */
5478 };
5479 static struct hda_verb alc260_test_init_verbs[] = {
5480         /* Enable all GPIOs as outputs with an initial value of 0 */
5481         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5482         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5483         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5484
5485         /* Enable retasking pins as output, initially without power amp */
5486         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5487         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5488         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5489         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5490         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5491         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5492
5493         /* Disable digital (SPDIF) pins initially, but users can enable
5494          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5495          * payload also sets the generation to 0, output to be in "consumer"
5496          * PCM format, copyright asserted, no pre-emphasis and no validity
5497          * control.
5498          */
5499         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5500         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5501
5502         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5503          * OUT1 sum bus when acting as an output.
5504          */
5505         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5506         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5507         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5508         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5509
5510         /* Start with output sum widgets muted and their output gains at min */
5511         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5512         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5513         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5514         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5515         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5516         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5517         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5518         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5519         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5520
5521         /* Unmute retasking pin widget output buffers since the default
5522          * state appears to be output.  As the pin mode is changed by the
5523          * user the pin mode control will take care of enabling the pin's
5524          * input/output buffers as needed.
5525          */
5526         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5527         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5528         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5529         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5530         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5531         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5532         /* Also unmute the mono-out pin widget */
5533         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5534
5535         /* Mute capture amp left and right */
5536         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5537         /* Set ADC connection select to match default mixer setting (mic1
5538          * pin)
5539          */
5540         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5541
5542         /* Do the same for the second ADC: mute capture input amp and
5543          * set ADC connection to mic1 pin
5544          */
5545         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5546         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5547
5548         /* Mute all inputs to mixer widget (even unconnected ones) */
5549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5551         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5552         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5553         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5554         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5555         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5556         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5557
5558         { }
5559 };
5560 #endif
5561
5562 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5563 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5564
5565 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5566 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5567
5568 /*
5569  * for BIOS auto-configuration
5570  */
5571
5572 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5573                                         const char *pfx, int *vol_bits)
5574 {
5575         hda_nid_t nid_vol;
5576         unsigned long vol_val, sw_val;
5577         char name[32];
5578         int err;
5579
5580         if (nid >= 0x0f && nid < 0x11) {
5581                 nid_vol = nid - 0x7;
5582                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5583                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5584         } else if (nid == 0x11) {
5585                 nid_vol = nid - 0x7;
5586                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5587                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5588         } else if (nid >= 0x12 && nid <= 0x15) {
5589                 nid_vol = 0x08;
5590                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5591                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5592         } else
5593                 return 0; /* N/A */
5594
5595         if (!(*vol_bits & (1 << nid_vol))) {
5596                 /* first control for the volume widget */
5597                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5598                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5599                 if (err < 0)
5600                         return err;
5601                 *vol_bits |= (1 << nid_vol);
5602         }
5603         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5604         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5605         if (err < 0)
5606                 return err;
5607         return 1;
5608 }
5609
5610 /* add playback controls from the parsed DAC table */
5611 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5612                                              const struct auto_pin_cfg *cfg)
5613 {
5614         hda_nid_t nid;
5615         int err;
5616         int vols = 0;
5617
5618         spec->multiout.num_dacs = 1;
5619         spec->multiout.dac_nids = spec->private_dac_nids;
5620         spec->multiout.dac_nids[0] = 0x02;
5621
5622         nid = cfg->line_out_pins[0];
5623         if (nid) {
5624                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5625                 if (err < 0)
5626                         return err;
5627         }
5628
5629         nid = cfg->speaker_pins[0];
5630         if (nid) {
5631                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5632                 if (err < 0)
5633                         return err;
5634         }
5635
5636         nid = cfg->hp_pins[0];
5637         if (nid) {
5638                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5639                                                    &vols);
5640                 if (err < 0)
5641                         return err;
5642         }
5643         return 0;
5644 }
5645
5646 /* create playback/capture controls for input pins */
5647 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5648                                                 const struct auto_pin_cfg *cfg)
5649 {
5650         struct hda_input_mux *imux = &spec->private_imux[0];
5651         int i, err, idx;
5652
5653         for (i = 0; i < AUTO_PIN_LAST; i++) {
5654                 if (cfg->input_pins[i] >= 0x12) {
5655                         idx = cfg->input_pins[i] - 0x12;
5656                         err = new_analog_input(spec, cfg->input_pins[i],
5657                                                auto_pin_cfg_labels[i], idx,
5658                                                0x07);
5659                         if (err < 0)
5660                                 return err;
5661                         imux->items[imux->num_items].label =
5662                                 auto_pin_cfg_labels[i];
5663                         imux->items[imux->num_items].index = idx;
5664                         imux->num_items++;
5665                 }
5666                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5667                         idx = cfg->input_pins[i] - 0x09;
5668                         err = new_analog_input(spec, cfg->input_pins[i],
5669                                                auto_pin_cfg_labels[i], idx,
5670                                                0x07);
5671                         if (err < 0)
5672                                 return err;
5673                         imux->items[imux->num_items].label =
5674                                 auto_pin_cfg_labels[i];
5675                         imux->items[imux->num_items].index = idx;
5676                         imux->num_items++;
5677                 }
5678         }
5679         return 0;
5680 }
5681
5682 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5683                                               hda_nid_t nid, int pin_type,
5684                                               int sel_idx)
5685 {
5686         alc_set_pin_output(codec, nid, pin_type);
5687         /* need the manual connection? */
5688         if (nid >= 0x12) {
5689                 int idx = nid - 0x12;
5690                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5691                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5692         }
5693 }
5694
5695 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5696 {
5697         struct alc_spec *spec = codec->spec;
5698         hda_nid_t nid;
5699
5700         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5701         nid = spec->autocfg.line_out_pins[0];
5702         if (nid) {
5703                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5704                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5705         }
5706
5707         nid = spec->autocfg.speaker_pins[0];
5708         if (nid)
5709                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5710
5711         nid = spec->autocfg.hp_pins[0];
5712         if (nid)
5713                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5714 }
5715
5716 #define ALC260_PIN_CD_NID               0x16
5717 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5718 {
5719         struct alc_spec *spec = codec->spec;
5720         int i;
5721
5722         for (i = 0; i < AUTO_PIN_LAST; i++) {
5723                 hda_nid_t nid = spec->autocfg.input_pins[i];
5724                 if (nid >= 0x12) {
5725                         snd_hda_codec_write(codec, nid, 0,
5726                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
5727                                             i <= AUTO_PIN_FRONT_MIC ?
5728                                             PIN_VREF80 : PIN_IN);
5729                         if (nid != ALC260_PIN_CD_NID)
5730                                 snd_hda_codec_write(codec, nid, 0,
5731                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5732                                                     AMP_OUT_MUTE);
5733                 }
5734         }
5735 }
5736
5737 /*
5738  * generic initialization of ADC, input mixers and output mixers
5739  */
5740 static struct hda_verb alc260_volume_init_verbs[] = {
5741         /*
5742          * Unmute ADC0-1 and set the default input to mic-in
5743          */
5744         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5745         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5746         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5747         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5748
5749         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5750          * mixer widget
5751          * Note: PASD motherboards uses the Line In 2 as the input for
5752          * front panel mic (mic 2)
5753          */
5754         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5755         /* mute analog inputs */
5756         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5757         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5758         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5759         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5760         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5761
5762         /*
5763          * Set up output mixers (0x08 - 0x0a)
5764          */
5765         /* set vol=0 to output mixers */
5766         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5767         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5768         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5769         /* set up input amps for analog loopback */
5770         /* Amp Indices: DAC = 0, mixer = 1 */
5771         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5772         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5773         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5774         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5775         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5776         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5777
5778         { }
5779 };
5780
5781 static int alc260_parse_auto_config(struct hda_codec *codec)
5782 {
5783         struct alc_spec *spec = codec->spec;
5784         int err;
5785         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5786
5787         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5788                                            alc260_ignore);
5789         if (err < 0)
5790                 return err;
5791         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5792         if (err < 0)
5793                 return err;
5794         if (!spec->kctls.list)
5795                 return 0; /* can't find valid BIOS pin config */
5796         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5797         if (err < 0)
5798                 return err;
5799
5800         spec->multiout.max_channels = 2;
5801
5802         if (spec->autocfg.dig_outs)
5803                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5804         if (spec->kctls.list)
5805                 add_mixer(spec, spec->kctls.list);
5806
5807         add_verb(spec, alc260_volume_init_verbs);
5808
5809         spec->num_mux_defs = 1;
5810         spec->input_mux = &spec->private_imux[0];
5811
5812         store_pin_configs(codec);
5813         return 1;
5814 }
5815
5816 /* additional initialization for auto-configuration model */
5817 static void alc260_auto_init(struct hda_codec *codec)
5818 {
5819         struct alc_spec *spec = codec->spec;
5820         alc260_auto_init_multi_out(codec);
5821         alc260_auto_init_analog_input(codec);
5822         if (spec->unsol_event)
5823                 alc_inithook(codec);
5824 }
5825
5826 #ifdef CONFIG_SND_HDA_POWER_SAVE
5827 static struct hda_amp_list alc260_loopbacks[] = {
5828         { 0x07, HDA_INPUT, 0 },
5829         { 0x07, HDA_INPUT, 1 },
5830         { 0x07, HDA_INPUT, 2 },
5831         { 0x07, HDA_INPUT, 3 },
5832         { 0x07, HDA_INPUT, 4 },
5833         { } /* end */
5834 };
5835 #endif
5836
5837 /*
5838  * ALC260 configurations
5839  */
5840 static const char *alc260_models[ALC260_MODEL_LAST] = {
5841         [ALC260_BASIC]          = "basic",
5842         [ALC260_HP]             = "hp",
5843         [ALC260_HP_3013]        = "hp-3013",
5844         [ALC260_HP_DC7600]      = "hp-dc7600",
5845         [ALC260_FUJITSU_S702X]  = "fujitsu",
5846         [ALC260_ACER]           = "acer",
5847         [ALC260_WILL]           = "will",
5848         [ALC260_REPLACER_672V]  = "replacer",
5849         [ALC260_FAVORIT100]     = "favorit100",
5850 #ifdef CONFIG_SND_DEBUG
5851         [ALC260_TEST]           = "test",
5852 #endif
5853         [ALC260_AUTO]           = "auto",
5854 };
5855
5856 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5857         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5858         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5859         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5860         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5861         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5862         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5863         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5864         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5865         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5866         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5867         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5868         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5869         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5870         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5871         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5872         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5873         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5874         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5875         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5876         {}
5877 };
5878
5879 static struct alc_config_preset alc260_presets[] = {
5880         [ALC260_BASIC] = {
5881                 .mixers = { alc260_base_output_mixer,
5882                             alc260_input_mixer },
5883                 .init_verbs = { alc260_init_verbs },
5884                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5885                 .dac_nids = alc260_dac_nids,
5886                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5887                 .adc_nids = alc260_adc_nids,
5888                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5889                 .channel_mode = alc260_modes,
5890                 .input_mux = &alc260_capture_source,
5891         },
5892         [ALC260_HP] = {
5893                 .mixers = { alc260_hp_output_mixer,
5894                             alc260_input_mixer },
5895                 .init_verbs = { alc260_init_verbs,
5896                                 alc260_hp_unsol_verbs },
5897                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5898                 .dac_nids = alc260_dac_nids,
5899                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5900                 .adc_nids = alc260_adc_nids_alt,
5901                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5902                 .channel_mode = alc260_modes,
5903                 .input_mux = &alc260_capture_source,
5904                 .unsol_event = alc260_hp_unsol_event,
5905                 .init_hook = alc260_hp_automute,
5906         },
5907         [ALC260_HP_DC7600] = {
5908                 .mixers = { alc260_hp_dc7600_mixer,
5909                             alc260_input_mixer },
5910                 .init_verbs = { alc260_init_verbs,
5911                                 alc260_hp_dc7600_verbs },
5912                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5913                 .dac_nids = alc260_dac_nids,
5914                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5915                 .adc_nids = alc260_adc_nids_alt,
5916                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5917                 .channel_mode = alc260_modes,
5918                 .input_mux = &alc260_capture_source,
5919                 .unsol_event = alc260_hp_3012_unsol_event,
5920                 .init_hook = alc260_hp_3012_automute,
5921         },
5922         [ALC260_HP_3013] = {
5923                 .mixers = { alc260_hp_3013_mixer,
5924                             alc260_input_mixer },
5925                 .init_verbs = { alc260_hp_3013_init_verbs,
5926                                 alc260_hp_3013_unsol_verbs },
5927                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5928                 .dac_nids = alc260_dac_nids,
5929                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5930                 .adc_nids = alc260_adc_nids_alt,
5931                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5932                 .channel_mode = alc260_modes,
5933                 .input_mux = &alc260_capture_source,
5934                 .unsol_event = alc260_hp_3013_unsol_event,
5935                 .init_hook = alc260_hp_3013_automute,
5936         },
5937         [ALC260_FUJITSU_S702X] = {
5938                 .mixers = { alc260_fujitsu_mixer },
5939                 .init_verbs = { alc260_fujitsu_init_verbs },
5940                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5941                 .dac_nids = alc260_dac_nids,
5942                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5943                 .adc_nids = alc260_dual_adc_nids,
5944                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5945                 .channel_mode = alc260_modes,
5946                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5947                 .input_mux = alc260_fujitsu_capture_sources,
5948         },
5949         [ALC260_ACER] = {
5950                 .mixers = { alc260_acer_mixer },
5951                 .init_verbs = { alc260_acer_init_verbs },
5952                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5953                 .dac_nids = alc260_dac_nids,
5954                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5955                 .adc_nids = alc260_dual_adc_nids,
5956                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5957                 .channel_mode = alc260_modes,
5958                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5959                 .input_mux = alc260_acer_capture_sources,
5960         },
5961         [ALC260_FAVORIT100] = {
5962                 .mixers = { alc260_favorit100_mixer },
5963                 .init_verbs = { alc260_favorit100_init_verbs },
5964                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5965                 .dac_nids = alc260_dac_nids,
5966                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5967                 .adc_nids = alc260_dual_adc_nids,
5968                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5969                 .channel_mode = alc260_modes,
5970                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
5971                 .input_mux = alc260_favorit100_capture_sources,
5972         },
5973         [ALC260_WILL] = {
5974                 .mixers = { alc260_will_mixer },
5975                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5976                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5977                 .dac_nids = alc260_dac_nids,
5978                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5979                 .adc_nids = alc260_adc_nids,
5980                 .dig_out_nid = ALC260_DIGOUT_NID,
5981                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5982                 .channel_mode = alc260_modes,
5983                 .input_mux = &alc260_capture_source,
5984         },
5985         [ALC260_REPLACER_672V] = {
5986                 .mixers = { alc260_replacer_672v_mixer },
5987                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5988                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5989                 .dac_nids = alc260_dac_nids,
5990                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5991                 .adc_nids = alc260_adc_nids,
5992                 .dig_out_nid = ALC260_DIGOUT_NID,
5993                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5994                 .channel_mode = alc260_modes,
5995                 .input_mux = &alc260_capture_source,
5996                 .unsol_event = alc260_replacer_672v_unsol_event,
5997                 .init_hook = alc260_replacer_672v_automute,
5998         },
5999 #ifdef CONFIG_SND_DEBUG
6000         [ALC260_TEST] = {
6001                 .mixers = { alc260_test_mixer },
6002                 .init_verbs = { alc260_test_init_verbs },
6003                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6004                 .dac_nids = alc260_test_dac_nids,
6005                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6006                 .adc_nids = alc260_test_adc_nids,
6007                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6008                 .channel_mode = alc260_modes,
6009                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6010                 .input_mux = alc260_test_capture_sources,
6011         },
6012 #endif
6013 };
6014
6015 static int patch_alc260(struct hda_codec *codec)
6016 {
6017         struct alc_spec *spec;
6018         int err, board_config;
6019
6020         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6021         if (spec == NULL)
6022                 return -ENOMEM;
6023
6024         codec->spec = spec;
6025
6026         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6027                                                   alc260_models,
6028                                                   alc260_cfg_tbl);
6029         if (board_config < 0) {
6030                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
6031                            "trying auto-probe from BIOS...\n");
6032                 board_config = ALC260_AUTO;
6033         }
6034
6035         if (board_config == ALC260_AUTO) {
6036                 /* automatic parse from the BIOS config */
6037                 err = alc260_parse_auto_config(codec);
6038                 if (err < 0) {
6039                         alc_free(codec);
6040                         return err;
6041                 } else if (!err) {
6042                         printk(KERN_INFO
6043                                "hda_codec: Cannot set up configuration "
6044                                "from BIOS.  Using base mode...\n");
6045                         board_config = ALC260_BASIC;
6046                 }
6047         }
6048
6049         err = snd_hda_attach_beep_device(codec, 0x1);
6050         if (err < 0) {
6051                 alc_free(codec);
6052                 return err;
6053         }
6054
6055         if (board_config != ALC260_AUTO)
6056                 setup_preset(spec, &alc260_presets[board_config]);
6057
6058         spec->stream_name_analog = "ALC260 Analog";
6059         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6060         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6061
6062         spec->stream_name_digital = "ALC260 Digital";
6063         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6064         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6065
6066         if (!spec->adc_nids && spec->input_mux) {
6067                 /* check whether NID 0x04 is valid */
6068                 unsigned int wcap = get_wcaps(codec, 0x04);
6069                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6070                 /* get type */
6071                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6072                         spec->adc_nids = alc260_adc_nids_alt;
6073                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6074                 } else {
6075                         spec->adc_nids = alc260_adc_nids;
6076                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6077                 }
6078         }
6079         set_capture_mixer(spec);
6080         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6081
6082         spec->vmaster_nid = 0x08;
6083
6084         codec->patch_ops = alc_patch_ops;
6085         if (board_config == ALC260_AUTO)
6086                 spec->init_hook = alc260_auto_init;
6087 #ifdef CONFIG_SND_HDA_POWER_SAVE
6088         if (!spec->loopback.amplist)
6089                 spec->loopback.amplist = alc260_loopbacks;
6090 #endif
6091         codec->proc_widget_hook = print_realtek_coef;
6092
6093         return 0;
6094 }
6095
6096
6097 /*
6098  * ALC882 support
6099  *
6100  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6101  * configuration.  Each pin widget can choose any input DACs and a mixer.
6102  * Each ADC is connected from a mixer of all inputs.  This makes possible
6103  * 6-channel independent captures.
6104  *
6105  * In addition, an independent DAC for the multi-playback (not used in this
6106  * driver yet).
6107  */
6108 #define ALC882_DIGOUT_NID       0x06
6109 #define ALC882_DIGIN_NID        0x0a
6110
6111 static struct hda_channel_mode alc882_ch_modes[1] = {
6112         { 8, NULL }
6113 };
6114
6115 static hda_nid_t alc882_dac_nids[4] = {
6116         /* front, rear, clfe, rear_surr */
6117         0x02, 0x03, 0x04, 0x05
6118 };
6119
6120 /* identical with ALC880 */
6121 #define alc882_adc_nids         alc880_adc_nids
6122 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6123
6124 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6125 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6126
6127 /* input MUX */
6128 /* FIXME: should be a matrix-type input source selection */
6129
6130 static struct hda_input_mux alc882_capture_source = {
6131         .num_items = 4,
6132         .items = {
6133                 { "Mic", 0x0 },
6134                 { "Front Mic", 0x1 },
6135                 { "Line", 0x2 },
6136                 { "CD", 0x4 },
6137         },
6138 };
6139 /*
6140  * 2ch mode
6141  */
6142 static struct hda_verb alc882_3ST_ch2_init[] = {
6143         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6144         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6145         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6146         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6147         { } /* end */
6148 };
6149
6150 /*
6151  * 6ch mode
6152  */
6153 static struct hda_verb alc882_3ST_ch6_init[] = {
6154         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6155         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6156         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6157         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6158         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6159         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6160         { } /* end */
6161 };
6162
6163 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6164         { 2, alc882_3ST_ch2_init },
6165         { 6, alc882_3ST_ch6_init },
6166 };
6167
6168 /*
6169  * 6ch mode
6170  */
6171 static struct hda_verb alc882_sixstack_ch6_init[] = {
6172         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6173         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6174         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6175         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6176         { } /* end */
6177 };
6178
6179 /*
6180  * 8ch mode
6181  */
6182 static struct hda_verb alc882_sixstack_ch8_init[] = {
6183         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6184         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6185         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6186         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6187         { } /* end */
6188 };
6189
6190 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6191         { 6, alc882_sixstack_ch6_init },
6192         { 8, alc882_sixstack_ch8_init },
6193 };
6194
6195 /*
6196  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6197  */
6198
6199 /*
6200  * 2ch mode
6201  */
6202 static struct hda_verb alc885_mbp_ch2_init[] = {
6203         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6204         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6205         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6206         { } /* end */
6207 };
6208
6209 /*
6210  * 6ch mode
6211  */
6212 static struct hda_verb alc885_mbp_ch6_init[] = {
6213         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6214         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6215         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6216         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6217         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6218         { } /* end */
6219 };
6220
6221 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6222         { 2, alc885_mbp_ch2_init },
6223         { 6, alc885_mbp_ch6_init },
6224 };
6225
6226
6227 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6228  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6229  */
6230 static struct snd_kcontrol_new alc882_base_mixer[] = {
6231         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6232         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6233         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6234         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6235         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6236         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6237         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6238         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6239         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6240         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6241         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6242         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6243         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6244         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6245         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6246         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6247         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6248         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6249         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6250         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6251         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6252         { } /* end */
6253 };
6254
6255 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6256         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6257         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6258         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6259         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6260         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6261         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6262         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6263         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6264         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6265         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6266         { } /* end */
6267 };
6268 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6269         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6270         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6271         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6272         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6273         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6274         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6275         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6276         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6277         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6278         { } /* end */
6279 };
6280
6281 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6282         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6283         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6284         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6285         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6286         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6287         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6288         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6290         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6291         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6292         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6293         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6294         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6295         { } /* end */
6296 };
6297
6298 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6299  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6300  */
6301 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6302         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6303         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6304         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6305         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6306         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6307         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6308         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6309         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6310         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6311         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6312         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6313         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6314         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6315         { } /* end */
6316 };
6317
6318 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6319         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6320         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6321         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6322         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6323         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6324         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6325         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6326         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6327         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6328         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6329         { } /* end */
6330 };
6331
6332 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6333         {
6334                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6335                 .name = "Channel Mode",
6336                 .info = alc_ch_mode_info,
6337                 .get = alc_ch_mode_get,
6338                 .put = alc_ch_mode_put,
6339         },
6340         { } /* end */
6341 };
6342
6343 static struct hda_verb alc882_init_verbs[] = {
6344         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6347         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6348         /* Rear mixer */
6349         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6350         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6351         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6352         /* CLFE mixer */
6353         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6354         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6355         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6356         /* Side mixer */
6357         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6358         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6359         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6360
6361         /* Front Pin: output 0 (0x0c) */
6362         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6363         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6364         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6365         /* Rear Pin: output 1 (0x0d) */
6366         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6367         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6368         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6369         /* CLFE Pin: output 2 (0x0e) */
6370         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6371         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6372         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6373         /* Side Pin: output 3 (0x0f) */
6374         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6375         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6376         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6377         /* Mic (rear) pin: input vref at 80% */
6378         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6379         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6380         /* Front Mic pin: input vref at 80% */
6381         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6382         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6383         /* Line In pin: input */
6384         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6385         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6386         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6387         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6388         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6389         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6390         /* CD pin widget for input */
6391         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6392
6393         /* FIXME: use matrix-type input source selection */
6394         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6395         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6396         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6397         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6398         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6399         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6400         /* Input mixer2 */
6401         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6402         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6403         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6404         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6405         /* Input mixer3 */
6406         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6407         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6408         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6409         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6410         /* ADC1: mute amp left and right */
6411         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6412         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6413         /* ADC2: mute amp left and right */
6414         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6415         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6416         /* ADC3: mute amp left and right */
6417         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6418         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6419
6420         { }
6421 };
6422
6423 static struct hda_verb alc882_eapd_verbs[] = {
6424         /* change to EAPD mode */
6425         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6426         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6427         { }
6428 };
6429
6430 /* Mac Pro test */
6431 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6432         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6433         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6434         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6435         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6436         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6437         /* FIXME: this looks suspicious...
6438         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6439         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6440         */
6441         { } /* end */
6442 };
6443
6444 static struct hda_verb alc882_macpro_init_verbs[] = {
6445         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6446         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6447         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6448         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6449         /* Front Pin: output 0 (0x0c) */
6450         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6451         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6452         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6453         /* Front Mic pin: input vref at 80% */
6454         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6455         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6456         /* Speaker:  output */
6457         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6458         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6459         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6460         /* Headphone output (output 0 - 0x0c) */
6461         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6462         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6463         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6464
6465         /* FIXME: use matrix-type input source selection */
6466         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6467         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6468         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6469         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6470         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6471         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6472         /* Input mixer2 */
6473         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6474         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6475         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6476         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6477         /* Input mixer3 */
6478         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6479         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6480         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6482         /* ADC1: mute amp left and right */
6483         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6484         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6485         /* ADC2: mute amp left and right */
6486         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6487         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6488         /* ADC3: mute amp left and right */
6489         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6490         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6491
6492         { }
6493 };
6494
6495 /* Macbook Pro rev3 */
6496 static struct hda_verb alc885_mbp3_init_verbs[] = {
6497         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6498         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6499         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6500         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6501         /* Rear mixer */
6502         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6503         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6504         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6505         /* Front Pin: output 0 (0x0c) */
6506         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6507         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6508         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6509         /* HP Pin: output 0 (0x0d) */
6510         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6511         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6512         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6513         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6514         /* Mic (rear) pin: input vref at 80% */
6515         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6516         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6517         /* Front Mic pin: input vref at 80% */
6518         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6519         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6520         /* Line In pin: use output 1 when in LineOut mode */
6521         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6522         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6523         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6524
6525         /* FIXME: use matrix-type input source selection */
6526         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6527         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6528         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6529         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6530         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6531         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6532         /* Input mixer2 */
6533         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6534         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6535         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6536         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6537         /* Input mixer3 */
6538         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6539         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6540         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6541         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6542         /* ADC1: mute amp left and right */
6543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6544         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6545         /* ADC2: mute amp left and right */
6546         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6547         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6548         /* ADC3: mute amp left and right */
6549         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6550         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6551
6552         { }
6553 };
6554
6555 /* iMac 24 mixer. */
6556 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6557         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6558         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6559         { } /* end */
6560 };
6561
6562 /* iMac 24 init verbs. */
6563 static struct hda_verb alc885_imac24_init_verbs[] = {
6564         /* Internal speakers: output 0 (0x0c) */
6565         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6566         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6567         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6568         /* Internal speakers: output 0 (0x0c) */
6569         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6570         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6571         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6572         /* Headphone: output 0 (0x0c) */
6573         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6574         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6575         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6576         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6577         /* Front Mic: input vref at 80% */
6578         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6579         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6580         { }
6581 };
6582
6583 /* Toggle speaker-output according to the hp-jack state */
6584 static void alc885_imac24_automute(struct hda_codec *codec)
6585 {
6586         unsigned int present;
6587
6588         present = snd_hda_codec_read(codec, 0x14, 0,
6589                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6590         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6591                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6592         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6593                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6594 }
6595
6596 /* Processes unsolicited events. */
6597 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6598                                       unsigned int res)
6599 {
6600         /* Headphone insertion or removal. */
6601         if ((res >> 26) == ALC880_HP_EVENT)
6602                 alc885_imac24_automute(codec);
6603 }
6604
6605 static void alc885_mbp3_automute(struct hda_codec *codec)
6606 {
6607         unsigned int present;
6608
6609         present = snd_hda_codec_read(codec, 0x15, 0,
6610                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6611         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6612                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6613         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6614                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6615
6616 }
6617 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6618                                     unsigned int res)
6619 {
6620         /* Headphone insertion or removal. */
6621         if ((res >> 26) == ALC880_HP_EVENT)
6622                 alc885_mbp3_automute(codec);
6623 }
6624
6625
6626 static struct hda_verb alc882_targa_verbs[] = {
6627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6628         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6629
6630         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6631         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6632
6633         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6634         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6635         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6636
6637         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6638         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6639         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6640         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6641         { } /* end */
6642 };
6643
6644 /* toggle speaker-output according to the hp-jack state */
6645 static void alc882_targa_automute(struct hda_codec *codec)
6646 {
6647         unsigned int present;
6648
6649         present = snd_hda_codec_read(codec, 0x14, 0,
6650                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6651         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6652                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6653         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6654                                   present ? 1 : 3);
6655 }
6656
6657 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6658 {
6659         /* Looks like the unsol event is incompatible with the standard
6660          * definition.  4bit tag is placed at 26 bit!
6661          */
6662         if (((res >> 26) == ALC880_HP_EVENT)) {
6663                 alc882_targa_automute(codec);
6664         }
6665 }
6666
6667 static struct hda_verb alc882_asus_a7j_verbs[] = {
6668         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6669         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6670
6671         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6672         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6673         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6674
6675         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6676         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6677         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6678
6679         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6680         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6681         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6682         { } /* end */
6683 };
6684
6685 static struct hda_verb alc882_asus_a7m_verbs[] = {
6686         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6687         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6688
6689         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6690         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6691         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6692
6693         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6694         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6695         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6696
6697         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6698         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6699         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6700         { } /* end */
6701 };
6702
6703 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6704 {
6705         unsigned int gpiostate, gpiomask, gpiodir;
6706
6707         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6708                                        AC_VERB_GET_GPIO_DATA, 0);
6709
6710         if (!muted)
6711                 gpiostate |= (1 << pin);
6712         else
6713                 gpiostate &= ~(1 << pin);
6714
6715         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6716                                       AC_VERB_GET_GPIO_MASK, 0);
6717         gpiomask |= (1 << pin);
6718
6719         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6720                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6721         gpiodir |= (1 << pin);
6722
6723
6724         snd_hda_codec_write(codec, codec->afg, 0,
6725                             AC_VERB_SET_GPIO_MASK, gpiomask);
6726         snd_hda_codec_write(codec, codec->afg, 0,
6727                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6728
6729         msleep(1);
6730
6731         snd_hda_codec_write(codec, codec->afg, 0,
6732                             AC_VERB_SET_GPIO_DATA, gpiostate);
6733 }
6734
6735 /* set up GPIO at initialization */
6736 static void alc885_macpro_init_hook(struct hda_codec *codec)
6737 {
6738         alc882_gpio_mute(codec, 0, 0);
6739         alc882_gpio_mute(codec, 1, 0);
6740 }
6741
6742 /* set up GPIO and update auto-muting at initialization */
6743 static void alc885_imac24_init_hook(struct hda_codec *codec)
6744 {
6745         alc885_macpro_init_hook(codec);
6746         alc885_imac24_automute(codec);
6747 }
6748
6749 /*
6750  * generic initialization of ADC, input mixers and output mixers
6751  */
6752 static struct hda_verb alc882_auto_init_verbs[] = {
6753         /*
6754          * Unmute ADC0-2 and set the default input to mic-in
6755          */
6756         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6757         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6758         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6759         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6760         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6761         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6762
6763         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6764          * mixer widget
6765          * Note: PASD motherboards uses the Line In 2 as the input for
6766          * front panel mic (mic 2)
6767          */
6768         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6769         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6770         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6771         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6772         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6773         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6774
6775         /*
6776          * Set up output mixers (0x0c - 0x0f)
6777          */
6778         /* set vol=0 to output mixers */
6779         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6780         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6781         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6782         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6783         /* set up input amps for analog loopback */
6784         /* Amp Indices: DAC = 0, mixer = 1 */
6785         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6786         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6787         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6788         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6789         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6790         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6791         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6792         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6793         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6794         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6795
6796         /* FIXME: use matrix-type input source selection */
6797         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6798         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6799         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6800         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6801         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6802         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6803         /* Input mixer2 */
6804         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6805         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6806         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6807         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6808         /* Input mixer3 */
6809         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6810         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6811         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6812         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6813
6814         { }
6815 };
6816
6817 #ifdef CONFIG_SND_HDA_POWER_SAVE
6818 #define alc882_loopbacks        alc880_loopbacks
6819 #endif
6820
6821 /* pcm configuration: identiacal with ALC880 */
6822 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6823 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6824 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6825 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6826
6827 /*
6828  * configuration and preset
6829  */
6830 static const char *alc882_models[ALC882_MODEL_LAST] = {
6831         [ALC882_3ST_DIG]        = "3stack-dig",
6832         [ALC882_6ST_DIG]        = "6stack-dig",
6833         [ALC882_ARIMA]          = "arima",
6834         [ALC882_W2JC]           = "w2jc",
6835         [ALC882_TARGA]          = "targa",
6836         [ALC882_ASUS_A7J]       = "asus-a7j",
6837         [ALC882_ASUS_A7M]       = "asus-a7m",
6838         [ALC885_MACPRO]         = "macpro",
6839         [ALC885_MBP3]           = "mbp3",
6840         [ALC885_IMAC24]         = "imac24",
6841         [ALC882_AUTO]           = "auto",
6842 };
6843
6844 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6845         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6846         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6847         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6848         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6849         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6850         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6851         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6852         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6853         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6854         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6855         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6856         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6857         {}
6858 };
6859
6860 static struct alc_config_preset alc882_presets[] = {
6861         [ALC882_3ST_DIG] = {
6862                 .mixers = { alc882_base_mixer },
6863                 .init_verbs = { alc882_init_verbs },
6864                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6865                 .dac_nids = alc882_dac_nids,
6866                 .dig_out_nid = ALC882_DIGOUT_NID,
6867                 .dig_in_nid = ALC882_DIGIN_NID,
6868                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6869                 .channel_mode = alc882_ch_modes,
6870                 .need_dac_fix = 1,
6871                 .input_mux = &alc882_capture_source,
6872         },
6873         [ALC882_6ST_DIG] = {
6874                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6875                 .init_verbs = { alc882_init_verbs },
6876                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6877                 .dac_nids = alc882_dac_nids,
6878                 .dig_out_nid = ALC882_DIGOUT_NID,
6879                 .dig_in_nid = ALC882_DIGIN_NID,
6880                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6881                 .channel_mode = alc882_sixstack_modes,
6882                 .input_mux = &alc882_capture_source,
6883         },
6884         [ALC882_ARIMA] = {
6885                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6886                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6887                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6888                 .dac_nids = alc882_dac_nids,
6889                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6890                 .channel_mode = alc882_sixstack_modes,
6891                 .input_mux = &alc882_capture_source,
6892         },
6893         [ALC882_W2JC] = {
6894                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6895                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6896                                 alc880_gpio1_init_verbs },
6897                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6898                 .dac_nids = alc882_dac_nids,
6899                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6900                 .channel_mode = alc880_threestack_modes,
6901                 .need_dac_fix = 1,
6902                 .input_mux = &alc882_capture_source,
6903                 .dig_out_nid = ALC882_DIGOUT_NID,
6904         },
6905         [ALC885_MBP3] = {
6906                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6907                 .init_verbs = { alc885_mbp3_init_verbs,
6908                                 alc880_gpio1_init_verbs },
6909                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6910                 .dac_nids = alc882_dac_nids,
6911                 .channel_mode = alc885_mbp_6ch_modes,
6912                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6913                 .input_mux = &alc882_capture_source,
6914                 .dig_out_nid = ALC882_DIGOUT_NID,
6915                 .dig_in_nid = ALC882_DIGIN_NID,
6916                 .unsol_event = alc885_mbp3_unsol_event,
6917                 .init_hook = alc885_mbp3_automute,
6918         },
6919         [ALC885_MACPRO] = {
6920                 .mixers = { alc882_macpro_mixer },
6921                 .init_verbs = { alc882_macpro_init_verbs },
6922                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6923                 .dac_nids = alc882_dac_nids,
6924                 .dig_out_nid = ALC882_DIGOUT_NID,
6925                 .dig_in_nid = ALC882_DIGIN_NID,
6926                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6927                 .channel_mode = alc882_ch_modes,
6928                 .input_mux = &alc882_capture_source,
6929                 .init_hook = alc885_macpro_init_hook,
6930         },
6931         [ALC885_IMAC24] = {
6932                 .mixers = { alc885_imac24_mixer },
6933                 .init_verbs = { alc885_imac24_init_verbs },
6934                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6935                 .dac_nids = alc882_dac_nids,
6936                 .dig_out_nid = ALC882_DIGOUT_NID,
6937                 .dig_in_nid = ALC882_DIGIN_NID,
6938                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6939                 .channel_mode = alc882_ch_modes,
6940                 .input_mux = &alc882_capture_source,
6941                 .unsol_event = alc885_imac24_unsol_event,
6942                 .init_hook = alc885_imac24_init_hook,
6943         },
6944         [ALC882_TARGA] = {
6945                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
6946                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6947                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6948                 .dac_nids = alc882_dac_nids,
6949                 .dig_out_nid = ALC882_DIGOUT_NID,
6950                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6951                 .adc_nids = alc882_adc_nids,
6952                 .capsrc_nids = alc882_capsrc_nids,
6953                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6954                 .channel_mode = alc882_3ST_6ch_modes,
6955                 .need_dac_fix = 1,
6956                 .input_mux = &alc882_capture_source,
6957                 .unsol_event = alc882_targa_unsol_event,
6958                 .init_hook = alc882_targa_automute,
6959         },
6960         [ALC882_ASUS_A7J] = {
6961                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
6962                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6963                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6964                 .dac_nids = alc882_dac_nids,
6965                 .dig_out_nid = ALC882_DIGOUT_NID,
6966                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6967                 .adc_nids = alc882_adc_nids,
6968                 .capsrc_nids = alc882_capsrc_nids,
6969                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6970                 .channel_mode = alc882_3ST_6ch_modes,
6971                 .need_dac_fix = 1,
6972                 .input_mux = &alc882_capture_source,
6973         },
6974         [ALC882_ASUS_A7M] = {
6975                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6976                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6977                                 alc880_gpio1_init_verbs,
6978                                 alc882_asus_a7m_verbs },
6979                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6980                 .dac_nids = alc882_dac_nids,
6981                 .dig_out_nid = ALC882_DIGOUT_NID,
6982                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6983                 .channel_mode = alc880_threestack_modes,
6984                 .need_dac_fix = 1,
6985                 .input_mux = &alc882_capture_source,
6986         },
6987 };
6988
6989
6990 /*
6991  * Pin config fixes
6992  */
6993 enum {
6994         PINFIX_ABIT_AW9D_MAX
6995 };
6996
6997 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6998         { 0x15, 0x01080104 }, /* side */
6999         { 0x16, 0x01011012 }, /* rear */
7000         { 0x17, 0x01016011 }, /* clfe */
7001         { }
7002 };
7003
7004 static const struct alc_pincfg *alc882_pin_fixes[] = {
7005         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
7006 };
7007
7008 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
7009         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
7010         {}
7011 };
7012
7013 /*
7014  * BIOS auto configuration
7015  */
7016 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
7017                                               hda_nid_t nid, int pin_type,
7018                                               int dac_idx)
7019 {
7020         /* set as output */
7021         struct alc_spec *spec = codec->spec;
7022         int idx;
7023
7024         alc_set_pin_output(codec, nid, pin_type);
7025         if (spec->multiout.dac_nids[dac_idx] == 0x25)
7026                 idx = 4;
7027         else
7028                 idx = spec->multiout.dac_nids[dac_idx] - 2;
7029         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
7030
7031 }
7032
7033 static void alc882_auto_init_multi_out(struct hda_codec *codec)
7034 {
7035         struct alc_spec *spec = codec->spec;
7036         int i;
7037
7038         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
7039         for (i = 0; i <= HDA_SIDE; i++) {
7040                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
7041                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7042                 if (nid)
7043                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
7044                                                           i);
7045         }
7046 }
7047
7048 static void alc882_auto_init_hp_out(struct hda_codec *codec)
7049 {
7050         struct alc_spec *spec = codec->spec;
7051         hda_nid_t pin;
7052
7053         pin = spec->autocfg.hp_pins[0];
7054         if (pin) /* connect to front */
7055                 /* use dac 0 */
7056                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7057         pin = spec->autocfg.speaker_pins[0];
7058         if (pin)
7059                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7060 }
7061
7062 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
7063 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
7064
7065 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7066 {
7067         struct alc_spec *spec = codec->spec;
7068         int i;
7069
7070         for (i = 0; i < AUTO_PIN_LAST; i++) {
7071                 hda_nid_t nid = spec->autocfg.input_pins[i];
7072                 unsigned int vref;
7073                 if (!nid)
7074                         continue;
7075                 vref = PIN_IN;
7076                 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
7077                         unsigned int pincap;
7078                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
7079                         if ((pincap >> AC_PINCAP_VREF_SHIFT) &
7080                             AC_PINCAP_VREF_80)
7081                                 vref = PIN_VREF80;
7082                 }
7083                 snd_hda_codec_write(codec, nid, 0,
7084                                     AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
7085                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7086                         snd_hda_codec_write(codec, nid, 0,
7087                                             AC_VERB_SET_AMP_GAIN_MUTE,
7088                                             AMP_OUT_MUTE);
7089         }
7090 }
7091
7092 static void alc882_auto_init_input_src(struct hda_codec *codec)
7093 {
7094         struct alc_spec *spec = codec->spec;
7095         int c;
7096
7097         for (c = 0; c < spec->num_adc_nids; c++) {
7098                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7099                 hda_nid_t nid = spec->capsrc_nids[c];
7100                 unsigned int mux_idx;
7101                 const struct hda_input_mux *imux;
7102                 int conns, mute, idx, item;
7103
7104                 conns = snd_hda_get_connections(codec, nid, conn_list,
7105                                                 ARRAY_SIZE(conn_list));
7106                 if (conns < 0)
7107                         continue;
7108                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
7109                 imux = &spec->input_mux[mux_idx];
7110                 for (idx = 0; idx < conns; idx++) {
7111                         /* if the current connection is the selected one,
7112                          * unmute it as default - otherwise mute it
7113                          */
7114                         mute = AMP_IN_MUTE(idx);
7115                         for (item = 0; item < imux->num_items; item++) {
7116                                 if (imux->items[item].index == idx) {
7117                                         if (spec->cur_mux[c] == item)
7118                                                 mute = AMP_IN_UNMUTE(idx);
7119                                         break;
7120                                 }
7121                         }
7122                         /* check if we have a selector or mixer
7123                          * we could check for the widget type instead, but
7124                          * just check for Amp-In presence (in case of mixer
7125                          * without amp-in there is something wrong, this
7126                          * function shouldn't be used or capsrc nid is wrong)
7127                          */
7128                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7129                                 snd_hda_codec_write(codec, nid, 0,
7130                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7131                                                     mute);
7132                         else if (mute != AMP_IN_MUTE(idx))
7133                                 snd_hda_codec_write(codec, nid, 0,
7134                                                     AC_VERB_SET_CONNECT_SEL,
7135                                                     idx);
7136                 }
7137         }
7138 }
7139
7140 /* add mic boosts if needed */
7141 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7142 {
7143         struct alc_spec *spec = codec->spec;
7144         int err;
7145         hda_nid_t nid;
7146
7147         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7148         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7149                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7150                                   "Mic Boost",
7151                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7152                 if (err < 0)
7153                         return err;
7154         }
7155         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7156         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7157                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7158                                   "Front Mic Boost",
7159                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7160                 if (err < 0)
7161                         return err;
7162         }
7163         return 0;
7164 }
7165
7166 /* almost identical with ALC880 parser... */
7167 static int alc882_parse_auto_config(struct hda_codec *codec)
7168 {
7169         struct alc_spec *spec = codec->spec;
7170         int err = alc880_parse_auto_config(codec);
7171
7172         if (err < 0)
7173                 return err;
7174         else if (!err)
7175                 return 0; /* no config found */
7176
7177         err = alc_auto_add_mic_boost(codec);
7178         if (err < 0)
7179                 return err;
7180
7181         /* hack - override the init verbs */
7182         spec->init_verbs[0] = alc882_auto_init_verbs;
7183
7184         return 1; /* config found */
7185 }
7186
7187 /* additional initialization for auto-configuration model */
7188 static void alc882_auto_init(struct hda_codec *codec)
7189 {
7190         struct alc_spec *spec = codec->spec;
7191         alc882_auto_init_multi_out(codec);
7192         alc882_auto_init_hp_out(codec);
7193         alc882_auto_init_analog_input(codec);
7194         alc882_auto_init_input_src(codec);
7195         if (spec->unsol_event)
7196                 alc_inithook(codec);
7197 }
7198
7199 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7200
7201 static int patch_alc882(struct hda_codec *codec)
7202 {
7203         struct alc_spec *spec;
7204         int err, board_config;
7205
7206         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7207         if (spec == NULL)
7208                 return -ENOMEM;
7209
7210         codec->spec = spec;
7211
7212         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7213                                                   alc882_models,
7214                                                   alc882_cfg_tbl);
7215
7216         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7217                 /* Pick up systems that don't supply PCI SSID */
7218                 switch (codec->subsystem_id) {
7219                 case 0x106b0c00: /* Mac Pro */
7220                         board_config = ALC885_MACPRO;
7221                         break;
7222                 case 0x106b1000: /* iMac 24 */
7223                 case 0x106b2800: /* AppleTV */
7224                 case 0x106b3e00: /* iMac 24 Aluminium */
7225                         board_config = ALC885_IMAC24;
7226                         break;
7227                 case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7228                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7229                 case 0x106b00a4: /* MacbookPro4,1 */
7230                 case 0x106b2c00: /* Macbook Pro rev3 */
7231                 case 0x106b3600: /* Macbook 3.1 */
7232                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7233                         board_config = ALC885_MBP3;
7234                         break;
7235                 default:
7236                         /* ALC889A is handled better as ALC888-compatible */
7237                         if (codec->revision_id == 0x100101 ||
7238                             codec->revision_id == 0x100103) {
7239                                 alc_free(codec);
7240                                 return patch_alc883(codec);
7241                         }
7242                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
7243                                          "trying auto-probe from BIOS...\n");
7244                         board_config = ALC882_AUTO;
7245                 }
7246         }
7247
7248         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7249
7250         if (board_config == ALC882_AUTO) {
7251                 /* automatic parse from the BIOS config */
7252                 err = alc882_parse_auto_config(codec);
7253                 if (err < 0) {
7254                         alc_free(codec);
7255                         return err;
7256                 } else if (!err) {
7257                         printk(KERN_INFO
7258                                "hda_codec: Cannot set up configuration "
7259                                "from BIOS.  Using base mode...\n");
7260                         board_config = ALC882_3ST_DIG;
7261                 }
7262         }
7263
7264         err = snd_hda_attach_beep_device(codec, 0x1);
7265         if (err < 0) {
7266                 alc_free(codec);
7267                 return err;
7268         }
7269
7270         if (board_config != ALC882_AUTO)
7271                 setup_preset(spec, &alc882_presets[board_config]);
7272
7273         if (codec->vendor_id == 0x10ec0885) {
7274                 spec->stream_name_analog = "ALC885 Analog";
7275                 spec->stream_name_digital = "ALC885 Digital";
7276         } else {
7277                 spec->stream_name_analog = "ALC882 Analog";
7278                 spec->stream_name_digital = "ALC882 Digital";
7279         }
7280
7281         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7282         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7283         /* FIXME: setup DAC5 */
7284         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7285         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7286
7287         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7288         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7289
7290         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7291         if (!spec->adc_nids && spec->input_mux) {
7292                 /* check whether NID 0x07 is valid */
7293                 unsigned int wcap = get_wcaps(codec, 0x07);
7294                 /* get type */
7295                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7296                 if (wcap != AC_WID_AUD_IN) {
7297                         spec->adc_nids = alc882_adc_nids_alt;
7298                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7299                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7300                 } else {
7301                         spec->adc_nids = alc882_adc_nids;
7302                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7303                         spec->capsrc_nids = alc882_capsrc_nids;
7304                 }
7305         }
7306         set_capture_mixer(spec);
7307         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7308
7309         spec->vmaster_nid = 0x0c;
7310
7311         codec->patch_ops = alc_patch_ops;
7312         if (board_config == ALC882_AUTO)
7313                 spec->init_hook = alc882_auto_init;
7314 #ifdef CONFIG_SND_HDA_POWER_SAVE
7315         if (!spec->loopback.amplist)
7316                 spec->loopback.amplist = alc882_loopbacks;
7317 #endif
7318         codec->proc_widget_hook = print_realtek_coef;
7319
7320         return 0;
7321 }
7322
7323 /*
7324  * ALC883 support
7325  *
7326  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7327  * configuration.  Each pin widget can choose any input DACs and a mixer.
7328  * Each ADC is connected from a mixer of all inputs.  This makes possible
7329  * 6-channel independent captures.
7330  *
7331  * In addition, an independent DAC for the multi-playback (not used in this
7332  * driver yet).
7333  */
7334 #define ALC883_DIGOUT_NID       0x06
7335 #define ALC883_DIGIN_NID        0x0a
7336
7337 #define ALC1200_DIGOUT_NID      0x10
7338
7339 static hda_nid_t alc883_dac_nids[4] = {
7340         /* front, rear, clfe, rear_surr */
7341         0x02, 0x03, 0x04, 0x05
7342 };
7343
7344 static hda_nid_t alc883_adc_nids[2] = {
7345         /* ADC1-2 */
7346         0x08, 0x09,
7347 };
7348
7349 static hda_nid_t alc883_adc_nids_alt[1] = {
7350         /* ADC1 */
7351         0x08,
7352 };
7353
7354 static hda_nid_t alc883_adc_nids_rev[2] = {
7355         /* ADC2-1 */
7356         0x09, 0x08
7357 };
7358
7359 #define alc889_adc_nids         alc880_adc_nids
7360
7361 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7362
7363 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7364
7365 #define alc889_capsrc_nids      alc882_capsrc_nids
7366
7367 /* input MUX */
7368 /* FIXME: should be a matrix-type input source selection */
7369
7370 static struct hda_input_mux alc883_capture_source = {
7371         .num_items = 4,
7372         .items = {
7373                 { "Mic", 0x0 },
7374                 { "Front Mic", 0x1 },
7375                 { "Line", 0x2 },
7376                 { "CD", 0x4 },
7377         },
7378 };
7379
7380 static struct hda_input_mux alc883_3stack_6ch_intel = {
7381         .num_items = 4,
7382         .items = {
7383                 { "Mic", 0x1 },
7384                 { "Front Mic", 0x0 },
7385                 { "Line", 0x2 },
7386                 { "CD", 0x4 },
7387         },
7388 };
7389
7390 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7391         .num_items = 2,
7392         .items = {
7393                 { "Mic", 0x1 },
7394                 { "Line", 0x2 },
7395         },
7396 };
7397
7398 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7399         .num_items = 4,
7400         .items = {
7401                 { "Mic", 0x0 },
7402                 { "iMic", 0x1 },
7403                 { "Line", 0x2 },
7404                 { "CD", 0x4 },
7405         },
7406 };
7407
7408 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7409         .num_items = 2,
7410         .items = {
7411                 { "Mic", 0x0 },
7412                 { "Int Mic", 0x1 },
7413         },
7414 };
7415
7416 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7417         .num_items = 3,
7418         .items = {
7419                 { "Mic", 0x0 },
7420                 { "Front Mic", 0x1 },
7421                 { "Line", 0x4 },
7422         },
7423 };
7424
7425 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7426         .num_items = 2,
7427         .items = {
7428                 { "Mic", 0x0 },
7429                 { "Line", 0x2 },
7430         },
7431 };
7432
7433 /*
7434  * 2ch mode
7435  */
7436 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7437         { 2, NULL }
7438 };
7439
7440 /*
7441  * 2ch mode
7442  */
7443 static struct hda_verb alc883_3ST_ch2_init[] = {
7444         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7445         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7446         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7447         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7448         { } /* end */
7449 };
7450
7451 /*
7452  * 4ch mode
7453  */
7454 static struct hda_verb alc883_3ST_ch4_init[] = {
7455         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7456         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7457         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7458         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7459         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7460         { } /* end */
7461 };
7462
7463 /*
7464  * 6ch mode
7465  */
7466 static struct hda_verb alc883_3ST_ch6_init[] = {
7467         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7468         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7469         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7470         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7471         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7472         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7473         { } /* end */
7474 };
7475
7476 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7477         { 2, alc883_3ST_ch2_init },
7478         { 4, alc883_3ST_ch4_init },
7479         { 6, alc883_3ST_ch6_init },
7480 };
7481
7482 /*
7483  * 2ch mode
7484  */
7485 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7486         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7487         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7488         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7489         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7490         { } /* end */
7491 };
7492
7493 /*
7494  * 4ch mode
7495  */
7496 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7497         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7498         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7499         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7500         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7501         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7502         { } /* end */
7503 };
7504
7505 /*
7506  * 6ch mode
7507  */
7508 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7509         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7510         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7511         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7512         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7513         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7514         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7515         { } /* end */
7516 };
7517
7518 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7519         { 2, alc883_3ST_ch2_intel_init },
7520         { 4, alc883_3ST_ch4_intel_init },
7521         { 6, alc883_3ST_ch6_intel_init },
7522 };
7523
7524 /*
7525  * 6ch mode
7526  */
7527 static struct hda_verb alc883_sixstack_ch6_init[] = {
7528         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7529         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7530         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7531         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7532         { } /* end */
7533 };
7534
7535 /*
7536  * 8ch mode
7537  */
7538 static struct hda_verb alc883_sixstack_ch8_init[] = {
7539         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7540         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7541         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7542         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7543         { } /* end */
7544 };
7545
7546 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7547         { 6, alc883_sixstack_ch6_init },
7548         { 8, alc883_sixstack_ch8_init },
7549 };
7550
7551 static struct hda_verb alc883_medion_eapd_verbs[] = {
7552         /* eanable EAPD on medion laptop */
7553         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7554         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7555         { }
7556 };
7557
7558 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7559  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7560  */
7561
7562 static struct snd_kcontrol_new alc883_base_mixer[] = {
7563         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7564         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7565         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7566         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7567         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7568         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7569         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7570         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7571         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7572         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7573         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7574         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7575         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7576         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7577         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7578         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7579         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7580         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7581         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7582         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7583         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7584         { } /* end */
7585 };
7586
7587 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7588         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7589         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7590         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7591         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7592         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7593         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7594         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7595         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7596         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7597         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7598         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7599         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7600         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7601         { } /* end */
7602 };
7603
7604 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7605         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7606         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7607         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7608         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7609         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7610         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7611         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7612         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7613         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7614         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7615         { } /* end */
7616 };
7617
7618 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7619         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7620         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7621         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7622         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7623         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7624         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7625         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7626         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7627         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7628         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7629         { } /* end */
7630 };
7631
7632 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7633         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7634         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7635         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7636         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7637         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7638         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7639         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7640         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7641         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7642         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7643         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7644         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7645         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7646         { } /* end */
7647 };
7648
7649 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7650         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7651         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7652         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7653         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7654         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7655         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7656         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7657         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7658         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7659         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7660         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7661         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7662         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7663         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7664         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7665         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7666         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7667         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7668         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7669         { } /* end */
7670 };
7671
7672 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7673         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7674         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7675         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7676         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7677         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7678                               HDA_OUTPUT),
7679         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7680         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7681         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7682         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7683         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7684         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7685         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7686         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7687         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7688         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7689         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7690         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7691         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7692         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7693         { } /* end */
7694 };
7695
7696 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7697         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7698         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7699         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7700         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7701         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7702         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7703         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7704         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7705         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7706         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7707         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7708         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7709         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7710         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7711         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7712         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7713         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7714         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7715         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7716         { } /* end */
7717 };
7718
7719 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7720         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7721         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7722         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7723         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7724         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7725         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7726         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7727         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7728         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7729         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7730         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7731         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7732         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7733         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7734         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7735         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7736         { } /* end */
7737 };
7738
7739 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7740         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7741         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7742         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7743         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7744         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7745         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7746         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7748         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7749         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7750         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7751         { } /* end */
7752 };
7753
7754 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7755         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7756         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7757         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7758         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7759         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7761         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7762         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7763         { } /* end */
7764 };
7765
7766 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7767         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7768         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7769         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7770         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7771         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7772         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7773         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7774         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7775         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7776         { } /* end */
7777 };
7778
7779 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7780         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7781         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7782         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7783         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7784         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7785         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7787         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7788         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7789         { } /* end */
7790 };
7791
7792 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7793         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7794         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7796         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7797         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7798         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7799         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7800         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7801         { } /* end */
7802 };
7803
7804 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7805         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7806         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7807         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7808         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7809         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7810                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7811         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7812         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7813         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7814         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7815         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7816         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7817         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7818         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7819         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7820         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7821         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7822         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7823         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7824         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7825         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7826         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7827         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7828         { } /* end */
7829 };
7830
7831 static struct hda_bind_ctls alc883_bind_cap_vol = {
7832         .ops = &snd_hda_bind_vol,
7833         .values = {
7834                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7835                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7836                 0
7837         },
7838 };
7839
7840 static struct hda_bind_ctls alc883_bind_cap_switch = {
7841         .ops = &snd_hda_bind_sw,
7842         .values = {
7843                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7844                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7845                 0
7846         },
7847 };
7848
7849 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7850         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7851         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7852         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7853         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7854         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7855         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7856         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7858         { } /* end */
7859 };
7860
7861 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7862         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7863         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7864         {
7865                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7866                 /* .name = "Capture Source", */
7867                 .name = "Input Source",
7868                 .count = 1,
7869                 .info = alc_mux_enum_info,
7870                 .get = alc_mux_enum_get,
7871                 .put = alc_mux_enum_put,
7872         },
7873         { } /* end */
7874 };
7875
7876 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7877         {
7878                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7879                 .name = "Channel Mode",
7880                 .info = alc_ch_mode_info,
7881                 .get = alc_ch_mode_get,
7882                 .put = alc_ch_mode_put,
7883         },
7884         { } /* end */
7885 };
7886
7887 static struct hda_verb alc883_init_verbs[] = {
7888         /* ADC1: mute amp left and right */
7889         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7890         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7891         /* ADC2: mute amp left and right */
7892         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7893         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7894         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7895         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7896         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7897         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7898         /* Rear mixer */
7899         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7900         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7901         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7902         /* CLFE mixer */
7903         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7904         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7905         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7906         /* Side mixer */
7907         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7908         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7909         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7910
7911         /* mute analog input loopbacks */
7912         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7913         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7914         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7915         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7916         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7917
7918         /* Front Pin: output 0 (0x0c) */
7919         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7920         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7921         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7922         /* Rear Pin: output 1 (0x0d) */
7923         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7924         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7925         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7926         /* CLFE Pin: output 2 (0x0e) */
7927         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7928         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7929         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7930         /* Side Pin: output 3 (0x0f) */
7931         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7932         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7933         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7934         /* Mic (rear) pin: input vref at 80% */
7935         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7936         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7937         /* Front Mic pin: input vref at 80% */
7938         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7939         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7940         /* Line In pin: input */
7941         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7942         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7943         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7944         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7945         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7946         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7947         /* CD pin widget for input */
7948         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7949
7950         /* FIXME: use matrix-type input source selection */
7951         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7952         /* Input mixer2 */
7953         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7954         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7955         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7956         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7957         /* Input mixer3 */
7958         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7959         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7960         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7961         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7962         { }
7963 };
7964
7965 /* toggle speaker-output according to the hp-jack state */
7966 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7967 {
7968         unsigned int present;
7969
7970         present = snd_hda_codec_read(codec, 0x15, 0,
7971                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7972         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7973                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7974         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7975                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7976 }
7977
7978 /* auto-toggle front mic */
7979 /*
7980 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7981 {
7982         unsigned int present;
7983         unsigned char bits;
7984
7985         present = snd_hda_codec_read(codec, 0x18, 0,
7986                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7987         bits = present ? HDA_AMP_MUTE : 0;
7988         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7989 }
7990 */
7991
7992 static void alc883_mitac_automute(struct hda_codec *codec)
7993 {
7994         alc883_mitac_hp_automute(codec);
7995         /* alc883_mitac_mic_automute(codec); */
7996 }
7997
7998 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7999                                            unsigned int res)
8000 {
8001         switch (res >> 26) {
8002         case ALC880_HP_EVENT:
8003                 alc883_mitac_hp_automute(codec);
8004                 break;
8005         case ALC880_MIC_EVENT:
8006                 /* alc883_mitac_mic_automute(codec); */
8007                 break;
8008         }
8009 }
8010
8011 static struct hda_verb alc883_mitac_verbs[] = {
8012         /* HP */
8013         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8014         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8015         /* Subwoofer */
8016         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8017         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8018
8019         /* enable unsolicited event */
8020         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8021         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8022
8023         { } /* end */
8024 };
8025
8026 static struct hda_verb alc883_clevo_m720_verbs[] = {
8027         /* HP */
8028         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8029         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8030         /* Int speaker */
8031         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8032         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8033
8034         /* enable unsolicited event */
8035         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8036         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8037
8038         { } /* end */
8039 };
8040
8041 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8042         /* HP */
8043         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8044         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8045         /* Subwoofer */
8046         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8047         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8048
8049         /* enable unsolicited event */
8050         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8051
8052         { } /* end */
8053 };
8054
8055 static struct hda_verb alc883_tagra_verbs[] = {
8056         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8057         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8058
8059         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8060         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8061
8062         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8063         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8064         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8065
8066         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8067         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8068         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8069         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8070
8071         { } /* end */
8072 };
8073
8074 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8075         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8076         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8077         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8078         { } /* end */
8079 };
8080
8081 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8083         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8084         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8085         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8086         { } /* end */
8087 };
8088
8089 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8090         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8091         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8092         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8093         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8094         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8095         { } /* end */
8096 };
8097
8098 static struct hda_verb alc883_haier_w66_verbs[] = {
8099         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8100         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8101
8102         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8103
8104         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8105         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8106         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8107         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8108         { } /* end */
8109 };
8110
8111 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8112         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8113         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8114         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8115         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8116         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8117         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8118         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8119         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8120         { } /* end */
8121 };
8122
8123 static struct hda_verb alc888_3st_hp_verbs[] = {
8124         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8125         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8126         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8127         { }
8128 };
8129
8130 static struct hda_verb alc888_6st_dell_verbs[] = {
8131         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8132         { }
8133 };
8134
8135 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8136         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8137         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8138         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8139         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8140         { }
8141 };
8142
8143 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8144         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8145         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8146         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8147         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8148         { }
8149 };
8150
8151 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
8152         { 2, alc888_3st_hp_2ch_init },
8153         { 6, alc888_3st_hp_6ch_init },
8154 };
8155
8156 /* toggle front-jack and RCA according to the hp-jack state */
8157 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8158 {
8159         unsigned int present;
8160
8161         present = snd_hda_codec_read(codec, 0x1b, 0,
8162                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8163         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8164                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8165         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8166                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8167 }
8168
8169 /* toggle RCA according to the front-jack state */
8170 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8171 {
8172         unsigned int present;
8173
8174         present = snd_hda_codec_read(codec, 0x14, 0,
8175                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8176         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8177                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8178 }
8179
8180 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8181                                              unsigned int res)
8182 {
8183         if ((res >> 26) == ALC880_HP_EVENT)
8184                 alc888_lenovo_ms7195_front_automute(codec);
8185         if ((res >> 26) == ALC880_FRONT_EVENT)
8186                 alc888_lenovo_ms7195_rca_automute(codec);
8187 }
8188
8189 static struct hda_verb alc883_medion_md2_verbs[] = {
8190         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8191         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8192
8193         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8194
8195         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8196         { } /* end */
8197 };
8198
8199 /* toggle speaker-output according to the hp-jack state */
8200 static void alc883_medion_md2_automute(struct hda_codec *codec)
8201 {
8202         unsigned int present;
8203
8204         present = snd_hda_codec_read(codec, 0x14, 0,
8205                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8206         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8207                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8208 }
8209
8210 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
8211                                           unsigned int res)
8212 {
8213         if ((res >> 26) == ALC880_HP_EVENT)
8214                 alc883_medion_md2_automute(codec);
8215 }
8216
8217 /* toggle speaker-output according to the hp-jack state */
8218 static void alc883_tagra_automute(struct hda_codec *codec)
8219 {
8220         unsigned int present;
8221         unsigned char bits;
8222
8223         present = snd_hda_codec_read(codec, 0x14, 0,
8224                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8225         bits = present ? HDA_AMP_MUTE : 0;
8226         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
8227                                  HDA_AMP_MUTE, bits);
8228         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8229                                   present ? 1 : 3);
8230 }
8231
8232 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
8233 {
8234         if ((res >> 26) == ALC880_HP_EVENT)
8235                 alc883_tagra_automute(codec);
8236 }
8237
8238 /* toggle speaker-output according to the hp-jack state */
8239 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
8240 {
8241         unsigned int present;
8242         unsigned char bits;
8243
8244         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
8245                 & AC_PINSENSE_PRESENCE;
8246         bits = present ? HDA_AMP_MUTE : 0;
8247         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8248                                  HDA_AMP_MUTE, bits);
8249 }
8250
8251 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8252 {
8253         unsigned int present;
8254
8255         present = snd_hda_codec_read(codec, 0x18, 0,
8256                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8257         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8258                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8259 }
8260
8261 static void alc883_clevo_m720_automute(struct hda_codec *codec)
8262 {
8263         alc883_clevo_m720_hp_automute(codec);
8264         alc883_clevo_m720_mic_automute(codec);
8265 }
8266
8267 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8268                                            unsigned int res)
8269 {
8270         switch (res >> 26) {
8271         case ALC880_HP_EVENT:
8272                 alc883_clevo_m720_hp_automute(codec);
8273                 break;
8274         case ALC880_MIC_EVENT:
8275                 alc883_clevo_m720_mic_automute(codec);
8276                 break;
8277         }
8278 }
8279
8280 /* toggle speaker-output according to the hp-jack state */
8281 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8282 {
8283         unsigned int present;
8284         unsigned char bits;
8285
8286         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8287                 & AC_PINSENSE_PRESENCE;
8288         bits = present ? HDA_AMP_MUTE : 0;
8289         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8290                                  HDA_AMP_MUTE, bits);
8291 }
8292
8293 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8294                                                   unsigned int res)
8295 {
8296         if ((res >> 26) == ALC880_HP_EVENT)
8297                 alc883_2ch_fujitsu_pi2515_automute(codec);
8298 }
8299
8300 static void alc883_haier_w66_automute(struct hda_codec *codec)
8301 {
8302         unsigned int present;
8303         unsigned char bits;
8304
8305         present = snd_hda_codec_read(codec, 0x1b, 0,
8306                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8307         bits = present ? 0x80 : 0;
8308         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8309                                  0x80, bits);
8310 }
8311
8312 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8313                                          unsigned int res)
8314 {
8315         if ((res >> 26) == ALC880_HP_EVENT)
8316                 alc883_haier_w66_automute(codec);
8317 }
8318
8319 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8320 {
8321         unsigned int present;
8322         unsigned char bits;
8323
8324         present = snd_hda_codec_read(codec, 0x14, 0,
8325                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8326         bits = present ? HDA_AMP_MUTE : 0;
8327         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8328                                  HDA_AMP_MUTE, bits);
8329 }
8330
8331 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8332 {
8333         unsigned int present;
8334         unsigned char bits;
8335
8336         present = snd_hda_codec_read(codec, 0x1b, 0,
8337                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8338         bits = present ? HDA_AMP_MUTE : 0;
8339         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8340                                  HDA_AMP_MUTE, bits);
8341         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8342                                  HDA_AMP_MUTE, bits);
8343 }
8344
8345 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8346                                            unsigned int res)
8347 {
8348         if ((res >> 26) == ALC880_HP_EVENT)
8349                 alc883_lenovo_101e_all_automute(codec);
8350         if ((res >> 26) == ALC880_FRONT_EVENT)
8351                 alc883_lenovo_101e_ispeaker_automute(codec);
8352 }
8353
8354 /* toggle speaker-output according to the hp-jack state */
8355 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8356 {
8357         unsigned int present;
8358
8359         present = snd_hda_codec_read(codec, 0x14, 0,
8360                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8361         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8362                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8363         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8364                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8365 }
8366
8367 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8368                                            unsigned int res)
8369 {
8370         if ((res >> 26) == ALC880_HP_EVENT)
8371                 alc883_acer_aspire_automute(codec);
8372 }
8373
8374 static struct hda_verb alc883_acer_eapd_verbs[] = {
8375         /* HP Pin: output 0 (0x0c) */
8376         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8377         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8378         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8379         /* Front Pin: output 0 (0x0c) */
8380         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8381         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8382         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8383         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8384         /* eanable EAPD on medion laptop */
8385         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8386         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8387         /* enable unsolicited event */
8388         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8389         { }
8390 };
8391
8392 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8393 {
8394         unsigned int present;
8395
8396         present = snd_hda_codec_read(codec, 0x1b, 0,
8397                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8398         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8399                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8400         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8401                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8402         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8403                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8404         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8405                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8406 }
8407
8408 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8409                                              unsigned int res)
8410 {
8411         switch (res >> 26) {
8412         case ALC880_HP_EVENT:
8413                 /* printk(KERN_DEBUG "hp_event\n"); */
8414                 alc888_6st_dell_front_automute(codec);
8415                 break;
8416         }
8417 }
8418
8419 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8420 {
8421         unsigned int mute;
8422         unsigned int present;
8423
8424         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8425         present = snd_hda_codec_read(codec, 0x1b, 0,
8426                                      AC_VERB_GET_PIN_SENSE, 0);
8427         present = (present & 0x80000000) != 0;
8428         if (present) {
8429                 /* mute internal speaker */
8430                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8431                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8432                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8433                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8434                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8435                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8436                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8437                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8438                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8439                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8440         } else {
8441                 /* unmute internal speaker if necessary */
8442                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8443                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8444                                          HDA_AMP_MUTE, mute);
8445                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8446                                          HDA_AMP_MUTE, mute);
8447                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8448                                          HDA_AMP_MUTE, mute);
8449                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8450                                          HDA_AMP_MUTE, mute);
8451                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8452                                          HDA_AMP_MUTE, mute);
8453         }
8454 }
8455
8456 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8457                                              unsigned int res)
8458 {
8459         if ((res >> 26) == ALC880_HP_EVENT)
8460                 alc888_lenovo_sky_front_automute(codec);
8461 }
8462
8463 /*
8464  * generic initialization of ADC, input mixers and output mixers
8465  */
8466 static struct hda_verb alc883_auto_init_verbs[] = {
8467         /*
8468          * Unmute ADC0-2 and set the default input to mic-in
8469          */
8470         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8471         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8473         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8474
8475         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8476          * mixer widget
8477          * Note: PASD motherboards uses the Line In 2 as the input for
8478          * front panel mic (mic 2)
8479          */
8480         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8481         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8482         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8483         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8485         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8486
8487         /*
8488          * Set up output mixers (0x0c - 0x0f)
8489          */
8490         /* set vol=0 to output mixers */
8491         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8492         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8493         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8494         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8495         /* set up input amps for analog loopback */
8496         /* Amp Indices: DAC = 0, mixer = 1 */
8497         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8498         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8499         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8500         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8501         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8502         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8503         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8504         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8505         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8506         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8507
8508         /* FIXME: use matrix-type input source selection */
8509         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8510         /* Input mixer1 */
8511         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8512         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8513         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8514         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8515         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8516         /* Input mixer2 */
8517         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8518         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8519         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8520         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8521         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8522
8523         { }
8524 };
8525
8526 static struct hda_verb alc888_asus_m90v_verbs[] = {
8527         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8528         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8529         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8530         /* enable unsolicited event */
8531         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8532         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8533         { } /* end */
8534 };
8535
8536 static void alc883_nb_mic_automute(struct hda_codec *codec)
8537 {
8538         unsigned int present;
8539
8540         present = snd_hda_codec_read(codec, 0x18, 0,
8541                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8542         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8543                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8544         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8545                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8546 }
8547
8548 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8549 {
8550         unsigned int present;
8551         unsigned char bits;
8552
8553         present = snd_hda_codec_read(codec, 0x1b, 0,
8554                                      AC_VERB_GET_PIN_SENSE, 0)
8555                 & AC_PINSENSE_PRESENCE;
8556         bits = present ? 0 : PIN_OUT;
8557         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8558                             bits);
8559         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8560                             bits);
8561         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8562                             bits);
8563 }
8564
8565 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8566                                            unsigned int res)
8567 {
8568         switch (res >> 26) {
8569         case ALC880_HP_EVENT:
8570                 alc883_M90V_speaker_automute(codec);
8571                 break;
8572         case ALC880_MIC_EVENT:
8573                 alc883_nb_mic_automute(codec);
8574                 break;
8575         }
8576 }
8577
8578 static void alc883_mode2_inithook(struct hda_codec *codec)
8579 {
8580         alc883_M90V_speaker_automute(codec);
8581         alc883_nb_mic_automute(codec);
8582 }
8583
8584 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8585         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8586         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8587         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8588         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8589         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8590         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8591         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8592         /* enable unsolicited event */
8593         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8594         { } /* end */
8595 };
8596
8597 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8598 {
8599         unsigned int present;
8600         unsigned char bits;
8601
8602         present = snd_hda_codec_read(codec, 0x14, 0,
8603                                      AC_VERB_GET_PIN_SENSE, 0)
8604                 & AC_PINSENSE_PRESENCE;
8605         bits = present ? 0 : PIN_OUT;
8606         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8607                             bits);
8608 }
8609
8610 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8611                                            unsigned int res)
8612 {
8613         switch (res >> 26) {
8614         case ALC880_HP_EVENT:
8615                 alc883_eee1601_speaker_automute(codec);
8616                 break;
8617         }
8618 }
8619
8620 static void alc883_eee1601_inithook(struct hda_codec *codec)
8621 {
8622         alc883_eee1601_speaker_automute(codec);
8623 }
8624
8625 #ifdef CONFIG_SND_HDA_POWER_SAVE
8626 #define alc883_loopbacks        alc880_loopbacks
8627 #endif
8628
8629 /* pcm configuration: identiacal with ALC880 */
8630 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8631 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8632 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8633 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8634 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8635
8636 /*
8637  * configuration and preset
8638  */
8639 static const char *alc883_models[ALC883_MODEL_LAST] = {
8640         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8641         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8642         [ALC883_3ST_6ch]        = "3stack-6ch",
8643         [ALC883_6ST_DIG]        = "6stack-dig",
8644         [ALC883_TARGA_DIG]      = "targa-dig",
8645         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8646         [ALC883_ACER]           = "acer",
8647         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8648         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8649         [ALC883_MEDION]         = "medion",
8650         [ALC883_MEDION_MD2]     = "medion-md2",
8651         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8652         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8653         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8654         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8655         [ALC888_LENOVO_SKY] = "lenovo-sky",
8656         [ALC883_HAIER_W66]      = "haier-w66",
8657         [ALC888_3ST_HP]         = "3stack-hp",
8658         [ALC888_6ST_DELL]       = "6stack-dell",
8659         [ALC883_MITAC]          = "mitac",
8660         [ALC883_CLEVO_M720]     = "clevo-m720",
8661         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8662         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8663         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8664         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8665         [ALC883_AUTO]           = "auto",
8666 };
8667
8668 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8669         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8670         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8671         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8672         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8673         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8674         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8675         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8676                 ALC888_ACER_ASPIRE_4930G),
8677         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8678                 ALC888_ACER_ASPIRE_4930G),
8679         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8680         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8681         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8682                 ALC888_ACER_ASPIRE_4930G),
8683         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8684                 ALC888_ACER_ASPIRE_4930G),
8685         /* default Acer */
8686         SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
8687         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8688         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8689         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8690         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8691         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8692         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8693         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8694         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8695         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8696         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8697         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8698         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8699         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8700         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8701         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8702         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8703         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8704         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8705         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8706         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8707         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8708         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8709         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8710         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8711         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8712         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8713         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8714         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8715         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8716         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8717         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8718         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8719         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8720         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8721         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8722         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8723         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8724         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8725         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8726         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8727         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8728         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8729         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8730         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8731         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8732         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8733         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8734         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8735         SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550",
8736                       ALC883_FUJITSU_PI2515),
8737         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8738         SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
8739                 ALC888_FUJITSU_XA3530),
8740         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8741         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8742         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8743         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8744         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8745         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8746         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8747         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8748         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8749         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8750         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8751         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8752         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8753         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8754         {}
8755 };
8756
8757 static hda_nid_t alc1200_slave_dig_outs[] = {
8758         ALC883_DIGOUT_NID, 0,
8759 };
8760
8761 static struct alc_config_preset alc883_presets[] = {
8762         [ALC883_3ST_2ch_DIG] = {
8763                 .mixers = { alc883_3ST_2ch_mixer },
8764                 .init_verbs = { alc883_init_verbs },
8765                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8766                 .dac_nids = alc883_dac_nids,
8767                 .dig_out_nid = ALC883_DIGOUT_NID,
8768                 .dig_in_nid = ALC883_DIGIN_NID,
8769                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8770                 .channel_mode = alc883_3ST_2ch_modes,
8771                 .input_mux = &alc883_capture_source,
8772         },
8773         [ALC883_3ST_6ch_DIG] = {
8774                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8775                 .init_verbs = { alc883_init_verbs },
8776                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8777                 .dac_nids = alc883_dac_nids,
8778                 .dig_out_nid = ALC883_DIGOUT_NID,
8779                 .dig_in_nid = ALC883_DIGIN_NID,
8780                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8781                 .channel_mode = alc883_3ST_6ch_modes,
8782                 .need_dac_fix = 1,
8783                 .input_mux = &alc883_capture_source,
8784         },
8785         [ALC883_3ST_6ch] = {
8786                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8787                 .init_verbs = { alc883_init_verbs },
8788                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8789                 .dac_nids = alc883_dac_nids,
8790                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8791                 .channel_mode = alc883_3ST_6ch_modes,
8792                 .need_dac_fix = 1,
8793                 .input_mux = &alc883_capture_source,
8794         },
8795         [ALC883_3ST_6ch_INTEL] = {
8796                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8797                 .init_verbs = { alc883_init_verbs },
8798                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8799                 .dac_nids = alc883_dac_nids,
8800                 .dig_out_nid = ALC883_DIGOUT_NID,
8801                 .dig_in_nid = ALC883_DIGIN_NID,
8802                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8803                 .channel_mode = alc883_3ST_6ch_intel_modes,
8804                 .need_dac_fix = 1,
8805                 .input_mux = &alc883_3stack_6ch_intel,
8806         },
8807         [ALC883_6ST_DIG] = {
8808                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8809                 .init_verbs = { alc883_init_verbs },
8810                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8811                 .dac_nids = alc883_dac_nids,
8812                 .dig_out_nid = ALC883_DIGOUT_NID,
8813                 .dig_in_nid = ALC883_DIGIN_NID,
8814                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8815                 .channel_mode = alc883_sixstack_modes,
8816                 .input_mux = &alc883_capture_source,
8817         },
8818         [ALC883_TARGA_DIG] = {
8819                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8820                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8821                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8822                 .dac_nids = alc883_dac_nids,
8823                 .dig_out_nid = ALC883_DIGOUT_NID,
8824                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8825                 .channel_mode = alc883_3ST_6ch_modes,
8826                 .need_dac_fix = 1,
8827                 .input_mux = &alc883_capture_source,
8828                 .unsol_event = alc883_tagra_unsol_event,
8829                 .init_hook = alc883_tagra_automute,
8830         },
8831         [ALC883_TARGA_2ch_DIG] = {
8832                 .mixers = { alc883_tagra_2ch_mixer},
8833                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8834                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8835                 .dac_nids = alc883_dac_nids,
8836                 .adc_nids = alc883_adc_nids_alt,
8837                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8838                 .dig_out_nid = ALC883_DIGOUT_NID,
8839                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8840                 .channel_mode = alc883_3ST_2ch_modes,
8841                 .input_mux = &alc883_capture_source,
8842                 .unsol_event = alc883_tagra_unsol_event,
8843                 .init_hook = alc883_tagra_automute,
8844         },
8845         [ALC883_ACER] = {
8846                 .mixers = { alc883_base_mixer },
8847                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8848                  * and the headphone jack.  Turn this on and rely on the
8849                  * standard mute methods whenever the user wants to turn
8850                  * these outputs off.
8851                  */
8852                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8853                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8854                 .dac_nids = alc883_dac_nids,
8855                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8856                 .channel_mode = alc883_3ST_2ch_modes,
8857                 .input_mux = &alc883_capture_source,
8858         },
8859         [ALC883_ACER_ASPIRE] = {
8860                 .mixers = { alc883_acer_aspire_mixer },
8861                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8862                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8863                 .dac_nids = alc883_dac_nids,
8864                 .dig_out_nid = ALC883_DIGOUT_NID,
8865                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8866                 .channel_mode = alc883_3ST_2ch_modes,
8867                 .input_mux = &alc883_capture_source,
8868                 .unsol_event = alc883_acer_aspire_unsol_event,
8869                 .init_hook = alc883_acer_aspire_automute,
8870         },
8871         [ALC888_ACER_ASPIRE_4930G] = {
8872                 .mixers = { alc888_base_mixer,
8873                                 alc883_chmode_mixer },
8874                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8875                                 alc888_acer_aspire_4930g_verbs },
8876                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8877                 .dac_nids = alc883_dac_nids,
8878                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8879                 .adc_nids = alc883_adc_nids_rev,
8880                 .capsrc_nids = alc883_capsrc_nids_rev,
8881                 .dig_out_nid = ALC883_DIGOUT_NID,
8882                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8883                 .channel_mode = alc883_3ST_6ch_modes,
8884                 .need_dac_fix = 1,
8885                 .num_mux_defs =
8886                         ARRAY_SIZE(alc888_2_capture_sources),
8887                 .input_mux = alc888_2_capture_sources,
8888                 .unsol_event = alc888_acer_aspire_4930g_unsol_event,
8889                 .init_hook = alc888_acer_aspire_4930g_automute,
8890         },
8891         [ALC883_MEDION] = {
8892                 .mixers = { alc883_fivestack_mixer,
8893                             alc883_chmode_mixer },
8894                 .init_verbs = { alc883_init_verbs,
8895                                 alc883_medion_eapd_verbs },
8896                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8897                 .dac_nids = alc883_dac_nids,
8898                 .adc_nids = alc883_adc_nids_alt,
8899                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8900                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8901                 .channel_mode = alc883_sixstack_modes,
8902                 .input_mux = &alc883_capture_source,
8903         },
8904         [ALC883_MEDION_MD2] = {
8905                 .mixers = { alc883_medion_md2_mixer},
8906                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8907                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8908                 .dac_nids = alc883_dac_nids,
8909                 .dig_out_nid = ALC883_DIGOUT_NID,
8910                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8911                 .channel_mode = alc883_3ST_2ch_modes,
8912                 .input_mux = &alc883_capture_source,
8913                 .unsol_event = alc883_medion_md2_unsol_event,
8914                 .init_hook = alc883_medion_md2_automute,
8915         },
8916         [ALC883_LAPTOP_EAPD] = {
8917                 .mixers = { alc883_base_mixer },
8918                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8919                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8920                 .dac_nids = alc883_dac_nids,
8921                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8922                 .channel_mode = alc883_3ST_2ch_modes,
8923                 .input_mux = &alc883_capture_source,
8924         },
8925         [ALC883_CLEVO_M720] = {
8926                 .mixers = { alc883_clevo_m720_mixer },
8927                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8928                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8929                 .dac_nids = alc883_dac_nids,
8930                 .dig_out_nid = ALC883_DIGOUT_NID,
8931                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8932                 .channel_mode = alc883_3ST_2ch_modes,
8933                 .input_mux = &alc883_capture_source,
8934                 .unsol_event = alc883_clevo_m720_unsol_event,
8935                 .init_hook = alc883_clevo_m720_automute,
8936         },
8937         [ALC883_LENOVO_101E_2ch] = {
8938                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8939                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8940                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8941                 .dac_nids = alc883_dac_nids,
8942                 .adc_nids = alc883_adc_nids_alt,
8943                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8944                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8945                 .channel_mode = alc883_3ST_2ch_modes,
8946                 .input_mux = &alc883_lenovo_101e_capture_source,
8947                 .unsol_event = alc883_lenovo_101e_unsol_event,
8948                 .init_hook = alc883_lenovo_101e_all_automute,
8949         },
8950         [ALC883_LENOVO_NB0763] = {
8951                 .mixers = { alc883_lenovo_nb0763_mixer },
8952                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8953                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8954                 .dac_nids = alc883_dac_nids,
8955                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8956                 .channel_mode = alc883_3ST_2ch_modes,
8957                 .need_dac_fix = 1,
8958                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8959                 .unsol_event = alc883_medion_md2_unsol_event,
8960                 .init_hook = alc883_medion_md2_automute,
8961         },
8962         [ALC888_LENOVO_MS7195_DIG] = {
8963                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8964                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8965                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8966                 .dac_nids = alc883_dac_nids,
8967                 .dig_out_nid = ALC883_DIGOUT_NID,
8968                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8969                 .channel_mode = alc883_3ST_6ch_modes,
8970                 .need_dac_fix = 1,
8971                 .input_mux = &alc883_capture_source,
8972                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8973                 .init_hook = alc888_lenovo_ms7195_front_automute,
8974         },
8975         [ALC883_HAIER_W66] = {
8976                 .mixers = { alc883_tagra_2ch_mixer},
8977                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8978                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8979                 .dac_nids = alc883_dac_nids,
8980                 .dig_out_nid = ALC883_DIGOUT_NID,
8981                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8982                 .channel_mode = alc883_3ST_2ch_modes,
8983                 .input_mux = &alc883_capture_source,
8984                 .unsol_event = alc883_haier_w66_unsol_event,
8985                 .init_hook = alc883_haier_w66_automute,
8986         },
8987         [ALC888_3ST_HP] = {
8988                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8989                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8990                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8991                 .dac_nids = alc883_dac_nids,
8992                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8993                 .channel_mode = alc888_3st_hp_modes,
8994                 .need_dac_fix = 1,
8995                 .input_mux = &alc883_capture_source,
8996         },
8997         [ALC888_6ST_DELL] = {
8998                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8999                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9000                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9001                 .dac_nids = alc883_dac_nids,
9002                 .dig_out_nid = ALC883_DIGOUT_NID,
9003                 .dig_in_nid = ALC883_DIGIN_NID,
9004                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9005                 .channel_mode = alc883_sixstack_modes,
9006                 .input_mux = &alc883_capture_source,
9007                 .unsol_event = alc888_6st_dell_unsol_event,
9008                 .init_hook = alc888_6st_dell_front_automute,
9009         },
9010         [ALC883_MITAC] = {
9011                 .mixers = { alc883_mitac_mixer },
9012                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9013                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9014                 .dac_nids = alc883_dac_nids,
9015                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9016                 .channel_mode = alc883_3ST_2ch_modes,
9017                 .input_mux = &alc883_capture_source,
9018                 .unsol_event = alc883_mitac_unsol_event,
9019                 .init_hook = alc883_mitac_automute,
9020         },
9021         [ALC883_FUJITSU_PI2515] = {
9022                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9023                 .init_verbs = { alc883_init_verbs,
9024                                 alc883_2ch_fujitsu_pi2515_verbs},
9025                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9026                 .dac_nids = alc883_dac_nids,
9027                 .dig_out_nid = ALC883_DIGOUT_NID,
9028                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9029                 .channel_mode = alc883_3ST_2ch_modes,
9030                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9031                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
9032                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
9033         },
9034         [ALC888_FUJITSU_XA3530] = {
9035                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9036                 .init_verbs = { alc883_init_verbs,
9037                         alc888_fujitsu_xa3530_verbs },
9038                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9039                 .dac_nids = alc883_dac_nids,
9040                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9041                 .adc_nids = alc883_adc_nids_rev,
9042                 .capsrc_nids = alc883_capsrc_nids_rev,
9043                 .dig_out_nid = ALC883_DIGOUT_NID,
9044                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9045                 .channel_mode = alc888_4ST_8ch_intel_modes,
9046                 .num_mux_defs =
9047                         ARRAY_SIZE(alc888_2_capture_sources),
9048                 .input_mux = alc888_2_capture_sources,
9049                 .unsol_event = alc888_fujitsu_xa3530_unsol_event,
9050                 .init_hook = alc888_fujitsu_xa3530_automute,
9051         },
9052         [ALC888_LENOVO_SKY] = {
9053                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9054                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9055                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9056                 .dac_nids = alc883_dac_nids,
9057                 .dig_out_nid = ALC883_DIGOUT_NID,
9058                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9059                 .channel_mode = alc883_sixstack_modes,
9060                 .need_dac_fix = 1,
9061                 .input_mux = &alc883_lenovo_sky_capture_source,
9062                 .unsol_event = alc883_lenovo_sky_unsol_event,
9063                 .init_hook = alc888_lenovo_sky_front_automute,
9064         },
9065         [ALC888_ASUS_M90V] = {
9066                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9067                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9068                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9069                 .dac_nids = alc883_dac_nids,
9070                 .dig_out_nid = ALC883_DIGOUT_NID,
9071                 .dig_in_nid = ALC883_DIGIN_NID,
9072                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9073                 .channel_mode = alc883_3ST_6ch_modes,
9074                 .need_dac_fix = 1,
9075                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9076                 .unsol_event = alc883_mode2_unsol_event,
9077                 .init_hook = alc883_mode2_inithook,
9078         },
9079         [ALC888_ASUS_EEE1601] = {
9080                 .mixers = { alc883_asus_eee1601_mixer },
9081                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9082                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9083                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9084                 .dac_nids = alc883_dac_nids,
9085                 .dig_out_nid = ALC883_DIGOUT_NID,
9086                 .dig_in_nid = ALC883_DIGIN_NID,
9087                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9088                 .channel_mode = alc883_3ST_2ch_modes,
9089                 .need_dac_fix = 1,
9090                 .input_mux = &alc883_asus_eee1601_capture_source,
9091                 .unsol_event = alc883_eee1601_unsol_event,
9092                 .init_hook = alc883_eee1601_inithook,
9093         },
9094         [ALC1200_ASUS_P5Q] = {
9095                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9096                 .init_verbs = { alc883_init_verbs },
9097                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9098                 .dac_nids = alc883_dac_nids,
9099                 .dig_out_nid = ALC1200_DIGOUT_NID,
9100                 .dig_in_nid = ALC883_DIGIN_NID,
9101                 .slave_dig_outs = alc1200_slave_dig_outs,
9102                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9103                 .channel_mode = alc883_sixstack_modes,
9104                 .input_mux = &alc883_capture_source,
9105         },
9106 };
9107
9108
9109 /*
9110  * BIOS auto configuration
9111  */
9112 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9113                                               hda_nid_t nid, int pin_type,
9114                                               int dac_idx)
9115 {
9116         /* set as output */
9117         struct alc_spec *spec = codec->spec;
9118         int idx;
9119
9120         alc_set_pin_output(codec, nid, pin_type);
9121         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9122                 idx = 4;
9123         else
9124                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9125         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9126
9127 }
9128
9129 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9130 {
9131         struct alc_spec *spec = codec->spec;
9132         int i;
9133
9134         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
9135         for (i = 0; i <= HDA_SIDE; i++) {
9136                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9137                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9138                 if (nid)
9139                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9140                                                           i);
9141         }
9142 }
9143
9144 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9145 {
9146         struct alc_spec *spec = codec->spec;
9147         hda_nid_t pin;
9148
9149         pin = spec->autocfg.hp_pins[0];
9150         if (pin) /* connect to front */
9151                 /* use dac 0 */
9152                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9153         pin = spec->autocfg.speaker_pins[0];
9154         if (pin)
9155                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9156 }
9157
9158 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
9159 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
9160
9161 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9162 {
9163         struct alc_spec *spec = codec->spec;
9164         int i;
9165
9166         for (i = 0; i < AUTO_PIN_LAST; i++) {
9167                 hda_nid_t nid = spec->autocfg.input_pins[i];
9168                 if (alc883_is_input_pin(nid)) {
9169                         snd_hda_codec_write(codec, nid, 0,
9170                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
9171                                             (i <= AUTO_PIN_FRONT_MIC ?
9172                                              PIN_VREF80 : PIN_IN));
9173                         if (nid != ALC883_PIN_CD_NID)
9174                                 snd_hda_codec_write(codec, nid, 0,
9175                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9176                                                     AMP_OUT_MUTE);
9177                 }
9178         }
9179 }
9180
9181 #define alc883_auto_init_input_src      alc882_auto_init_input_src
9182
9183 /* almost identical with ALC880 parser... */
9184 static int alc883_parse_auto_config(struct hda_codec *codec)
9185 {
9186         struct alc_spec *spec = codec->spec;
9187         int err = alc880_parse_auto_config(codec);
9188         struct auto_pin_cfg *cfg = &spec->autocfg;
9189         int i;
9190
9191         if (err < 0)
9192                 return err;
9193         else if (!err)
9194                 return 0; /* no config found */
9195
9196         err = alc_auto_add_mic_boost(codec);
9197         if (err < 0)
9198                 return err;
9199
9200         /* hack - override the init verbs */
9201         spec->init_verbs[0] = alc883_auto_init_verbs;
9202
9203         /* setup input_mux for ALC889 */
9204         if (codec->vendor_id == 0x10ec0889) {
9205                 /* digital-mic input pin is excluded in alc880_auto_create..()
9206                  * because it's under 0x18
9207                  */
9208                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9209                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9210                         struct hda_input_mux *imux = &spec->private_imux[0];
9211                         for (i = 1; i < 3; i++)
9212                                 memcpy(&spec->private_imux[i],
9213                                        &spec->private_imux[0],
9214                                        sizeof(spec->private_imux[0]));
9215                         imux->items[imux->num_items].label = "Int DMic";
9216                         imux->items[imux->num_items].index = 0x0b;
9217                         imux->num_items++;
9218                         spec->num_mux_defs = 3;
9219                         spec->input_mux = spec->private_imux;
9220                 }
9221         }
9222
9223         return 1; /* config found */
9224 }
9225
9226 /* additional initialization for auto-configuration model */
9227 static void alc883_auto_init(struct hda_codec *codec)
9228 {
9229         struct alc_spec *spec = codec->spec;
9230         alc883_auto_init_multi_out(codec);
9231         alc883_auto_init_hp_out(codec);
9232         alc883_auto_init_analog_input(codec);
9233         alc883_auto_init_input_src(codec);
9234         if (spec->unsol_event)
9235                 alc_inithook(codec);
9236 }
9237
9238 static int patch_alc883(struct hda_codec *codec)
9239 {
9240         struct alc_spec *spec;
9241         int err, board_config;
9242
9243         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9244         if (spec == NULL)
9245                 return -ENOMEM;
9246
9247         codec->spec = spec;
9248
9249         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9250
9251         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9252                                                   alc883_models,
9253                                                   alc883_cfg_tbl);
9254         if (board_config < 0) {
9255                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9256                        "trying auto-probe from BIOS...\n");
9257                 board_config = ALC883_AUTO;
9258         }
9259
9260         if (board_config == ALC883_AUTO) {
9261                 /* automatic parse from the BIOS config */
9262                 err = alc883_parse_auto_config(codec);
9263                 if (err < 0) {
9264                         alc_free(codec);
9265                         return err;
9266                 } else if (!err) {
9267                         printk(KERN_INFO
9268                                "hda_codec: Cannot set up configuration "
9269                                "from BIOS.  Using base mode...\n");
9270                         board_config = ALC883_3ST_2ch_DIG;
9271                 }
9272         }
9273
9274         err = snd_hda_attach_beep_device(codec, 0x1);
9275         if (err < 0) {
9276                 alc_free(codec);
9277                 return err;
9278         }
9279
9280         if (board_config != ALC883_AUTO)
9281                 setup_preset(spec, &alc883_presets[board_config]);
9282
9283         switch (codec->vendor_id) {
9284         case 0x10ec0888:
9285                 if (codec->revision_id == 0x100101) {
9286                         spec->stream_name_analog = "ALC1200 Analog";
9287                         spec->stream_name_digital = "ALC1200 Digital";
9288                 } else {
9289                         spec->stream_name_analog = "ALC888 Analog";
9290                         spec->stream_name_digital = "ALC888 Digital";
9291                 }
9292                 if (!spec->num_adc_nids) {
9293                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9294                         spec->adc_nids = alc883_adc_nids;
9295                 }
9296                 if (!spec->capsrc_nids)
9297                         spec->capsrc_nids = alc883_capsrc_nids;
9298                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9299                 break;
9300         case 0x10ec0889:
9301                 spec->stream_name_analog = "ALC889 Analog";
9302                 spec->stream_name_digital = "ALC889 Digital";
9303                 if (!spec->num_adc_nids) {
9304                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9305                         spec->adc_nids = alc889_adc_nids;
9306                 }
9307                 if (!spec->capsrc_nids)
9308                         spec->capsrc_nids = alc889_capsrc_nids;
9309                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9310                                                         capture */
9311                 break;
9312         default:
9313                 spec->stream_name_analog = "ALC883 Analog";
9314                 spec->stream_name_digital = "ALC883 Digital";
9315                 if (!spec->num_adc_nids) {
9316                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9317                         spec->adc_nids = alc883_adc_nids;
9318                 }
9319                 if (!spec->capsrc_nids)
9320                         spec->capsrc_nids = alc883_capsrc_nids;
9321                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9322                 break;
9323         }
9324
9325         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9326         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9327         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9328
9329         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9330         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9331
9332         if (!spec->cap_mixer)
9333                 set_capture_mixer(spec);
9334         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9335
9336         spec->vmaster_nid = 0x0c;
9337
9338         codec->patch_ops = alc_patch_ops;
9339         if (board_config == ALC883_AUTO)
9340                 spec->init_hook = alc883_auto_init;
9341
9342 #ifdef CONFIG_SND_HDA_POWER_SAVE
9343         if (!spec->loopback.amplist)
9344                 spec->loopback.amplist = alc883_loopbacks;
9345 #endif
9346         codec->proc_widget_hook = print_realtek_coef;
9347
9348         return 0;
9349 }
9350
9351 /*
9352  * ALC262 support
9353  */
9354
9355 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9356 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9357
9358 #define alc262_dac_nids         alc260_dac_nids
9359 #define alc262_adc_nids         alc882_adc_nids
9360 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9361 #define alc262_capsrc_nids      alc882_capsrc_nids
9362 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9363
9364 #define alc262_modes            alc260_modes
9365 #define alc262_capture_source   alc882_capture_source
9366
9367 static hda_nid_t alc262_dmic_adc_nids[1] = {
9368         /* ADC0 */
9369         0x09
9370 };
9371
9372 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9373
9374 static struct snd_kcontrol_new alc262_base_mixer[] = {
9375         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9376         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9377         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9378         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9379         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9380         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9381         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9382         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9383         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9384         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9385         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9386         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9387         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9388         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9389         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9390         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9391         { } /* end */
9392 };
9393
9394 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9395         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9396         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9397         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9398         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9399         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9400         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9401         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9402         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9403         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9404         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9405         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9406         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9407         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9408         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9409         { } /* end */
9410 };
9411
9412 /* update HP, line and mono-out pins according to the master switch */
9413 static void alc262_hp_master_update(struct hda_codec *codec)
9414 {
9415         struct alc_spec *spec = codec->spec;
9416         int val = spec->master_sw;
9417
9418         /* HP & line-out */
9419         snd_hda_codec_write_cache(codec, 0x1b, 0,
9420                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9421                                   val ? PIN_HP : 0);
9422         snd_hda_codec_write_cache(codec, 0x15, 0,
9423                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9424                                   val ? PIN_HP : 0);
9425         /* mono (speaker) depending on the HP jack sense */
9426         val = val && !spec->jack_present;
9427         snd_hda_codec_write_cache(codec, 0x16, 0,
9428                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9429                                   val ? PIN_OUT : 0);
9430 }
9431
9432 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9433 {
9434         struct alc_spec *spec = codec->spec;
9435         unsigned int presence;
9436         presence = snd_hda_codec_read(codec, 0x1b, 0,
9437                                       AC_VERB_GET_PIN_SENSE, 0);
9438         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9439         alc262_hp_master_update(codec);
9440 }
9441
9442 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9443 {
9444         if ((res >> 26) != ALC880_HP_EVENT)
9445                 return;
9446         alc262_hp_bpc_automute(codec);
9447 }
9448
9449 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9450 {
9451         struct alc_spec *spec = codec->spec;
9452         unsigned int presence;
9453         presence = snd_hda_codec_read(codec, 0x15, 0,
9454                                       AC_VERB_GET_PIN_SENSE, 0);
9455         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9456         alc262_hp_master_update(codec);
9457 }
9458
9459 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9460                                            unsigned int res)
9461 {
9462         if ((res >> 26) != ALC880_HP_EVENT)
9463                 return;
9464         alc262_hp_wildwest_automute(codec);
9465 }
9466
9467 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9468                                    struct snd_ctl_elem_value *ucontrol)
9469 {
9470         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9471         struct alc_spec *spec = codec->spec;
9472         *ucontrol->value.integer.value = spec->master_sw;
9473         return 0;
9474 }
9475
9476 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9477                                    struct snd_ctl_elem_value *ucontrol)
9478 {
9479         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9480         struct alc_spec *spec = codec->spec;
9481         int val = !!*ucontrol->value.integer.value;
9482
9483         if (val == spec->master_sw)
9484                 return 0;
9485         spec->master_sw = val;
9486         alc262_hp_master_update(codec);
9487         return 1;
9488 }
9489
9490 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9491         {
9492                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9493                 .name = "Master Playback Switch",
9494                 .info = snd_ctl_boolean_mono_info,
9495                 .get = alc262_hp_master_sw_get,
9496                 .put = alc262_hp_master_sw_put,
9497         },
9498         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9499         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9500         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9501         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9502                               HDA_OUTPUT),
9503         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9504                             HDA_OUTPUT),
9505         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9506         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9507         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9508         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9509         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9510         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9511         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9512         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9513         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9514         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9515         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9516         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9517         { } /* end */
9518 };
9519
9520 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9521         {
9522                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9523                 .name = "Master Playback Switch",
9524                 .info = snd_ctl_boolean_mono_info,
9525                 .get = alc262_hp_master_sw_get,
9526                 .put = alc262_hp_master_sw_put,
9527         },
9528         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9529         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9530         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9531         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9532         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9533                               HDA_OUTPUT),
9534         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9535                             HDA_OUTPUT),
9536         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9537         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9538         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9539         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9540         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9541         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9542         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9543         { } /* end */
9544 };
9545
9546 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9547         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9548         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9549         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9550         { } /* end */
9551 };
9552
9553 /* mute/unmute internal speaker according to the hp jack and mute state */
9554 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9555 {
9556         struct alc_spec *spec = codec->spec;
9557
9558         if (force || !spec->sense_updated) {
9559                 unsigned int present;
9560                 present = snd_hda_codec_read(codec, 0x15, 0,
9561                                              AC_VERB_GET_PIN_SENSE, 0);
9562                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9563                 spec->sense_updated = 1;
9564         }
9565         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9566                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9567 }
9568
9569 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9570                                         unsigned int res)
9571 {
9572         if ((res >> 26) != ALC880_HP_EVENT)
9573                 return;
9574         alc262_hp_t5735_automute(codec, 1);
9575 }
9576
9577 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9578 {
9579         alc262_hp_t5735_automute(codec, 1);
9580 }
9581
9582 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9583         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9584         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9585         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9586         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9587         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9588         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9589         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9590         { } /* end */
9591 };
9592
9593 static struct hda_verb alc262_hp_t5735_verbs[] = {
9594         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9595         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9596
9597         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9598         { }
9599 };
9600
9601 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9602         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9603         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9604         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9605         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9606         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9607         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9608         { } /* end */
9609 };
9610
9611 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9612         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9613         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9614         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9615         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9616         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9617         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9618         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9619         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9620         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9621         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9622         {}
9623 };
9624
9625 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9626         .num_items = 1,
9627         .items = {
9628                 { "Line", 0x1 },
9629         },
9630 };
9631
9632 /* bind hp and internal speaker mute (with plug check) */
9633 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9634                                      struct snd_ctl_elem_value *ucontrol)
9635 {
9636         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9637         long *valp = ucontrol->value.integer.value;
9638         int change;
9639
9640         /* change hp mute */
9641         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9642                                           HDA_AMP_MUTE,
9643                                           valp[0] ? 0 : HDA_AMP_MUTE);
9644         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9645                                            HDA_AMP_MUTE,
9646                                            valp[1] ? 0 : HDA_AMP_MUTE);
9647         if (change) {
9648                 /* change speaker according to HP jack state */
9649                 struct alc_spec *spec = codec->spec;
9650                 unsigned int mute;
9651                 if (spec->jack_present)
9652                         mute = HDA_AMP_MUTE;
9653                 else
9654                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9655                                                       HDA_OUTPUT, 0);
9656                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9657                                          HDA_AMP_MUTE, mute);
9658         }
9659         return change;
9660 }
9661
9662 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9663         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9664         {
9665                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9666                 .name = "Master Playback Switch",
9667                 .info = snd_hda_mixer_amp_switch_info,
9668                 .get = snd_hda_mixer_amp_switch_get,
9669                 .put = alc262_sony_master_sw_put,
9670                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9671         },
9672         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9673         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9674         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9675         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9676         { } /* end */
9677 };
9678
9679 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9680         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9681         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9682         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9683         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9684         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9685         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9686         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9687         { } /* end */
9688 };
9689
9690 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9691         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9692         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9693         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9694         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9695         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9696         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9697         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9698         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9699         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9700         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9701         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9702         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9703         { } /* end */
9704 };
9705
9706 static struct hda_verb alc262_tyan_verbs[] = {
9707         /* Headphone automute */
9708         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9709         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9710         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9711
9712         /* P11 AUX_IN, white 4-pin connector */
9713         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9714         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9715         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9716         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9717
9718         {}
9719 };
9720
9721 /* unsolicited event for HP jack sensing */
9722 static void alc262_tyan_automute(struct hda_codec *codec)
9723 {
9724         unsigned int mute;
9725         unsigned int present;
9726
9727         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9728         present = snd_hda_codec_read(codec, 0x1b, 0,
9729                                      AC_VERB_GET_PIN_SENSE, 0);
9730         present = (present & 0x80000000) != 0;
9731         if (present) {
9732                 /* mute line output on ATX panel */
9733                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9734                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9735         } else {
9736                 /* unmute line output if necessary */
9737                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9738                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9739                                          HDA_AMP_MUTE, mute);
9740         }
9741 }
9742
9743 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9744                                        unsigned int res)
9745 {
9746         if ((res >> 26) != ALC880_HP_EVENT)
9747                 return;
9748         alc262_tyan_automute(codec);
9749 }
9750
9751 #define alc262_capture_mixer            alc882_capture_mixer
9752 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9753
9754 /*
9755  * generic initialization of ADC, input mixers and output mixers
9756  */
9757 static struct hda_verb alc262_init_verbs[] = {
9758         /*
9759          * Unmute ADC0-2 and set the default input to mic-in
9760          */
9761         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9762         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9763         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9764         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9765         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9766         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9767
9768         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9769          * mixer widget
9770          * Note: PASD motherboards uses the Line In 2 as the input for
9771          * front panel mic (mic 2)
9772          */
9773         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9774         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9775         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9776         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9777         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9778         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9779
9780         /*
9781          * Set up output mixers (0x0c - 0x0e)
9782          */
9783         /* set vol=0 to output mixers */
9784         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9785         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9786         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9787         /* set up input amps for analog loopback */
9788         /* Amp Indices: DAC = 0, mixer = 1 */
9789         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9790         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9791         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9792         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9793         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9794         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9795
9796         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9797         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9798         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9799         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9800         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9801         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9802
9803         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9804         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9805         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9806         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9807         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9808
9809         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9810         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9811
9812         /* FIXME: use matrix-type input source selection */
9813         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9814         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9815         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9816         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9817         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9818         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9819         /* Input mixer2 */
9820         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9821         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9822         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9823         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9824         /* Input mixer3 */
9825         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9826         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9827         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9828         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9829
9830         { }
9831 };
9832
9833 static struct hda_verb alc262_eapd_verbs[] = {
9834         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9835         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9836         { }
9837 };
9838
9839 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9840         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9841         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9842         {}
9843 };
9844
9845 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9846         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9847         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9848         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9849
9850         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9851         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9852         {}
9853 };
9854
9855 static struct hda_verb alc262_sony_unsol_verbs[] = {
9856         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9857         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9858         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9859
9860         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9861         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9862         {}
9863 };
9864
9865 static struct hda_input_mux alc262_dmic_capture_source = {
9866         .num_items = 2,
9867         .items = {
9868                 { "Int DMic", 0x9 },
9869                 { "Mic", 0x0 },
9870         },
9871 };
9872
9873 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9874         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9875         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9876         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9877         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9878         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9879         { } /* end */
9880 };
9881
9882 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9883         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9884         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9885         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9886         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9887         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9888         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9889         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9890         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9891         {}
9892 };
9893
9894 static void alc262_dmic_automute(struct hda_codec *codec)
9895 {
9896         unsigned int present;
9897
9898         present = snd_hda_codec_read(codec, 0x18, 0,
9899                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9900         snd_hda_codec_write(codec, 0x22, 0,
9901                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9902 }
9903
9904 /* toggle speaker-output according to the hp-jack state */
9905 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9906 {
9907         unsigned int present;
9908         unsigned char bits;
9909
9910         present = snd_hda_codec_read(codec, 0x15, 0,
9911                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9912         bits = present ? 0 : PIN_OUT;
9913         snd_hda_codec_write(codec, 0x14, 0,
9914                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9915 }
9916
9917
9918
9919 /* unsolicited event for HP jack sensing */
9920 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9921                                        unsigned int res)
9922 {
9923         if ((res >> 26) == ALC880_HP_EVENT)
9924                 alc262_toshiba_s06_speaker_automute(codec);
9925         if ((res >> 26) == ALC880_MIC_EVENT)
9926                 alc262_dmic_automute(codec);
9927
9928 }
9929
9930 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9931 {
9932         alc262_toshiba_s06_speaker_automute(codec);
9933         alc262_dmic_automute(codec);
9934 }
9935
9936 /* mute/unmute internal speaker according to the hp jack and mute state */
9937 static void alc262_hippo_automute(struct hda_codec *codec)
9938 {
9939         struct alc_spec *spec = codec->spec;
9940         unsigned int mute;
9941         unsigned int present;
9942
9943         /* need to execute and sync at first */
9944         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9945         present = snd_hda_codec_read(codec, 0x15, 0,
9946                                      AC_VERB_GET_PIN_SENSE, 0);
9947         spec->jack_present = (present & 0x80000000) != 0;
9948         if (spec->jack_present) {
9949                 /* mute internal speaker */
9950                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9951                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9952         } else {
9953                 /* unmute internal speaker if necessary */
9954                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9955                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9956                                          HDA_AMP_MUTE, mute);
9957         }
9958 }
9959
9960 /* unsolicited event for HP jack sensing */
9961 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9962                                        unsigned int res)
9963 {
9964         if ((res >> 26) != ALC880_HP_EVENT)
9965                 return;
9966         alc262_hippo_automute(codec);
9967 }
9968
9969 static void alc262_hippo1_automute(struct hda_codec *codec)
9970 {
9971         unsigned int mute;
9972         unsigned int present;
9973
9974         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9975         present = snd_hda_codec_read(codec, 0x1b, 0,
9976                                      AC_VERB_GET_PIN_SENSE, 0);
9977         present = (present & 0x80000000) != 0;
9978         if (present) {
9979                 /* mute internal speaker */
9980                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9981                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9982         } else {
9983                 /* unmute internal speaker if necessary */
9984                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9985                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9986                                          HDA_AMP_MUTE, mute);
9987         }
9988 }
9989
9990 /* unsolicited event for HP jack sensing */
9991 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9992                                        unsigned int res)
9993 {
9994         if ((res >> 26) != ALC880_HP_EVENT)
9995                 return;
9996         alc262_hippo1_automute(codec);
9997 }
9998
9999 /*
10000  * nec model
10001  *  0x15 = headphone
10002  *  0x16 = internal speaker
10003  *  0x18 = external mic
10004  */
10005
10006 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10007         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10008         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10009
10010         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10011         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10012         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10013
10014         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10015         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10016         { } /* end */
10017 };
10018
10019 static struct hda_verb alc262_nec_verbs[] = {
10020         /* Unmute Speaker */
10021         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10022
10023         /* Headphone */
10024         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10025         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10026
10027         /* External mic to headphone */
10028         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10029         /* External mic to speaker */
10030         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10031         {}
10032 };
10033
10034 /*
10035  * fujitsu model
10036  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10037  *  0x1b = port replicator headphone out
10038  */
10039
10040 #define ALC_HP_EVENT    0x37
10041
10042 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10043         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10044         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10045         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10046         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10047         {}
10048 };
10049
10050 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10051         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10052         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10053         {}
10054 };
10055
10056 static struct hda_input_mux alc262_fujitsu_capture_source = {
10057         .num_items = 3,
10058         .items = {
10059                 { "Mic", 0x0 },
10060                 { "Int Mic", 0x1 },
10061                 { "CD", 0x4 },
10062         },
10063 };
10064
10065 static struct hda_input_mux alc262_HP_capture_source = {
10066         .num_items = 5,
10067         .items = {
10068                 { "Mic", 0x0 },
10069                 { "Front Mic", 0x1 },
10070                 { "Line", 0x2 },
10071                 { "CD", 0x4 },
10072                 { "AUX IN", 0x6 },
10073         },
10074 };
10075
10076 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10077         .num_items = 4,
10078         .items = {
10079                 { "Mic", 0x0 },
10080                 { "Front Mic", 0x2 },
10081                 { "Line", 0x1 },
10082                 { "CD", 0x4 },
10083         },
10084 };
10085
10086 /* mute/unmute internal speaker according to the hp jacks and mute state */
10087 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10088 {
10089         struct alc_spec *spec = codec->spec;
10090         unsigned int mute;
10091
10092         if (force || !spec->sense_updated) {
10093                 unsigned int present;
10094                 /* need to execute and sync at first */
10095                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10096                 /* check laptop HP jack */
10097                 present = snd_hda_codec_read(codec, 0x14, 0,
10098                                              AC_VERB_GET_PIN_SENSE, 0);
10099                 /* need to execute and sync at first */
10100                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10101                 /* check docking HP jack */
10102                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10103                                               AC_VERB_GET_PIN_SENSE, 0);
10104                 if (present & AC_PINSENSE_PRESENCE)
10105                         spec->jack_present = 1;
10106                 else
10107                         spec->jack_present = 0;
10108                 spec->sense_updated = 1;
10109         }
10110         /* unmute internal speaker only if both HPs are unplugged and
10111          * master switch is on
10112          */
10113         if (spec->jack_present)
10114                 mute = HDA_AMP_MUTE;
10115         else
10116                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10117         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10118                                  HDA_AMP_MUTE, mute);
10119 }
10120
10121 /* unsolicited event for HP jack sensing */
10122 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10123                                        unsigned int res)
10124 {
10125         if ((res >> 26) != ALC_HP_EVENT)
10126                 return;
10127         alc262_fujitsu_automute(codec, 1);
10128 }
10129
10130 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10131 {
10132         alc262_fujitsu_automute(codec, 1);
10133 }
10134
10135 /* bind volumes of both NID 0x0c and 0x0d */
10136 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10137         .ops = &snd_hda_bind_vol,
10138         .values = {
10139                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10140                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10141                 0
10142         },
10143 };
10144
10145 /* mute/unmute internal speaker according to the hp jack and mute state */
10146 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10147 {
10148         struct alc_spec *spec = codec->spec;
10149         unsigned int mute;
10150
10151         if (force || !spec->sense_updated) {
10152                 unsigned int present_int_hp;
10153                 /* need to execute and sync at first */
10154                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10155                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10156                                         AC_VERB_GET_PIN_SENSE, 0);
10157                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10158                 spec->sense_updated = 1;
10159         }
10160         if (spec->jack_present) {
10161                 /* mute internal speaker */
10162                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10163                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10164                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10165                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10166         } else {
10167                 /* unmute internal speaker if necessary */
10168                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10169                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10170                                          HDA_AMP_MUTE, mute);
10171                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10172                                          HDA_AMP_MUTE, mute);
10173         }
10174 }
10175
10176 /* unsolicited event for HP jack sensing */
10177 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10178                                        unsigned int res)
10179 {
10180         if ((res >> 26) != ALC_HP_EVENT)
10181                 return;
10182         alc262_lenovo_3000_automute(codec, 1);
10183 }
10184
10185 /* bind hp and internal speaker mute (with plug check) */
10186 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10187                                          struct snd_ctl_elem_value *ucontrol)
10188 {
10189         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10190         long *valp = ucontrol->value.integer.value;
10191         int change;
10192
10193         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10194                                                  HDA_AMP_MUTE,
10195                                                  valp ? 0 : HDA_AMP_MUTE);
10196         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10197                                                  HDA_AMP_MUTE,
10198                                                  valp ? 0 : HDA_AMP_MUTE);
10199
10200         if (change)
10201                 alc262_fujitsu_automute(codec, 0);
10202         return change;
10203 }
10204
10205 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10206         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10207         {
10208                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10209                 .name = "Master Playback Switch",
10210                 .info = snd_hda_mixer_amp_switch_info,
10211                 .get = snd_hda_mixer_amp_switch_get,
10212                 .put = alc262_fujitsu_master_sw_put,
10213                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10214         },
10215         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10216         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10217         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10218         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10219         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10220         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10221         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10222         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10223         { } /* end */
10224 };
10225
10226 /* bind hp and internal speaker mute (with plug check) */
10227 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10228                                          struct snd_ctl_elem_value *ucontrol)
10229 {
10230         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10231         long *valp = ucontrol->value.integer.value;
10232         int change;
10233
10234         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10235                                                  HDA_AMP_MUTE,
10236                                                  valp ? 0 : HDA_AMP_MUTE);
10237
10238         if (change)
10239                 alc262_lenovo_3000_automute(codec, 0);
10240         return change;
10241 }
10242
10243 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10244         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10245         {
10246                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10247                 .name = "Master Playback Switch",
10248                 .info = snd_hda_mixer_amp_switch_info,
10249                 .get = snd_hda_mixer_amp_switch_get,
10250                 .put = alc262_lenovo_3000_master_sw_put,
10251                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10252         },
10253         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10254         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10255         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10256         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10257         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10258         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10259         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10260         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10261         { } /* end */
10262 };
10263
10264 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10265         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10266         {
10267                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10268                 .name = "Master Playback Switch",
10269                 .info = snd_hda_mixer_amp_switch_info,
10270                 .get = snd_hda_mixer_amp_switch_get,
10271                 .put = alc262_sony_master_sw_put,
10272                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10273         },
10274         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10275         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10276         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10277         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10278         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10279         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10280         { } /* end */
10281 };
10282
10283 /* additional init verbs for Benq laptops */
10284 static struct hda_verb alc262_EAPD_verbs[] = {
10285         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10286         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10287         {}
10288 };
10289
10290 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10291         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10292         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10293
10294         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10295         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10296         {}
10297 };
10298
10299 /* Samsung Q1 Ultra Vista model setup */
10300 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10301         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10302         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10303         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10304         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10305         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10306         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10307         { } /* end */
10308 };
10309
10310 static struct hda_verb alc262_ultra_verbs[] = {
10311         /* output mixer */
10312         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10313         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10314         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10315         /* speaker */
10316         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10317         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10318         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10319         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10320         /* HP */
10321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10323         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10324         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10325         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10326         /* internal mic */
10327         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10328         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10329         /* ADC, choose mic */
10330         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10331         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10332         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10333         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10334         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10335         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10336         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10337         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10338         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10339         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10340         {}
10341 };
10342
10343 /* mute/unmute internal speaker according to the hp jack and mute state */
10344 static void alc262_ultra_automute(struct hda_codec *codec)
10345 {
10346         struct alc_spec *spec = codec->spec;
10347         unsigned int mute;
10348
10349         mute = 0;
10350         /* auto-mute only when HP is used as HP */
10351         if (!spec->cur_mux[0]) {
10352                 unsigned int present;
10353                 /* need to execute and sync at first */
10354                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10355                 present = snd_hda_codec_read(codec, 0x15, 0,
10356                                              AC_VERB_GET_PIN_SENSE, 0);
10357                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10358                 if (spec->jack_present)
10359                         mute = HDA_AMP_MUTE;
10360         }
10361         /* mute/unmute internal speaker */
10362         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10363                                  HDA_AMP_MUTE, mute);
10364         /* mute/unmute HP */
10365         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10366                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10367 }
10368
10369 /* unsolicited event for HP jack sensing */
10370 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10371                                        unsigned int res)
10372 {
10373         if ((res >> 26) != ALC880_HP_EVENT)
10374                 return;
10375         alc262_ultra_automute(codec);
10376 }
10377
10378 static struct hda_input_mux alc262_ultra_capture_source = {
10379         .num_items = 2,
10380         .items = {
10381                 { "Mic", 0x1 },
10382                 { "Headphone", 0x7 },
10383         },
10384 };
10385
10386 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10387                                      struct snd_ctl_elem_value *ucontrol)
10388 {
10389         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10390         struct alc_spec *spec = codec->spec;
10391         int ret;
10392
10393         ret = alc_mux_enum_put(kcontrol, ucontrol);
10394         if (!ret)
10395                 return 0;
10396         /* reprogram the HP pin as mic or HP according to the input source */
10397         snd_hda_codec_write_cache(codec, 0x15, 0,
10398                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10399                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10400         alc262_ultra_automute(codec); /* mute/unmute HP */
10401         return ret;
10402 }
10403
10404 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10405         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10406         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10407         {
10408                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10409                 .name = "Capture Source",
10410                 .info = alc_mux_enum_info,
10411                 .get = alc_mux_enum_get,
10412                 .put = alc262_ultra_mux_enum_put,
10413         },
10414         { } /* end */
10415 };
10416
10417 /* add playback controls from the parsed DAC table */
10418 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10419                                              const struct auto_pin_cfg *cfg)
10420 {
10421         hda_nid_t nid;
10422         int err;
10423
10424         spec->multiout.num_dacs = 1;    /* only use one dac */
10425         spec->multiout.dac_nids = spec->private_dac_nids;
10426         spec->multiout.dac_nids[0] = 2;
10427
10428         nid = cfg->line_out_pins[0];
10429         if (nid) {
10430                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10431                                   "Front Playback Volume",
10432                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10433                 if (err < 0)
10434                         return err;
10435                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10436                                   "Front Playback Switch",
10437                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10438                 if (err < 0)
10439                         return err;
10440         }
10441
10442         nid = cfg->speaker_pins[0];
10443         if (nid) {
10444                 if (nid == 0x16) {
10445                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10446                                           "Speaker Playback Volume",
10447                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10448                                                               HDA_OUTPUT));
10449                         if (err < 0)
10450                                 return err;
10451                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10452                                           "Speaker Playback Switch",
10453                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10454                                                               HDA_OUTPUT));
10455                         if (err < 0)
10456                                 return err;
10457                 } else {
10458                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10459                                           "Speaker Playback Switch",
10460                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10461                                                               HDA_OUTPUT));
10462                         if (err < 0)
10463                                 return err;
10464                 }
10465         }
10466         nid = cfg->hp_pins[0];
10467         if (nid) {
10468                 /* spec->multiout.hp_nid = 2; */
10469                 if (nid == 0x16) {
10470                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10471                                           "Headphone Playback Volume",
10472                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10473                                                               HDA_OUTPUT));
10474                         if (err < 0)
10475                                 return err;
10476                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10477                                           "Headphone Playback Switch",
10478                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10479                                                               HDA_OUTPUT));
10480                         if (err < 0)
10481                                 return err;
10482                 } else {
10483                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10484                                           "Headphone Playback Switch",
10485                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10486                                                               HDA_OUTPUT));
10487                         if (err < 0)
10488                                 return err;
10489                 }
10490         }
10491         return 0;
10492 }
10493
10494 /* identical with ALC880 */
10495 #define alc262_auto_create_analog_input_ctls \
10496         alc880_auto_create_analog_input_ctls
10497
10498 /*
10499  * generic initialization of ADC, input mixers and output mixers
10500  */
10501 static struct hda_verb alc262_volume_init_verbs[] = {
10502         /*
10503          * Unmute ADC0-2 and set the default input to mic-in
10504          */
10505         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10506         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10507         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10508         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10509         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10510         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10511
10512         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10513          * mixer widget
10514          * Note: PASD motherboards uses the Line In 2 as the input for
10515          * front panel mic (mic 2)
10516          */
10517         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10518         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10519         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10520         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10521         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10522         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10523
10524         /*
10525          * Set up output mixers (0x0c - 0x0f)
10526          */
10527         /* set vol=0 to output mixers */
10528         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10529         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10530         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10531
10532         /* set up input amps for analog loopback */
10533         /* Amp Indices: DAC = 0, mixer = 1 */
10534         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10535         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10536         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10537         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10538         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10539         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10540
10541         /* FIXME: use matrix-type input source selection */
10542         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10543         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10544         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10545         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10546         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10547         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10548         /* Input mixer2 */
10549         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10550         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10551         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10552         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10553         /* Input mixer3 */
10554         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10555         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10556         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10557         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10558
10559         { }
10560 };
10561
10562 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10563         /*
10564          * Unmute ADC0-2 and set the default input to mic-in
10565          */
10566         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10567         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10568         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10569         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10570         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10571         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10572
10573         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10574          * mixer widget
10575          * Note: PASD motherboards uses the Line In 2 as the input for
10576          * front panel mic (mic 2)
10577          */
10578         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10579         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10580         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10581         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10582         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10583         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10584         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10585         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10586
10587         /*
10588          * Set up output mixers (0x0c - 0x0e)
10589          */
10590         /* set vol=0 to output mixers */
10591         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10592         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10593         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10594
10595         /* set up input amps for analog loopback */
10596         /* Amp Indices: DAC = 0, mixer = 1 */
10597         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10599         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10600         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10601         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10602         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10603
10604         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10605         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10606         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10607
10608         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10609         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10610
10611         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10612         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10613
10614         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10615         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10616         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10617         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10618         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10619
10620         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10621         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10622         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10623         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10624         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10625         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10626
10627
10628         /* FIXME: use matrix-type input source selection */
10629         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10630         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10631         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10632         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10633         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10634         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10635         /* Input mixer2 */
10636         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10637         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10638         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10639         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10640         /* Input mixer3 */
10641         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10642         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10643         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10644         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10645
10646         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10647
10648         { }
10649 };
10650
10651 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10652         /*
10653          * Unmute ADC0-2 and set the default input to mic-in
10654          */
10655         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10656         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10657         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10658         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10659         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10660         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10661
10662         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10663          * mixer widget
10664          * Note: PASD motherboards uses the Line In 2 as the input for front
10665          * panel mic (mic 2)
10666          */
10667         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10668         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10669         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10670         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10671         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10672         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10673         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10674         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10675         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10676         /*
10677          * Set up output mixers (0x0c - 0x0e)
10678          */
10679         /* set vol=0 to output mixers */
10680         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10681         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10682         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10683
10684         /* set up input amps for analog loopback */
10685         /* Amp Indices: DAC = 0, mixer = 1 */
10686         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10687         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10688         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10689         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10690         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10691         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10692
10693
10694         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10695         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10696         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10697         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10698         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10699         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10700         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10701
10702         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10703         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10704
10705         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10706         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10707
10708         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10709         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10710         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10711         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10712         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10713         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10714
10715         /* FIXME: use matrix-type input source selection */
10716         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10717         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10718         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10719         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10720         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10721         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10722         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10723         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10724         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10725         /* Input mixer2 */
10726         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10727         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10728         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10729         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10730         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10731         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10732         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10733         /* Input mixer3 */
10734         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10735         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10736         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10737         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10738         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10739         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10740         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10741
10742         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10743
10744         { }
10745 };
10746
10747 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10748
10749         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10750         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10751         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10752
10753         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10754         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10755         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10756         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10757
10758         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10759         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10760         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10761         {}
10762 };
10763
10764
10765 #ifdef CONFIG_SND_HDA_POWER_SAVE
10766 #define alc262_loopbacks        alc880_loopbacks
10767 #endif
10768
10769 /* pcm configuration: identiacal with ALC880 */
10770 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10771 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10772 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10773 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10774
10775 /*
10776  * BIOS auto configuration
10777  */
10778 static int alc262_parse_auto_config(struct hda_codec *codec)
10779 {
10780         struct alc_spec *spec = codec->spec;
10781         int err;
10782         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10783
10784         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10785                                            alc262_ignore);
10786         if (err < 0)
10787                 return err;
10788         if (!spec->autocfg.line_outs) {
10789                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10790                         spec->multiout.max_channels = 2;
10791                         spec->no_analog = 1;
10792                         goto dig_only;
10793                 }
10794                 return 0; /* can't find valid BIOS pin config */
10795         }
10796         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10797         if (err < 0)
10798                 return err;
10799         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10800         if (err < 0)
10801                 return err;
10802
10803         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10804
10805  dig_only:
10806         if (spec->autocfg.dig_outs) {
10807                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10808                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10809         }
10810         if (spec->autocfg.dig_in_pin)
10811                 spec->dig_in_nid = ALC262_DIGIN_NID;
10812
10813         if (spec->kctls.list)
10814                 add_mixer(spec, spec->kctls.list);
10815
10816         add_verb(spec, alc262_volume_init_verbs);
10817         spec->num_mux_defs = 1;
10818         spec->input_mux = &spec->private_imux[0];
10819
10820         err = alc_auto_add_mic_boost(codec);
10821         if (err < 0)
10822                 return err;
10823
10824         store_pin_configs(codec);
10825         return 1;
10826 }
10827
10828 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10829 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10830 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10831 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10832
10833
10834 /* init callback for auto-configuration model -- overriding the default init */
10835 static void alc262_auto_init(struct hda_codec *codec)
10836 {
10837         struct alc_spec *spec = codec->spec;
10838         alc262_auto_init_multi_out(codec);
10839         alc262_auto_init_hp_out(codec);
10840         alc262_auto_init_analog_input(codec);
10841         alc262_auto_init_input_src(codec);
10842         if (spec->unsol_event)
10843                 alc_inithook(codec);
10844 }
10845
10846 /*
10847  * configuration and preset
10848  */
10849 static const char *alc262_models[ALC262_MODEL_LAST] = {
10850         [ALC262_BASIC]          = "basic",
10851         [ALC262_HIPPO]          = "hippo",
10852         [ALC262_HIPPO_1]        = "hippo_1",
10853         [ALC262_FUJITSU]        = "fujitsu",
10854         [ALC262_HP_BPC]         = "hp-bpc",
10855         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10856         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10857         [ALC262_HP_RP5700]      = "hp-rp5700",
10858         [ALC262_BENQ_ED8]       = "benq",
10859         [ALC262_BENQ_T31]       = "benq-t31",
10860         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10861         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10862         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10863         [ALC262_ULTRA]          = "ultra",
10864         [ALC262_LENOVO_3000]    = "lenovo-3000",
10865         [ALC262_NEC]            = "nec",
10866         [ALC262_TYAN]           = "tyan",
10867         [ALC262_AUTO]           = "auto",
10868 };
10869
10870 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10871         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10872         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10873         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10874                            ALC262_HP_BPC),
10875         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10876                            ALC262_HP_BPC),
10877         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10878         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10879         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10880         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10881         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10882         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10883         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10884         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10885         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10886         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10887         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10888         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10889                       ALC262_HP_TC_T5735),
10890         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10891         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10892         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10893         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10894         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10895         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10896         SND_PCI_QUIRK(0x104d, 0x9033, "Sony VAIO VGN-SR19XN",
10897                       ALC262_SONY_ASSAMD),
10898         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10899                       ALC262_TOSHIBA_RX1),
10900         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10901         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10902         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10903         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10904         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10905                            ALC262_ULTRA),
10906         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10907         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10908         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10909         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10910         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10911         {}
10912 };
10913
10914 static struct alc_config_preset alc262_presets[] = {
10915         [ALC262_BASIC] = {
10916                 .mixers = { alc262_base_mixer },
10917                 .init_verbs = { alc262_init_verbs },
10918                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10919                 .dac_nids = alc262_dac_nids,
10920                 .hp_nid = 0x03,
10921                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10922                 .channel_mode = alc262_modes,
10923                 .input_mux = &alc262_capture_source,
10924         },
10925         [ALC262_HIPPO] = {
10926                 .mixers = { alc262_base_mixer },
10927                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10928                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10929                 .dac_nids = alc262_dac_nids,
10930                 .hp_nid = 0x03,
10931                 .dig_out_nid = ALC262_DIGOUT_NID,
10932                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10933                 .channel_mode = alc262_modes,
10934                 .input_mux = &alc262_capture_source,
10935                 .unsol_event = alc262_hippo_unsol_event,
10936                 .init_hook = alc262_hippo_automute,
10937         },
10938         [ALC262_HIPPO_1] = {
10939                 .mixers = { alc262_hippo1_mixer },
10940                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10941                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10942                 .dac_nids = alc262_dac_nids,
10943                 .hp_nid = 0x02,
10944                 .dig_out_nid = ALC262_DIGOUT_NID,
10945                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10946                 .channel_mode = alc262_modes,
10947                 .input_mux = &alc262_capture_source,
10948                 .unsol_event = alc262_hippo1_unsol_event,
10949                 .init_hook = alc262_hippo1_automute,
10950         },
10951         [ALC262_FUJITSU] = {
10952                 .mixers = { alc262_fujitsu_mixer },
10953                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10954                                 alc262_fujitsu_unsol_verbs },
10955                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10956                 .dac_nids = alc262_dac_nids,
10957                 .hp_nid = 0x03,
10958                 .dig_out_nid = ALC262_DIGOUT_NID,
10959                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10960                 .channel_mode = alc262_modes,
10961                 .input_mux = &alc262_fujitsu_capture_source,
10962                 .unsol_event = alc262_fujitsu_unsol_event,
10963                 .init_hook = alc262_fujitsu_init_hook,
10964         },
10965         [ALC262_HP_BPC] = {
10966                 .mixers = { alc262_HP_BPC_mixer },
10967                 .init_verbs = { alc262_HP_BPC_init_verbs },
10968                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10969                 .dac_nids = alc262_dac_nids,
10970                 .hp_nid = 0x03,
10971                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10972                 .channel_mode = alc262_modes,
10973                 .input_mux = &alc262_HP_capture_source,
10974                 .unsol_event = alc262_hp_bpc_unsol_event,
10975                 .init_hook = alc262_hp_bpc_automute,
10976         },
10977         [ALC262_HP_BPC_D7000_WF] = {
10978                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10979                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10980                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10981                 .dac_nids = alc262_dac_nids,
10982                 .hp_nid = 0x03,
10983                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10984                 .channel_mode = alc262_modes,
10985                 .input_mux = &alc262_HP_D7000_capture_source,
10986                 .unsol_event = alc262_hp_wildwest_unsol_event,
10987                 .init_hook = alc262_hp_wildwest_automute,
10988         },
10989         [ALC262_HP_BPC_D7000_WL] = {
10990                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10991                             alc262_HP_BPC_WildWest_option_mixer },
10992                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10993                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10994                 .dac_nids = alc262_dac_nids,
10995                 .hp_nid = 0x03,
10996                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10997                 .channel_mode = alc262_modes,
10998                 .input_mux = &alc262_HP_D7000_capture_source,
10999                 .unsol_event = alc262_hp_wildwest_unsol_event,
11000                 .init_hook = alc262_hp_wildwest_automute,
11001         },
11002         [ALC262_HP_TC_T5735] = {
11003                 .mixers = { alc262_hp_t5735_mixer },
11004                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11005                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11006                 .dac_nids = alc262_dac_nids,
11007                 .hp_nid = 0x03,
11008                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11009                 .channel_mode = alc262_modes,
11010                 .input_mux = &alc262_capture_source,
11011                 .unsol_event = alc262_hp_t5735_unsol_event,
11012                 .init_hook = alc262_hp_t5735_init_hook,
11013         },
11014         [ALC262_HP_RP5700] = {
11015                 .mixers = { alc262_hp_rp5700_mixer },
11016                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11017                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11018                 .dac_nids = alc262_dac_nids,
11019                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11020                 .channel_mode = alc262_modes,
11021                 .input_mux = &alc262_hp_rp5700_capture_source,
11022         },
11023         [ALC262_BENQ_ED8] = {
11024                 .mixers = { alc262_base_mixer },
11025                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11026                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11027                 .dac_nids = alc262_dac_nids,
11028                 .hp_nid = 0x03,
11029                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11030                 .channel_mode = alc262_modes,
11031                 .input_mux = &alc262_capture_source,
11032         },
11033         [ALC262_SONY_ASSAMD] = {
11034                 .mixers = { alc262_sony_mixer },
11035                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11036                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11037                 .dac_nids = alc262_dac_nids,
11038                 .hp_nid = 0x02,
11039                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11040                 .channel_mode = alc262_modes,
11041                 .input_mux = &alc262_capture_source,
11042                 .unsol_event = alc262_hippo_unsol_event,
11043                 .init_hook = alc262_hippo_automute,
11044         },
11045         [ALC262_BENQ_T31] = {
11046                 .mixers = { alc262_benq_t31_mixer },
11047                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11048                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11049                 .dac_nids = alc262_dac_nids,
11050                 .hp_nid = 0x03,
11051                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11052                 .channel_mode = alc262_modes,
11053                 .input_mux = &alc262_capture_source,
11054                 .unsol_event = alc262_hippo_unsol_event,
11055                 .init_hook = alc262_hippo_automute,
11056         },
11057         [ALC262_ULTRA] = {
11058                 .mixers = { alc262_ultra_mixer },
11059                 .cap_mixer = alc262_ultra_capture_mixer,
11060                 .init_verbs = { alc262_ultra_verbs },
11061                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11062                 .dac_nids = alc262_dac_nids,
11063                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11064                 .channel_mode = alc262_modes,
11065                 .input_mux = &alc262_ultra_capture_source,
11066                 .adc_nids = alc262_adc_nids, /* ADC0 */
11067                 .capsrc_nids = alc262_capsrc_nids,
11068                 .num_adc_nids = 1, /* single ADC */
11069                 .unsol_event = alc262_ultra_unsol_event,
11070                 .init_hook = alc262_ultra_automute,
11071         },
11072         [ALC262_LENOVO_3000] = {
11073                 .mixers = { alc262_lenovo_3000_mixer },
11074                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11075                                 alc262_lenovo_3000_unsol_verbs },
11076                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11077                 .dac_nids = alc262_dac_nids,
11078                 .hp_nid = 0x03,
11079                 .dig_out_nid = ALC262_DIGOUT_NID,
11080                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11081                 .channel_mode = alc262_modes,
11082                 .input_mux = &alc262_fujitsu_capture_source,
11083                 .unsol_event = alc262_lenovo_3000_unsol_event,
11084         },
11085         [ALC262_NEC] = {
11086                 .mixers = { alc262_nec_mixer },
11087                 .init_verbs = { alc262_nec_verbs },
11088                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11089                 .dac_nids = alc262_dac_nids,
11090                 .hp_nid = 0x03,
11091                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11092                 .channel_mode = alc262_modes,
11093                 .input_mux = &alc262_capture_source,
11094         },
11095         [ALC262_TOSHIBA_S06] = {
11096                 .mixers = { alc262_toshiba_s06_mixer },
11097                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11098                                                         alc262_eapd_verbs },
11099                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11100                 .capsrc_nids = alc262_dmic_capsrc_nids,
11101                 .dac_nids = alc262_dac_nids,
11102                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11103                 .dig_out_nid = ALC262_DIGOUT_NID,
11104                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11105                 .channel_mode = alc262_modes,
11106                 .input_mux = &alc262_dmic_capture_source,
11107                 .unsol_event = alc262_toshiba_s06_unsol_event,
11108                 .init_hook = alc262_toshiba_s06_init_hook,
11109         },
11110         [ALC262_TOSHIBA_RX1] = {
11111                 .mixers = { alc262_toshiba_rx1_mixer },
11112                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11113                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11114                 .dac_nids = alc262_dac_nids,
11115                 .hp_nid = 0x03,
11116                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11117                 .channel_mode = alc262_modes,
11118                 .input_mux = &alc262_capture_source,
11119                 .unsol_event = alc262_hippo_unsol_event,
11120                 .init_hook = alc262_hippo_automute,
11121         },
11122         [ALC262_TYAN] = {
11123                 .mixers = { alc262_tyan_mixer },
11124                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11125                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11126                 .dac_nids = alc262_dac_nids,
11127                 .hp_nid = 0x02,
11128                 .dig_out_nid = ALC262_DIGOUT_NID,
11129                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11130                 .channel_mode = alc262_modes,
11131                 .input_mux = &alc262_capture_source,
11132                 .unsol_event = alc262_tyan_unsol_event,
11133                 .init_hook = alc262_tyan_automute,
11134         },
11135 };
11136
11137 static int patch_alc262(struct hda_codec *codec)
11138 {
11139         struct alc_spec *spec;
11140         int board_config;
11141         int err;
11142
11143         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11144         if (spec == NULL)
11145                 return -ENOMEM;
11146
11147         codec->spec = spec;
11148 #if 0
11149         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11150          * under-run
11151          */
11152         {
11153         int tmp;
11154         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11155         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11156         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11157         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11158         }
11159 #endif
11160
11161         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11162
11163         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11164                                                   alc262_models,
11165                                                   alc262_cfg_tbl);
11166
11167         if (board_config < 0) {
11168                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
11169                        "trying auto-probe from BIOS...\n");
11170                 board_config = ALC262_AUTO;
11171         }
11172
11173         if (board_config == ALC262_AUTO) {
11174                 /* automatic parse from the BIOS config */
11175                 err = alc262_parse_auto_config(codec);
11176                 if (err < 0) {
11177                         alc_free(codec);
11178                         return err;
11179                 } else if (!err) {
11180                         printk(KERN_INFO
11181                                "hda_codec: Cannot set up configuration "
11182                                "from BIOS.  Using base mode...\n");
11183                         board_config = ALC262_BASIC;
11184                 }
11185         }
11186
11187         if (!spec->no_analog) {
11188                 err = snd_hda_attach_beep_device(codec, 0x1);
11189                 if (err < 0) {
11190                         alc_free(codec);
11191                         return err;
11192                 }
11193         }
11194
11195         if (board_config != ALC262_AUTO)
11196                 setup_preset(spec, &alc262_presets[board_config]);
11197
11198         spec->stream_name_analog = "ALC262 Analog";
11199         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11200         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11201
11202         spec->stream_name_digital = "ALC262 Digital";
11203         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11204         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11205
11206         spec->capture_style = CAPT_MIX;
11207         if (!spec->adc_nids && spec->input_mux) {
11208                 /* check whether NID 0x07 is valid */
11209                 unsigned int wcap = get_wcaps(codec, 0x07);
11210
11211                 /* get type */
11212                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11213                 if (wcap != AC_WID_AUD_IN) {
11214                         spec->adc_nids = alc262_adc_nids_alt;
11215                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11216                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11217                 } else {
11218                         spec->adc_nids = alc262_adc_nids;
11219                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11220                         spec->capsrc_nids = alc262_capsrc_nids;
11221                 }
11222         }
11223         if (!spec->cap_mixer && !spec->no_analog)
11224                 set_capture_mixer(spec);
11225         if (!spec->no_analog)
11226                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11227
11228         spec->vmaster_nid = 0x0c;
11229
11230         codec->patch_ops = alc_patch_ops;
11231         if (board_config == ALC262_AUTO)
11232                 spec->init_hook = alc262_auto_init;
11233 #ifdef CONFIG_SND_HDA_POWER_SAVE
11234         if (!spec->loopback.amplist)
11235                 spec->loopback.amplist = alc262_loopbacks;
11236 #endif
11237         codec->proc_widget_hook = print_realtek_coef;
11238
11239         return 0;
11240 }
11241
11242 /*
11243  *  ALC268 channel source setting (2 channel)
11244  */
11245 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11246 #define alc268_modes            alc260_modes
11247
11248 static hda_nid_t alc268_dac_nids[2] = {
11249         /* front, hp */
11250         0x02, 0x03
11251 };
11252
11253 static hda_nid_t alc268_adc_nids[2] = {
11254         /* ADC0-1 */
11255         0x08, 0x07
11256 };
11257
11258 static hda_nid_t alc268_adc_nids_alt[1] = {
11259         /* ADC0 */
11260         0x08
11261 };
11262
11263 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11264
11265 static struct snd_kcontrol_new alc268_base_mixer[] = {
11266         /* output mixer control */
11267         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11268         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11269         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11270         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11271         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11272         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11273         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11274         { }
11275 };
11276
11277 /* bind Beep switches of both NID 0x0f and 0x10 */
11278 static struct hda_bind_ctls alc268_bind_beep_sw = {
11279         .ops = &snd_hda_bind_sw,
11280         .values = {
11281                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11282                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11283                 0
11284         },
11285 };
11286
11287 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11288         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11289         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11290         { }
11291 };
11292
11293 static struct hda_verb alc268_eapd_verbs[] = {
11294         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11295         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11296         { }
11297 };
11298
11299 /* Toshiba specific */
11300 #define alc268_toshiba_automute alc262_hippo_automute
11301
11302 static struct hda_verb alc268_toshiba_verbs[] = {
11303         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11304         { } /* end */
11305 };
11306
11307 static struct hda_input_mux alc268_acer_lc_capture_source = {
11308         .num_items = 2,
11309         .items = {
11310                 { "i-Mic", 0x6 },
11311                 { "E-Mic", 0x0 },
11312         },
11313 };
11314
11315 /* Acer specific */
11316 /* bind volumes of both NID 0x02 and 0x03 */
11317 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11318         .ops = &snd_hda_bind_vol,
11319         .values = {
11320                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11321                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11322                 0
11323         },
11324 };
11325
11326 /* mute/unmute internal speaker according to the hp jack and mute state */
11327 static void alc268_acer_automute(struct hda_codec *codec, int force)
11328 {
11329         struct alc_spec *spec = codec->spec;
11330         unsigned int mute;
11331
11332         if (force || !spec->sense_updated) {
11333                 unsigned int present;
11334                 present = snd_hda_codec_read(codec, 0x14, 0,
11335                                          AC_VERB_GET_PIN_SENSE, 0);
11336                 spec->jack_present = (present & 0x80000000) != 0;
11337                 spec->sense_updated = 1;
11338         }
11339         if (spec->jack_present)
11340                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11341         else /* unmute internal speaker if necessary */
11342                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11343         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11344                                  HDA_AMP_MUTE, mute);
11345 }
11346
11347
11348 /* bind hp and internal speaker mute (with plug check) */
11349 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11350                                      struct snd_ctl_elem_value *ucontrol)
11351 {
11352         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11353         long *valp = ucontrol->value.integer.value;
11354         int change;
11355
11356         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11357                                           HDA_AMP_MUTE,
11358                                           valp[0] ? 0 : HDA_AMP_MUTE);
11359         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11360                                            HDA_AMP_MUTE,
11361                                            valp[1] ? 0 : HDA_AMP_MUTE);
11362         if (change)
11363                 alc268_acer_automute(codec, 0);
11364         return change;
11365 }
11366
11367 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11368         /* output mixer control */
11369         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11370         {
11371                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11372                 .name = "Master Playback Switch",
11373                 .info = snd_hda_mixer_amp_switch_info,
11374                 .get = snd_hda_mixer_amp_switch_get,
11375                 .put = alc268_acer_master_sw_put,
11376                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11377         },
11378         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11379         { }
11380 };
11381
11382 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11383         /* output mixer control */
11384         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11385         {
11386                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11387                 .name = "Master Playback Switch",
11388                 .info = snd_hda_mixer_amp_switch_info,
11389                 .get = snd_hda_mixer_amp_switch_get,
11390                 .put = alc268_acer_master_sw_put,
11391                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11392         },
11393         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11394         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11395         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11396         { }
11397 };
11398
11399 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11400         /* output mixer control */
11401         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11402         {
11403                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11404                 .name = "Master Playback Switch",
11405                 .info = snd_hda_mixer_amp_switch_info,
11406                 .get = snd_hda_mixer_amp_switch_get,
11407                 .put = alc268_acer_master_sw_put,
11408                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11409         },
11410         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11411         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11412         { }
11413 };
11414
11415 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11416         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11417         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11418         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11419         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11420         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11421         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11422         { }
11423 };
11424
11425 static struct hda_verb alc268_acer_verbs[] = {
11426         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11427         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11428         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11429         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11431         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11432         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11433         { }
11434 };
11435
11436 /* unsolicited event for HP jack sensing */
11437 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11438                                        unsigned int res)
11439 {
11440         if ((res >> 26) != ALC880_HP_EVENT)
11441                 return;
11442         alc268_toshiba_automute(codec);
11443 }
11444
11445 static void alc268_acer_unsol_event(struct hda_codec *codec,
11446                                        unsigned int res)
11447 {
11448         if ((res >> 26) != ALC880_HP_EVENT)
11449                 return;
11450         alc268_acer_automute(codec, 1);
11451 }
11452
11453 static void alc268_acer_init_hook(struct hda_codec *codec)
11454 {
11455         alc268_acer_automute(codec, 1);
11456 }
11457
11458 /* toggle speaker-output according to the hp-jack state */
11459 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11460 {
11461         unsigned int present;
11462         unsigned char bits;
11463
11464         present = snd_hda_codec_read(codec, 0x15, 0,
11465                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11466         bits = present ? AMP_IN_MUTE(0) : 0;
11467         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11468                                 AMP_IN_MUTE(0), bits);
11469         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11470                                 AMP_IN_MUTE(0), bits);
11471 }
11472
11473
11474 static void alc268_acer_mic_automute(struct hda_codec *codec)
11475 {
11476         unsigned int present;
11477
11478         present = snd_hda_codec_read(codec, 0x18, 0,
11479                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11480         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11481                             present ? 0x0 : 0x6);
11482 }
11483
11484 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11485                                     unsigned int res)
11486 {
11487         if ((res >> 26) == ALC880_HP_EVENT)
11488                 alc268_aspire_one_speaker_automute(codec);
11489         if ((res >> 26) == ALC880_MIC_EVENT)
11490                 alc268_acer_mic_automute(codec);
11491 }
11492
11493 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11494 {
11495         alc268_aspire_one_speaker_automute(codec);
11496         alc268_acer_mic_automute(codec);
11497 }
11498
11499 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11500         /* output mixer control */
11501         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11502         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11503         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11504         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11505         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11506         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11507         { }
11508 };
11509
11510 static struct hda_verb alc268_dell_verbs[] = {
11511         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11512         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11513         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11514         { }
11515 };
11516
11517 /* mute/unmute internal speaker according to the hp jack and mute state */
11518 static void alc268_dell_automute(struct hda_codec *codec)
11519 {
11520         unsigned int present;
11521         unsigned int mute;
11522
11523         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11524         if (present & 0x80000000)
11525                 mute = HDA_AMP_MUTE;
11526         else
11527                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11528         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11529                                  HDA_AMP_MUTE, mute);
11530 }
11531
11532 static void alc268_dell_unsol_event(struct hda_codec *codec,
11533                                     unsigned int res)
11534 {
11535         if ((res >> 26) != ALC880_HP_EVENT)
11536                 return;
11537         alc268_dell_automute(codec);
11538 }
11539
11540 #define alc268_dell_init_hook   alc268_dell_automute
11541
11542 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11543         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11544         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11545         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11546         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11547         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11548         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11549         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11550         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11551         { }
11552 };
11553
11554 static struct hda_verb alc267_quanta_il1_verbs[] = {
11555         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11556         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11557         { }
11558 };
11559
11560 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11561 {
11562         unsigned int present;
11563
11564         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11565                 & AC_PINSENSE_PRESENCE;
11566         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11567                             present ? 0 : PIN_OUT);
11568 }
11569
11570 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11571 {
11572         unsigned int present;
11573
11574         present = snd_hda_codec_read(codec, 0x18, 0,
11575                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11576         snd_hda_codec_write(codec, 0x23, 0,
11577                             AC_VERB_SET_CONNECT_SEL,
11578                             present ? 0x00 : 0x01);
11579 }
11580
11581 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11582 {
11583         alc267_quanta_il1_hp_automute(codec);
11584         alc267_quanta_il1_mic_automute(codec);
11585 }
11586
11587 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11588                                            unsigned int res)
11589 {
11590         switch (res >> 26) {
11591         case ALC880_HP_EVENT:
11592                 alc267_quanta_il1_hp_automute(codec);
11593                 break;
11594         case ALC880_MIC_EVENT:
11595                 alc267_quanta_il1_mic_automute(codec);
11596                 break;
11597         }
11598 }
11599
11600 /*
11601  * generic initialization of ADC, input mixers and output mixers
11602  */
11603 static struct hda_verb alc268_base_init_verbs[] = {
11604         /* Unmute DAC0-1 and set vol = 0 */
11605         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11606         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11607
11608         /*
11609          * Set up output mixers (0x0c - 0x0e)
11610          */
11611         /* set vol=0 to output mixers */
11612         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11613         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11614
11615         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11616         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11617
11618         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11619         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11620         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11621         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11622         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11623         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11624         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11625         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11626
11627         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11628         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11629         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11630         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11631         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11632
11633         /* set PCBEEP vol = 0, mute connections */
11634         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11635         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11636         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11637
11638         /* Unmute Selector 23h,24h and set the default input to mic-in */
11639
11640         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11641         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11642         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11643         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11644
11645         { }
11646 };
11647
11648 /*
11649  * generic initialization of ADC, input mixers and output mixers
11650  */
11651 static struct hda_verb alc268_volume_init_verbs[] = {
11652         /* set output DAC */
11653         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11654         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11655
11656         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11657         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11658         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11659         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11660         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11661
11662         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11663         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11664         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11665
11666         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11667         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11668
11669         /* set PCBEEP vol = 0, mute connections */
11670         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11671         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11672         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11673
11674         { }
11675 };
11676
11677 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11678         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11679         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11680         {
11681                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11682                 /* The multiple "Capture Source" controls confuse alsamixer
11683                  * So call somewhat different..
11684                  */
11685                 /* .name = "Capture Source", */
11686                 .name = "Input Source",
11687                 .count = 1,
11688                 .info = alc_mux_enum_info,
11689                 .get = alc_mux_enum_get,
11690                 .put = alc_mux_enum_put,
11691         },
11692         { } /* end */
11693 };
11694
11695 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11696         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11697         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11698         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11699         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11700         {
11701                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11702                 /* The multiple "Capture Source" controls confuse alsamixer
11703                  * So call somewhat different..
11704                  */
11705                 /* .name = "Capture Source", */
11706                 .name = "Input Source",
11707                 .count = 2,
11708                 .info = alc_mux_enum_info,
11709                 .get = alc_mux_enum_get,
11710                 .put = alc_mux_enum_put,
11711         },
11712         { } /* end */
11713 };
11714
11715 static struct hda_input_mux alc268_capture_source = {
11716         .num_items = 4,
11717         .items = {
11718                 { "Mic", 0x0 },
11719                 { "Front Mic", 0x1 },
11720                 { "Line", 0x2 },
11721                 { "CD", 0x3 },
11722         },
11723 };
11724
11725 static struct hda_input_mux alc268_acer_capture_source = {
11726         .num_items = 3,
11727         .items = {
11728                 { "Mic", 0x0 },
11729                 { "Internal Mic", 0x1 },
11730                 { "Line", 0x2 },
11731         },
11732 };
11733
11734 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11735         .num_items = 3,
11736         .items = {
11737                 { "Mic", 0x0 },
11738                 { "Internal Mic", 0x6 },
11739                 { "Line", 0x2 },
11740         },
11741 };
11742
11743 #ifdef CONFIG_SND_DEBUG
11744 static struct snd_kcontrol_new alc268_test_mixer[] = {
11745         /* Volume widgets */
11746         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11747         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11748         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11749         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11750         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11751         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11752         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11753         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11754         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11755         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11756         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11757         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11758         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11759         /* The below appears problematic on some hardwares */
11760         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11761         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11762         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11763         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11764         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11765
11766         /* Modes for retasking pin widgets */
11767         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11768         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11769         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11770         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11771
11772         /* Controls for GPIO pins, assuming they are configured as outputs */
11773         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11774         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11775         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11776         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11777
11778         /* Switches to allow the digital SPDIF output pin to be enabled.
11779          * The ALC268 does not have an SPDIF input.
11780          */
11781         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11782
11783         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11784          * this output to turn on an external amplifier.
11785          */
11786         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11787         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11788
11789         { } /* end */
11790 };
11791 #endif
11792
11793 /* create input playback/capture controls for the given pin */
11794 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11795                                     const char *ctlname, int idx)
11796 {
11797         char name[32];
11798         int err;
11799
11800         sprintf(name, "%s Playback Volume", ctlname);
11801         if (nid == 0x14) {
11802                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11803                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11804                                                       HDA_OUTPUT));
11805                 if (err < 0)
11806                         return err;
11807         } else if (nid == 0x15) {
11808                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11809                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11810                                                       HDA_OUTPUT));
11811                 if (err < 0)
11812                         return err;
11813         } else
11814                 return -1;
11815         sprintf(name, "%s Playback Switch", ctlname);
11816         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11817                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11818         if (err < 0)
11819                 return err;
11820         return 0;
11821 }
11822
11823 /* add playback controls from the parsed DAC table */
11824 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11825                                              const struct auto_pin_cfg *cfg)
11826 {
11827         hda_nid_t nid;
11828         int err;
11829
11830         spec->multiout.num_dacs = 2;    /* only use one dac */
11831         spec->multiout.dac_nids = spec->private_dac_nids;
11832         spec->multiout.dac_nids[0] = 2;
11833         spec->multiout.dac_nids[1] = 3;
11834
11835         nid = cfg->line_out_pins[0];
11836         if (nid)
11837                 alc268_new_analog_output(spec, nid, "Front", 0);
11838
11839         nid = cfg->speaker_pins[0];
11840         if (nid == 0x1d) {
11841                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11842                                   "Speaker Playback Volume",
11843                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11844                 if (err < 0)
11845                         return err;
11846         }
11847         nid = cfg->hp_pins[0];
11848         if (nid)
11849                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11850
11851         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11852         if (nid == 0x16) {
11853                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11854                                   "Mono Playback Switch",
11855                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11856                 if (err < 0)
11857                         return err;
11858         }
11859         return 0;
11860 }
11861
11862 /* create playback/capture controls for input pins */
11863 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11864                                                 const struct auto_pin_cfg *cfg)
11865 {
11866         struct hda_input_mux *imux = &spec->private_imux[0];
11867         int i, idx1;
11868
11869         for (i = 0; i < AUTO_PIN_LAST; i++) {
11870                 switch(cfg->input_pins[i]) {
11871                 case 0x18:
11872                         idx1 = 0;       /* Mic 1 */
11873                         break;
11874                 case 0x19:
11875                         idx1 = 1;       /* Mic 2 */
11876                         break;
11877                 case 0x1a:
11878                         idx1 = 2;       /* Line In */
11879                         break;
11880                 case 0x1c:
11881                         idx1 = 3;       /* CD */
11882                         break;
11883                 case 0x12:
11884                 case 0x13:
11885                         idx1 = 6;       /* digital mics */
11886                         break;
11887                 default:
11888                         continue;
11889                 }
11890                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11891                 imux->items[imux->num_items].index = idx1;
11892                 imux->num_items++;
11893         }
11894         return 0;
11895 }
11896
11897 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11898 {
11899         struct alc_spec *spec = codec->spec;
11900         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11901         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11902         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11903         unsigned int    dac_vol1, dac_vol2;
11904
11905         if (speaker_nid) {
11906                 snd_hda_codec_write(codec, speaker_nid, 0,
11907                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11908                 snd_hda_codec_write(codec, 0x0f, 0,
11909                                     AC_VERB_SET_AMP_GAIN_MUTE,
11910                                     AMP_IN_UNMUTE(1));
11911                 snd_hda_codec_write(codec, 0x10, 0,
11912                                     AC_VERB_SET_AMP_GAIN_MUTE,
11913                                     AMP_IN_UNMUTE(1));
11914         } else {
11915                 snd_hda_codec_write(codec, 0x0f, 0,
11916                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11917                 snd_hda_codec_write(codec, 0x10, 0,
11918                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11919         }
11920
11921         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11922         if (line_nid == 0x14)
11923                 dac_vol2 = AMP_OUT_ZERO;
11924         else if (line_nid == 0x15)
11925                 dac_vol1 = AMP_OUT_ZERO;
11926         if (hp_nid == 0x14)
11927                 dac_vol2 = AMP_OUT_ZERO;
11928         else if (hp_nid == 0x15)
11929                 dac_vol1 = AMP_OUT_ZERO;
11930         if (line_nid != 0x16 || hp_nid != 0x16 ||
11931             spec->autocfg.line_out_pins[1] != 0x16 ||
11932             spec->autocfg.line_out_pins[2] != 0x16)
11933                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11934
11935         snd_hda_codec_write(codec, 0x02, 0,
11936                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11937         snd_hda_codec_write(codec, 0x03, 0,
11938                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11939 }
11940
11941 /* pcm configuration: identiacal with ALC880 */
11942 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11943 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11944 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11945 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11946
11947 /*
11948  * BIOS auto configuration
11949  */
11950 static int alc268_parse_auto_config(struct hda_codec *codec)
11951 {
11952         struct alc_spec *spec = codec->spec;
11953         int err;
11954         static hda_nid_t alc268_ignore[] = { 0 };
11955
11956         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11957                                            alc268_ignore);
11958         if (err < 0)
11959                 return err;
11960         if (!spec->autocfg.line_outs) {
11961                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11962                         spec->multiout.max_channels = 2;
11963                         spec->no_analog = 1;
11964                         goto dig_only;
11965                 }
11966                 return 0; /* can't find valid BIOS pin config */
11967         }
11968         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11969         if (err < 0)
11970                 return err;
11971         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11972         if (err < 0)
11973                 return err;
11974
11975         spec->multiout.max_channels = 2;
11976
11977  dig_only:
11978         /* digital only support output */
11979         if (spec->autocfg.dig_outs) {
11980                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11981                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11982         }
11983         if (spec->kctls.list)
11984                 add_mixer(spec, spec->kctls.list);
11985
11986         if (spec->autocfg.speaker_pins[0] != 0x1d)
11987                 add_mixer(spec, alc268_beep_mixer);
11988
11989         add_verb(spec, alc268_volume_init_verbs);
11990         spec->num_mux_defs = 1;
11991         spec->input_mux = &spec->private_imux[0];
11992
11993         err = alc_auto_add_mic_boost(codec);
11994         if (err < 0)
11995                 return err;
11996
11997         store_pin_configs(codec);
11998         return 1;
11999 }
12000
12001 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
12002 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
12003 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12004
12005 /* init callback for auto-configuration model -- overriding the default init */
12006 static void alc268_auto_init(struct hda_codec *codec)
12007 {
12008         struct alc_spec *spec = codec->spec;
12009         alc268_auto_init_multi_out(codec);
12010         alc268_auto_init_hp_out(codec);
12011         alc268_auto_init_mono_speaker_out(codec);
12012         alc268_auto_init_analog_input(codec);
12013         if (spec->unsol_event)
12014                 alc_inithook(codec);
12015 }
12016
12017 /*
12018  * configuration and preset
12019  */
12020 static const char *alc268_models[ALC268_MODEL_LAST] = {
12021         [ALC267_QUANTA_IL1]     = "quanta-il1",
12022         [ALC268_3ST]            = "3stack",
12023         [ALC268_TOSHIBA]        = "toshiba",
12024         [ALC268_ACER]           = "acer",
12025         [ALC268_ACER_DMIC]      = "acer-dmic",
12026         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12027         [ALC268_DELL]           = "dell",
12028         [ALC268_ZEPTO]          = "zepto",
12029 #ifdef CONFIG_SND_DEBUG
12030         [ALC268_TEST]           = "test",
12031 #endif
12032         [ALC268_AUTO]           = "auto",
12033 };
12034
12035 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12036         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12037         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12038         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12039         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12040         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12041         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12042                                                 ALC268_ACER_ASPIRE_ONE),
12043         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12044         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12045         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
12046         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12047         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
12048         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
12049         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
12050         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12051         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12052         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12053         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12054         {}
12055 };
12056
12057 static struct alc_config_preset alc268_presets[] = {
12058         [ALC267_QUANTA_IL1] = {
12059                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12060                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12061                                 alc267_quanta_il1_verbs },
12062                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12063                 .dac_nids = alc268_dac_nids,
12064                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12065                 .adc_nids = alc268_adc_nids_alt,
12066                 .hp_nid = 0x03,
12067                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12068                 .channel_mode = alc268_modes,
12069                 .input_mux = &alc268_capture_source,
12070                 .unsol_event = alc267_quanta_il1_unsol_event,
12071                 .init_hook = alc267_quanta_il1_automute,
12072         },
12073         [ALC268_3ST] = {
12074                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12075                             alc268_beep_mixer },
12076                 .init_verbs = { alc268_base_init_verbs },
12077                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12078                 .dac_nids = alc268_dac_nids,
12079                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12080                 .adc_nids = alc268_adc_nids_alt,
12081                 .capsrc_nids = alc268_capsrc_nids,
12082                 .hp_nid = 0x03,
12083                 .dig_out_nid = ALC268_DIGOUT_NID,
12084                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12085                 .channel_mode = alc268_modes,
12086                 .input_mux = &alc268_capture_source,
12087         },
12088         [ALC268_TOSHIBA] = {
12089                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12090                             alc268_beep_mixer },
12091                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12092                                 alc268_toshiba_verbs },
12093                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12094                 .dac_nids = alc268_dac_nids,
12095                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12096                 .adc_nids = alc268_adc_nids_alt,
12097                 .capsrc_nids = alc268_capsrc_nids,
12098                 .hp_nid = 0x03,
12099                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12100                 .channel_mode = alc268_modes,
12101                 .input_mux = &alc268_capture_source,
12102                 .unsol_event = alc268_toshiba_unsol_event,
12103                 .init_hook = alc268_toshiba_automute,
12104         },
12105         [ALC268_ACER] = {
12106                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12107                             alc268_beep_mixer },
12108                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12109                                 alc268_acer_verbs },
12110                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12111                 .dac_nids = alc268_dac_nids,
12112                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12113                 .adc_nids = alc268_adc_nids_alt,
12114                 .capsrc_nids = alc268_capsrc_nids,
12115                 .hp_nid = 0x02,
12116                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12117                 .channel_mode = alc268_modes,
12118                 .input_mux = &alc268_acer_capture_source,
12119                 .unsol_event = alc268_acer_unsol_event,
12120                 .init_hook = alc268_acer_init_hook,
12121         },
12122         [ALC268_ACER_DMIC] = {
12123                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12124                             alc268_beep_mixer },
12125                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12126                                 alc268_acer_verbs },
12127                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12128                 .dac_nids = alc268_dac_nids,
12129                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12130                 .adc_nids = alc268_adc_nids_alt,
12131                 .capsrc_nids = alc268_capsrc_nids,
12132                 .hp_nid = 0x02,
12133                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12134                 .channel_mode = alc268_modes,
12135                 .input_mux = &alc268_acer_dmic_capture_source,
12136                 .unsol_event = alc268_acer_unsol_event,
12137                 .init_hook = alc268_acer_init_hook,
12138         },
12139         [ALC268_ACER_ASPIRE_ONE] = {
12140                 .mixers = { alc268_acer_aspire_one_mixer,
12141                             alc268_beep_mixer,
12142                             alc268_capture_alt_mixer },
12143                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12144                                 alc268_acer_aspire_one_verbs },
12145                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12146                 .dac_nids = alc268_dac_nids,
12147                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12148                 .adc_nids = alc268_adc_nids_alt,
12149                 .capsrc_nids = alc268_capsrc_nids,
12150                 .hp_nid = 0x03,
12151                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12152                 .channel_mode = alc268_modes,
12153                 .input_mux = &alc268_acer_lc_capture_source,
12154                 .unsol_event = alc268_acer_lc_unsol_event,
12155                 .init_hook = alc268_acer_lc_init_hook,
12156         },
12157         [ALC268_DELL] = {
12158                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12159                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12160                                 alc268_dell_verbs },
12161                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12162                 .dac_nids = alc268_dac_nids,
12163                 .hp_nid = 0x02,
12164                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12165                 .channel_mode = alc268_modes,
12166                 .unsol_event = alc268_dell_unsol_event,
12167                 .init_hook = alc268_dell_init_hook,
12168                 .input_mux = &alc268_capture_source,
12169         },
12170         [ALC268_ZEPTO] = {
12171                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12172                             alc268_beep_mixer },
12173                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12174                                 alc268_toshiba_verbs },
12175                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12176                 .dac_nids = alc268_dac_nids,
12177                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12178                 .adc_nids = alc268_adc_nids_alt,
12179                 .capsrc_nids = alc268_capsrc_nids,
12180                 .hp_nid = 0x03,
12181                 .dig_out_nid = ALC268_DIGOUT_NID,
12182                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12183                 .channel_mode = alc268_modes,
12184                 .input_mux = &alc268_capture_source,
12185                 .unsol_event = alc268_toshiba_unsol_event,
12186                 .init_hook = alc268_toshiba_automute
12187         },
12188 #ifdef CONFIG_SND_DEBUG
12189         [ALC268_TEST] = {
12190                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12191                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12192                                 alc268_volume_init_verbs },
12193                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12194                 .dac_nids = alc268_dac_nids,
12195                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12196                 .adc_nids = alc268_adc_nids_alt,
12197                 .capsrc_nids = alc268_capsrc_nids,
12198                 .hp_nid = 0x03,
12199                 .dig_out_nid = ALC268_DIGOUT_NID,
12200                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12201                 .channel_mode = alc268_modes,
12202                 .input_mux = &alc268_capture_source,
12203         },
12204 #endif
12205 };
12206
12207 static int patch_alc268(struct hda_codec *codec)
12208 {
12209         struct alc_spec *spec;
12210         int board_config;
12211         int i, has_beep, err;
12212
12213         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12214         if (spec == NULL)
12215                 return -ENOMEM;
12216
12217         codec->spec = spec;
12218
12219         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12220                                                   alc268_models,
12221                                                   alc268_cfg_tbl);
12222
12223         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12224                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12225                        "trying auto-probe from BIOS...\n");
12226                 board_config = ALC268_AUTO;
12227         }
12228
12229         if (board_config == ALC268_AUTO) {
12230                 /* automatic parse from the BIOS config */
12231                 err = alc268_parse_auto_config(codec);
12232                 if (err < 0) {
12233                         alc_free(codec);
12234                         return err;
12235                 } else if (!err) {
12236                         printk(KERN_INFO
12237                                "hda_codec: Cannot set up configuration "
12238                                "from BIOS.  Using base mode...\n");
12239                         board_config = ALC268_3ST;
12240                 }
12241         }
12242
12243         if (board_config != ALC268_AUTO)
12244                 setup_preset(spec, &alc268_presets[board_config]);
12245
12246         if (codec->vendor_id == 0x10ec0267) {
12247                 spec->stream_name_analog = "ALC267 Analog";
12248                 spec->stream_name_digital = "ALC267 Digital";
12249         } else {
12250                 spec->stream_name_analog = "ALC268 Analog";
12251                 spec->stream_name_digital = "ALC268 Digital";
12252         }
12253
12254         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12255         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12256         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12257
12258         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12259
12260         has_beep = 0;
12261         for (i = 0; i < spec->num_mixers; i++) {
12262                 if (spec->mixers[i] == alc268_beep_mixer) {
12263                         has_beep = 1;
12264                         break;
12265                 }
12266         }
12267
12268         if (has_beep) {
12269                 err = snd_hda_attach_beep_device(codec, 0x1);
12270                 if (err < 0) {
12271                         alc_free(codec);
12272                         return err;
12273                 }
12274                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12275                         /* override the amp caps for beep generator */
12276                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12277                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12278                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12279                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12280                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12281         }
12282
12283         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12284                 /* check whether NID 0x07 is valid */
12285                 unsigned int wcap = get_wcaps(codec, 0x07);
12286                 int i;
12287
12288                 /* get type */
12289                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12290                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12291                         spec->adc_nids = alc268_adc_nids_alt;
12292                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12293                         add_mixer(spec, alc268_capture_alt_mixer);
12294                 } else {
12295                         spec->adc_nids = alc268_adc_nids;
12296                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12297                         add_mixer(spec, alc268_capture_mixer);
12298                 }
12299                 spec->capsrc_nids = alc268_capsrc_nids;
12300                 /* set default input source */
12301                 for (i = 0; i < spec->num_adc_nids; i++)
12302                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12303                                 0, AC_VERB_SET_CONNECT_SEL,
12304                                 spec->input_mux->items[0].index);
12305         }
12306
12307         spec->vmaster_nid = 0x02;
12308
12309         codec->patch_ops = alc_patch_ops;
12310         if (board_config == ALC268_AUTO)
12311                 spec->init_hook = alc268_auto_init;
12312
12313         codec->proc_widget_hook = print_realtek_coef;
12314
12315         return 0;
12316 }
12317
12318 /*
12319  *  ALC269 channel source setting (2 channel)
12320  */
12321 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12322
12323 #define alc269_dac_nids         alc260_dac_nids
12324
12325 static hda_nid_t alc269_adc_nids[1] = {
12326         /* ADC1 */
12327         0x08,
12328 };
12329
12330 static hda_nid_t alc269_capsrc_nids[1] = {
12331         0x23,
12332 };
12333
12334 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12335  *       not a mux!
12336  */
12337
12338 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12339         .num_items = 2,
12340         .items = {
12341                 { "i-Mic", 0x5 },
12342                 { "e-Mic", 0x0 },
12343         },
12344 };
12345
12346 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12347         .num_items = 2,
12348         .items = {
12349                 { "i-Mic", 0x1 },
12350                 { "e-Mic", 0x0 },
12351         },
12352 };
12353
12354 #define alc269_modes            alc260_modes
12355 #define alc269_capture_source   alc880_lg_lw_capture_source
12356
12357 static struct snd_kcontrol_new alc269_base_mixer[] = {
12358         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12359         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12360         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12361         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12362         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12363         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12364         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12365         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12366         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12367         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12368         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12369         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12370         { } /* end */
12371 };
12372
12373 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12374         /* output mixer control */
12375         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12376         {
12377                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12378                 .name = "Master Playback Switch",
12379                 .info = snd_hda_mixer_amp_switch_info,
12380                 .get = snd_hda_mixer_amp_switch_get,
12381                 .put = alc268_acer_master_sw_put,
12382                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12383         },
12384         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12385         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12386         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12387         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12388         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12389         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12390         { }
12391 };
12392
12393 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12394         /* output mixer control */
12395         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12396         {
12397                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12398                 .name = "Master Playback Switch",
12399                 .info = snd_hda_mixer_amp_switch_info,
12400                 .get = snd_hda_mixer_amp_switch_get,
12401                 .put = alc268_acer_master_sw_put,
12402                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12403         },
12404         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12405         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12406         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12407         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12408         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12409         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12410         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12411         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12412         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12413         { }
12414 };
12415
12416 /* bind volumes of both NID 0x0c and 0x0d */
12417 static struct hda_bind_ctls alc269_epc_bind_vol = {
12418         .ops = &snd_hda_bind_vol,
12419         .values = {
12420                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12421                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12422                 0
12423         },
12424 };
12425
12426 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12427         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12428         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12429         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12430         { } /* end */
12431 };
12432
12433 /* capture mixer elements */
12434 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12435         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12436         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12437         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12438         { } /* end */
12439 };
12440
12441 /* FSC amilo */
12442 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12443         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12444         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12445         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12446         { } /* end */
12447 };
12448
12449 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12450         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12451         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12452         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12453         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12454         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12455         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12456         { }
12457 };
12458
12459 static struct hda_verb alc269_lifebook_verbs[] = {
12460         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12461         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12462         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12463         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12464         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12465         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12466         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12467         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12468         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12469         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12470         { }
12471 };
12472
12473 /* toggle speaker-output according to the hp-jack state */
12474 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12475 {
12476         unsigned int present;
12477         unsigned char bits;
12478
12479         present = snd_hda_codec_read(codec, 0x15, 0,
12480                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12481         bits = present ? AMP_IN_MUTE(0) : 0;
12482         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12483                         AMP_IN_MUTE(0), bits);
12484         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12485                         AMP_IN_MUTE(0), bits);
12486
12487         snd_hda_codec_write(codec, 0x20, 0,
12488                         AC_VERB_SET_COEF_INDEX, 0x0c);
12489         snd_hda_codec_write(codec, 0x20, 0,
12490                         AC_VERB_SET_PROC_COEF, 0x680);
12491
12492         snd_hda_codec_write(codec, 0x20, 0,
12493                         AC_VERB_SET_COEF_INDEX, 0x0c);
12494         snd_hda_codec_write(codec, 0x20, 0,
12495                         AC_VERB_SET_PROC_COEF, 0x480);
12496 }
12497
12498 /* toggle speaker-output according to the hp-jacks state */
12499 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12500 {
12501         unsigned int present;
12502         unsigned char bits;
12503
12504         /* Check laptop headphone socket */
12505         present = snd_hda_codec_read(codec, 0x15, 0,
12506                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12507
12508         /* Check port replicator headphone socket */
12509         present |= snd_hda_codec_read(codec, 0x1a, 0,
12510                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12511
12512         bits = present ? AMP_IN_MUTE(0) : 0;
12513         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12514                         AMP_IN_MUTE(0), bits);
12515         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12516                         AMP_IN_MUTE(0), bits);
12517
12518         snd_hda_codec_write(codec, 0x20, 0,
12519                         AC_VERB_SET_COEF_INDEX, 0x0c);
12520         snd_hda_codec_write(codec, 0x20, 0,
12521                         AC_VERB_SET_PROC_COEF, 0x680);
12522
12523         snd_hda_codec_write(codec, 0x20, 0,
12524                         AC_VERB_SET_COEF_INDEX, 0x0c);
12525         snd_hda_codec_write(codec, 0x20, 0,
12526                         AC_VERB_SET_PROC_COEF, 0x480);
12527 }
12528
12529 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12530 {
12531         unsigned int present;
12532
12533         present = snd_hda_codec_read(codec, 0x18, 0,
12534                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12535         snd_hda_codec_write(codec, 0x23, 0,
12536                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12537 }
12538
12539 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12540 {
12541         unsigned int present_laptop;
12542         unsigned int present_dock;
12543
12544         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12545                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12546
12547         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12548                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12549
12550         /* Laptop mic port overrides dock mic port, design decision */
12551         if (present_dock)
12552                 snd_hda_codec_write(codec, 0x23, 0,
12553                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12554         if (present_laptop)
12555                 snd_hda_codec_write(codec, 0x23, 0,
12556                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12557         if (!present_dock && !present_laptop)
12558                 snd_hda_codec_write(codec, 0x23, 0,
12559                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12560 }
12561
12562 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12563                                     unsigned int res)
12564 {
12565         if ((res >> 26) == ALC880_HP_EVENT)
12566                 alc269_quanta_fl1_speaker_automute(codec);
12567         if ((res >> 26) == ALC880_MIC_EVENT)
12568                 alc269_quanta_fl1_mic_automute(codec);
12569 }
12570
12571 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12572                                         unsigned int res)
12573 {
12574         if ((res >> 26) == ALC880_HP_EVENT)
12575                 alc269_lifebook_speaker_automute(codec);
12576         if ((res >> 26) == ALC880_MIC_EVENT)
12577                 alc269_lifebook_mic_autoswitch(codec);
12578 }
12579
12580 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12581 {
12582         alc269_quanta_fl1_speaker_automute(codec);
12583         alc269_quanta_fl1_mic_automute(codec);
12584 }
12585
12586 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12587 {
12588         alc269_lifebook_speaker_automute(codec);
12589         alc269_lifebook_mic_autoswitch(codec);
12590 }
12591
12592 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12593         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12594         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12595         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12596         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12597         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12598         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12599         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12600         {}
12601 };
12602
12603 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12604         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12605         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12606         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12607         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12608         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12609         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12610         {}
12611 };
12612
12613 /* toggle speaker-output according to the hp-jack state */
12614 static void alc269_speaker_automute(struct hda_codec *codec)
12615 {
12616         unsigned int present;
12617         unsigned char bits;
12618
12619         present = snd_hda_codec_read(codec, 0x15, 0,
12620                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12621         bits = present ? AMP_IN_MUTE(0) : 0;
12622         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12623                                 AMP_IN_MUTE(0), bits);
12624         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12625                                 AMP_IN_MUTE(0), bits);
12626 }
12627
12628 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12629 {
12630         unsigned int present;
12631
12632         present = snd_hda_codec_read(codec, 0x18, 0,
12633                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12634         snd_hda_codec_write(codec, 0x23, 0,
12635                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12636 }
12637
12638 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12639 {
12640         unsigned int present;
12641
12642         present = snd_hda_codec_read(codec, 0x18, 0,
12643                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12644         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12645                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12646         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12647                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12648 }
12649
12650 /* unsolicited event for HP jack sensing */
12651 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12652                                      unsigned int res)
12653 {
12654         if ((res >> 26) == ALC880_HP_EVENT)
12655                 alc269_speaker_automute(codec);
12656
12657         if ((res >> 26) == ALC880_MIC_EVENT)
12658                 alc269_eeepc_dmic_automute(codec);
12659 }
12660
12661 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12662 {
12663         alc269_speaker_automute(codec);
12664         alc269_eeepc_dmic_automute(codec);
12665 }
12666
12667 /* unsolicited event for HP jack sensing */
12668 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12669                                      unsigned int res)
12670 {
12671         if ((res >> 26) == ALC880_HP_EVENT)
12672                 alc269_speaker_automute(codec);
12673
12674         if ((res >> 26) == ALC880_MIC_EVENT)
12675                 alc269_eeepc_amic_automute(codec);
12676 }
12677
12678 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12679 {
12680         alc269_speaker_automute(codec);
12681         alc269_eeepc_amic_automute(codec);
12682 }
12683
12684 /*
12685  * generic initialization of ADC, input mixers and output mixers
12686  */
12687 static struct hda_verb alc269_init_verbs[] = {
12688         /*
12689          * Unmute ADC0 and set the default input to mic-in
12690          */
12691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12692
12693         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12694          * analog-loopback mixer widget
12695          * Note: PASD motherboards uses the Line In 2 as the input for
12696          * front panel mic (mic 2)
12697          */
12698         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12699         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12700         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12701         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12702         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12703         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12704
12705         /*
12706          * Set up output mixers (0x0c - 0x0e)
12707          */
12708         /* set vol=0 to output mixers */
12709         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12710         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12711
12712         /* set up input amps for analog loopback */
12713         /* Amp Indices: DAC = 0, mixer = 1 */
12714         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12715         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12716         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12717         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12718         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12719         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12720
12721         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12722         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12723         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12724         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12725         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12726         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12727         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12728
12729         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12730         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12731         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12732         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12733         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12734         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12735         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12736
12737         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12738         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12739
12740         /* FIXME: use matrix-type input source selection */
12741         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12742         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12743         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12744         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12745         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12746         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12747
12748         /* set EAPD */
12749         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12750         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12751         { }
12752 };
12753
12754 /* add playback controls from the parsed DAC table */
12755 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12756                                              const struct auto_pin_cfg *cfg)
12757 {
12758         hda_nid_t nid;
12759         int err;
12760
12761         spec->multiout.num_dacs = 1;    /* only use one dac */
12762         spec->multiout.dac_nids = spec->private_dac_nids;
12763         spec->multiout.dac_nids[0] = 2;
12764
12765         nid = cfg->line_out_pins[0];
12766         if (nid) {
12767                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12768                                   "Front Playback Volume",
12769                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12770                 if (err < 0)
12771                         return err;
12772                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12773                                   "Front Playback Switch",
12774                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12775                 if (err < 0)
12776                         return err;
12777         }
12778
12779         nid = cfg->speaker_pins[0];
12780         if (nid) {
12781                 if (!cfg->line_out_pins[0]) {
12782                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12783                                           "Speaker Playback Volume",
12784                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12785                                                               HDA_OUTPUT));
12786                         if (err < 0)
12787                                 return err;
12788                 }
12789                 if (nid == 0x16) {
12790                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12791                                           "Speaker Playback Switch",
12792                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12793                                                               HDA_OUTPUT));
12794                         if (err < 0)
12795                                 return err;
12796                 } else {
12797                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12798                                           "Speaker Playback Switch",
12799                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12800                                                               HDA_OUTPUT));
12801                         if (err < 0)
12802                                 return err;
12803                 }
12804         }
12805         nid = cfg->hp_pins[0];
12806         if (nid) {
12807                 /* spec->multiout.hp_nid = 2; */
12808                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12809                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12810                                           "Headphone Playback Volume",
12811                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12812                                                               HDA_OUTPUT));
12813                         if (err < 0)
12814                                 return err;
12815                 }
12816                 if (nid == 0x16) {
12817                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12818                                           "Headphone Playback Switch",
12819                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12820                                                               HDA_OUTPUT));
12821                         if (err < 0)
12822                                 return err;
12823                 } else {
12824                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12825                                           "Headphone Playback Switch",
12826                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12827                                                               HDA_OUTPUT));
12828                         if (err < 0)
12829                                 return err;
12830                 }
12831         }
12832         return 0;
12833 }
12834
12835 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12836                                                 const struct auto_pin_cfg *cfg)
12837 {
12838         int err;
12839
12840         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12841         if (err < 0)
12842                 return err;
12843         /* digital-mic input pin is excluded in alc880_auto_create..()
12844          * because it's under 0x18
12845          */
12846         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12847             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12848                 struct hda_input_mux *imux = &spec->private_imux[0];
12849                 imux->items[imux->num_items].label = "Int Mic";
12850                 imux->items[imux->num_items].index = 0x05;
12851                 imux->num_items++;
12852         }
12853         return 0;
12854 }
12855
12856 #ifdef CONFIG_SND_HDA_POWER_SAVE
12857 #define alc269_loopbacks        alc880_loopbacks
12858 #endif
12859
12860 /* pcm configuration: identiacal with ALC880 */
12861 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12862 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12863 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12864 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12865
12866 /*
12867  * BIOS auto configuration
12868  */
12869 static int alc269_parse_auto_config(struct hda_codec *codec)
12870 {
12871         struct alc_spec *spec = codec->spec;
12872         int err;
12873         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12874
12875         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12876                                            alc269_ignore);
12877         if (err < 0)
12878                 return err;
12879
12880         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12881         if (err < 0)
12882                 return err;
12883         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12884         if (err < 0)
12885                 return err;
12886
12887         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12888
12889         if (spec->autocfg.dig_outs)
12890                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12891
12892         if (spec->kctls.list)
12893                 add_mixer(spec, spec->kctls.list);
12894
12895         add_verb(spec, alc269_init_verbs);
12896         spec->num_mux_defs = 1;
12897         spec->input_mux = &spec->private_imux[0];
12898         /* set default input source */
12899         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12900                                   0, AC_VERB_SET_CONNECT_SEL,
12901                                   spec->input_mux->items[0].index);
12902
12903         err = alc_auto_add_mic_boost(codec);
12904         if (err < 0)
12905                 return err;
12906
12907         if (!spec->cap_mixer && !spec->no_analog)
12908                 set_capture_mixer(spec);
12909
12910         store_pin_configs(codec);
12911         return 1;
12912 }
12913
12914 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12915 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12916 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12917
12918
12919 /* init callback for auto-configuration model -- overriding the default init */
12920 static void alc269_auto_init(struct hda_codec *codec)
12921 {
12922         struct alc_spec *spec = codec->spec;
12923         alc269_auto_init_multi_out(codec);
12924         alc269_auto_init_hp_out(codec);
12925         alc269_auto_init_analog_input(codec);
12926         if (spec->unsol_event)
12927                 alc_inithook(codec);
12928 }
12929
12930 /*
12931  * configuration and preset
12932  */
12933 static const char *alc269_models[ALC269_MODEL_LAST] = {
12934         [ALC269_BASIC]                  = "basic",
12935         [ALC269_QUANTA_FL1]             = "quanta",
12936         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12937         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12938         [ALC269_FUJITSU]                = "fujitsu",
12939         [ALC269_LIFEBOOK]               = "lifebook"
12940 };
12941
12942 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12943         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12944         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12945                       ALC269_ASUS_EEEPC_P703),
12946         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12947                       ALC269_ASUS_EEEPC_P901),
12948         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12949                       ALC269_ASUS_EEEPC_P901),
12950         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12951         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12952         {}
12953 };
12954
12955 static struct alc_config_preset alc269_presets[] = {
12956         [ALC269_BASIC] = {
12957                 .mixers = { alc269_base_mixer },
12958                 .init_verbs = { alc269_init_verbs },
12959                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12960                 .dac_nids = alc269_dac_nids,
12961                 .hp_nid = 0x03,
12962                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12963                 .channel_mode = alc269_modes,
12964                 .input_mux = &alc269_capture_source,
12965         },
12966         [ALC269_QUANTA_FL1] = {
12967                 .mixers = { alc269_quanta_fl1_mixer },
12968                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12969                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12970                 .dac_nids = alc269_dac_nids,
12971                 .hp_nid = 0x03,
12972                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12973                 .channel_mode = alc269_modes,
12974                 .input_mux = &alc269_capture_source,
12975                 .unsol_event = alc269_quanta_fl1_unsol_event,
12976                 .init_hook = alc269_quanta_fl1_init_hook,
12977         },
12978         [ALC269_ASUS_EEEPC_P703] = {
12979                 .mixers = { alc269_eeepc_mixer },
12980                 .cap_mixer = alc269_epc_capture_mixer,
12981                 .init_verbs = { alc269_init_verbs,
12982                                 alc269_eeepc_amic_init_verbs },
12983                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12984                 .dac_nids = alc269_dac_nids,
12985                 .hp_nid = 0x03,
12986                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12987                 .channel_mode = alc269_modes,
12988                 .input_mux = &alc269_eeepc_amic_capture_source,
12989                 .unsol_event = alc269_eeepc_amic_unsol_event,
12990                 .init_hook = alc269_eeepc_amic_inithook,
12991         },
12992         [ALC269_ASUS_EEEPC_P901] = {
12993                 .mixers = { alc269_eeepc_mixer },
12994                 .cap_mixer = alc269_epc_capture_mixer,
12995                 .init_verbs = { alc269_init_verbs,
12996                                 alc269_eeepc_dmic_init_verbs },
12997                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12998                 .dac_nids = alc269_dac_nids,
12999                 .hp_nid = 0x03,
13000                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13001                 .channel_mode = alc269_modes,
13002                 .input_mux = &alc269_eeepc_dmic_capture_source,
13003                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13004                 .init_hook = alc269_eeepc_dmic_inithook,
13005         },
13006         [ALC269_FUJITSU] = {
13007                 .mixers = { alc269_fujitsu_mixer },
13008                 .cap_mixer = alc269_epc_capture_mixer,
13009                 .init_verbs = { alc269_init_verbs,
13010                                 alc269_eeepc_dmic_init_verbs },
13011                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13012                 .dac_nids = alc269_dac_nids,
13013                 .hp_nid = 0x03,
13014                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13015                 .channel_mode = alc269_modes,
13016                 .input_mux = &alc269_eeepc_dmic_capture_source,
13017                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13018                 .init_hook = alc269_eeepc_dmic_inithook,
13019         },
13020         [ALC269_LIFEBOOK] = {
13021                 .mixers = { alc269_lifebook_mixer },
13022                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13023                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13024                 .dac_nids = alc269_dac_nids,
13025                 .hp_nid = 0x03,
13026                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13027                 .channel_mode = alc269_modes,
13028                 .input_mux = &alc269_capture_source,
13029                 .unsol_event = alc269_lifebook_unsol_event,
13030                 .init_hook = alc269_lifebook_init_hook,
13031         },
13032 };
13033
13034 static int patch_alc269(struct hda_codec *codec)
13035 {
13036         struct alc_spec *spec;
13037         int board_config;
13038         int err;
13039
13040         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13041         if (spec == NULL)
13042                 return -ENOMEM;
13043
13044         codec->spec = spec;
13045
13046         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13047
13048         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13049                                                   alc269_models,
13050                                                   alc269_cfg_tbl);
13051
13052         if (board_config < 0) {
13053                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
13054                        "trying auto-probe from BIOS...\n");
13055                 board_config = ALC269_AUTO;
13056         }
13057
13058         if (board_config == ALC269_AUTO) {
13059                 /* automatic parse from the BIOS config */
13060                 err = alc269_parse_auto_config(codec);
13061                 if (err < 0) {
13062                         alc_free(codec);
13063                         return err;
13064                 } else if (!err) {
13065                         printk(KERN_INFO
13066                                "hda_codec: Cannot set up configuration "
13067                                "from BIOS.  Using base mode...\n");
13068                         board_config = ALC269_BASIC;
13069                 }
13070         }
13071
13072         err = snd_hda_attach_beep_device(codec, 0x1);
13073         if (err < 0) {
13074                 alc_free(codec);
13075                 return err;
13076         }
13077
13078         if (board_config != ALC269_AUTO)
13079                 setup_preset(spec, &alc269_presets[board_config]);
13080
13081         spec->stream_name_analog = "ALC269 Analog";
13082         spec->stream_analog_playback = &alc269_pcm_analog_playback;
13083         spec->stream_analog_capture = &alc269_pcm_analog_capture;
13084
13085         spec->stream_name_digital = "ALC269 Digital";
13086         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13087         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13088
13089         spec->adc_nids = alc269_adc_nids;
13090         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13091         spec->capsrc_nids = alc269_capsrc_nids;
13092         if (!spec->cap_mixer)
13093                 set_capture_mixer(spec);
13094         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13095
13096         codec->patch_ops = alc_patch_ops;
13097         if (board_config == ALC269_AUTO)
13098                 spec->init_hook = alc269_auto_init;
13099 #ifdef CONFIG_SND_HDA_POWER_SAVE
13100         if (!spec->loopback.amplist)
13101                 spec->loopback.amplist = alc269_loopbacks;
13102 #endif
13103         codec->proc_widget_hook = print_realtek_coef;
13104
13105         return 0;
13106 }
13107
13108 /*
13109  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13110  */
13111
13112 /*
13113  * set the path ways for 2 channel output
13114  * need to set the codec line out and mic 1 pin widgets to inputs
13115  */
13116 static struct hda_verb alc861_threestack_ch2_init[] = {
13117         /* set pin widget 1Ah (line in) for input */
13118         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13119         /* set pin widget 18h (mic1/2) for input, for mic also enable
13120          * the vref
13121          */
13122         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13123
13124         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13125 #if 0
13126         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13127         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13128 #endif
13129         { } /* end */
13130 };
13131 /*
13132  * 6ch mode
13133  * need to set the codec line out and mic 1 pin widgets to outputs
13134  */
13135 static struct hda_verb alc861_threestack_ch6_init[] = {
13136         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13137         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13138         /* set pin widget 18h (mic1) for output (CLFE)*/
13139         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13140
13141         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13142         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13143
13144         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13145 #if 0
13146         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13147         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13148 #endif
13149         { } /* end */
13150 };
13151
13152 static struct hda_channel_mode alc861_threestack_modes[2] = {
13153         { 2, alc861_threestack_ch2_init },
13154         { 6, alc861_threestack_ch6_init },
13155 };
13156 /* Set mic1 as input and unmute the mixer */
13157 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13158         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13159         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13160         { } /* end */
13161 };
13162 /* Set mic1 as output and mute mixer */
13163 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13164         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13165         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13166         { } /* end */
13167 };
13168
13169 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13170         { 2, alc861_uniwill_m31_ch2_init },
13171         { 4, alc861_uniwill_m31_ch4_init },
13172 };
13173
13174 /* Set mic1 and line-in as input and unmute the mixer */
13175 static struct hda_verb alc861_asus_ch2_init[] = {
13176         /* set pin widget 1Ah (line in) for input */
13177         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13178         /* set pin widget 18h (mic1/2) for input, for mic also enable
13179          * the vref
13180          */
13181         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13182
13183         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13184 #if 0
13185         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13186         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13187 #endif
13188         { } /* end */
13189 };
13190 /* Set mic1 nad line-in as output and mute mixer */
13191 static struct hda_verb alc861_asus_ch6_init[] = {
13192         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13193         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13194         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13195         /* set pin widget 18h (mic1) for output (CLFE)*/
13196         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13197         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13198         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13199         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13200
13201         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13202 #if 0
13203         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13204         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13205 #endif
13206         { } /* end */
13207 };
13208
13209 static struct hda_channel_mode alc861_asus_modes[2] = {
13210         { 2, alc861_asus_ch2_init },
13211         { 6, alc861_asus_ch6_init },
13212 };
13213
13214 /* patch-ALC861 */
13215
13216 static struct snd_kcontrol_new alc861_base_mixer[] = {
13217         /* output mixer control */
13218         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13219         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13220         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13221         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13222         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13223
13224         /*Input mixer control */
13225         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13226            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13227         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13228         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13229         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13230         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13231         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13232         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13233         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13234         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13235
13236         { } /* end */
13237 };
13238
13239 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13240         /* output mixer control */
13241         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13242         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13243         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13244         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13245         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13246
13247         /* Input mixer control */
13248         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13249            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13250         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13251         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13252         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13253         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13254         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13255         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13256         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13257         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13258
13259         {
13260                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13261                 .name = "Channel Mode",
13262                 .info = alc_ch_mode_info,
13263                 .get = alc_ch_mode_get,
13264                 .put = alc_ch_mode_put,
13265                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13266         },
13267         { } /* end */
13268 };
13269
13270 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13271         /* output mixer control */
13272         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13273         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13274         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13275
13276         { } /* end */
13277 };
13278
13279 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13280         /* output mixer control */
13281         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13282         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13283         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13284         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13285         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13286
13287         /* Input mixer control */
13288         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13289            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13290         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13291         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13292         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13293         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13294         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13295         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13296         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13297         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13298
13299         {
13300                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13301                 .name = "Channel Mode",
13302                 .info = alc_ch_mode_info,
13303                 .get = alc_ch_mode_get,
13304                 .put = alc_ch_mode_put,
13305                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13306         },
13307         { } /* end */
13308 };
13309
13310 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13311         /* output mixer control */
13312         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13313         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13314         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13315         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13316         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13317
13318         /* Input mixer control */
13319         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13320         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13321         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13322         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13323         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13324         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13325         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13326         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13327         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13328         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13329
13330         {
13331                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13332                 .name = "Channel Mode",
13333                 .info = alc_ch_mode_info,
13334                 .get = alc_ch_mode_get,
13335                 .put = alc_ch_mode_put,
13336                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13337         },
13338         { }
13339 };
13340
13341 /* additional mixer */
13342 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13343         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13344         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13345         { }
13346 };
13347
13348 /*
13349  * generic initialization of ADC, input mixers and output mixers
13350  */
13351 static struct hda_verb alc861_base_init_verbs[] = {
13352         /*
13353          * Unmute ADC0 and set the default input to mic-in
13354          */
13355         /* port-A for surround (rear panel) */
13356         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13357         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13358         /* port-B for mic-in (rear panel) with vref */
13359         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13360         /* port-C for line-in (rear panel) */
13361         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13362         /* port-D for Front */
13363         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13364         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13365         /* port-E for HP out (front panel) */
13366         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13367         /* route front PCM to HP */
13368         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13369         /* port-F for mic-in (front panel) with vref */
13370         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13371         /* port-G for CLFE (rear panel) */
13372         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13373         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13374         /* port-H for side (rear panel) */
13375         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13376         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13377         /* CD-in */
13378         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13379         /* route front mic to ADC1*/
13380         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13381         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13382
13383         /* Unmute DAC0~3 & spdif out*/
13384         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13385         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13386         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13387         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13388         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13389
13390         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13391         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13392         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13393         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13394         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13395
13396         /* Unmute Stereo Mixer 15 */
13397         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13398         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13399         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13400         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13401
13402         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13403         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13404         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13405         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13406         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13407         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13408         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13409         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13410         /* hp used DAC 3 (Front) */
13411         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13412         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13413
13414         { }
13415 };
13416
13417 static struct hda_verb alc861_threestack_init_verbs[] = {
13418         /*
13419          * Unmute ADC0 and set the default input to mic-in
13420          */
13421         /* port-A for surround (rear panel) */
13422         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13423         /* port-B for mic-in (rear panel) with vref */
13424         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13425         /* port-C for line-in (rear panel) */
13426         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13427         /* port-D for Front */
13428         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13429         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13430         /* port-E for HP out (front panel) */
13431         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13432         /* route front PCM to HP */
13433         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13434         /* port-F for mic-in (front panel) with vref */
13435         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13436         /* port-G for CLFE (rear panel) */
13437         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13438         /* port-H for side (rear panel) */
13439         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13440         /* CD-in */
13441         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13442         /* route front mic to ADC1*/
13443         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13444         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13445         /* Unmute DAC0~3 & spdif out*/
13446         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13447         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13448         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13449         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13450         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13451
13452         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13453         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13454         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13455         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13456         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13457
13458         /* Unmute Stereo Mixer 15 */
13459         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13460         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13461         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13462         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13463
13464         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13465         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13466         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13467         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13468         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13469         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13470         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13471         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13472         /* hp used DAC 3 (Front) */
13473         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13474         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13475         { }
13476 };
13477
13478 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13479         /*
13480          * Unmute ADC0 and set the default input to mic-in
13481          */
13482         /* port-A for surround (rear panel) */
13483         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13484         /* port-B for mic-in (rear panel) with vref */
13485         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13486         /* port-C for line-in (rear panel) */
13487         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13488         /* port-D for Front */
13489         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13490         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13491         /* port-E for HP out (front panel) */
13492         /* this has to be set to VREF80 */
13493         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13494         /* route front PCM to HP */
13495         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13496         /* port-F for mic-in (front panel) with vref */
13497         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13498         /* port-G for CLFE (rear panel) */
13499         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13500         /* port-H for side (rear panel) */
13501         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13502         /* CD-in */
13503         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13504         /* route front mic to ADC1*/
13505         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13506         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13507         /* Unmute DAC0~3 & spdif out*/
13508         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13509         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13510         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13511         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13512         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13513
13514         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13515         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13516         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13517         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13518         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13519
13520         /* Unmute Stereo Mixer 15 */
13521         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13522         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13523         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13524         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13525
13526         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13527         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13528         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13529         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13530         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13531         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13532         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13533         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13534         /* hp used DAC 3 (Front) */
13535         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13536         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13537         { }
13538 };
13539
13540 static struct hda_verb alc861_asus_init_verbs[] = {
13541         /*
13542          * Unmute ADC0 and set the default input to mic-in
13543          */
13544         /* port-A for surround (rear panel)
13545          * according to codec#0 this is the HP jack
13546          */
13547         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13548         /* route front PCM to HP */
13549         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13550         /* port-B for mic-in (rear panel) with vref */
13551         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13552         /* port-C for line-in (rear panel) */
13553         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13554         /* port-D for Front */
13555         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13556         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13557         /* port-E for HP out (front panel) */
13558         /* this has to be set to VREF80 */
13559         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13560         /* route front PCM to HP */
13561         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13562         /* port-F for mic-in (front panel) with vref */
13563         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13564         /* port-G for CLFE (rear panel) */
13565         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13566         /* port-H for side (rear panel) */
13567         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13568         /* CD-in */
13569         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13570         /* route front mic to ADC1*/
13571         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13572         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13573         /* Unmute DAC0~3 & spdif out*/
13574         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13575         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13576         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13577         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13578         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13579         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13580         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13581         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13582         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13583         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13584
13585         /* Unmute Stereo Mixer 15 */
13586         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13587         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13588         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13589         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13590
13591         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13592         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13593         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13594         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13595         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13596         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13597         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13598         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13599         /* hp used DAC 3 (Front) */
13600         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13601         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13602         { }
13603 };
13604
13605 /* additional init verbs for ASUS laptops */
13606 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13607         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13608         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13609         { }
13610 };
13611
13612 /*
13613  * generic initialization of ADC, input mixers and output mixers
13614  */
13615 static struct hda_verb alc861_auto_init_verbs[] = {
13616         /*
13617          * Unmute ADC0 and set the default input to mic-in
13618          */
13619         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13620         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13621
13622         /* Unmute DAC0~3 & spdif out*/
13623         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13624         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13625         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13626         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13627         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13628
13629         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13630         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13631         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13632         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13633         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13634
13635         /* Unmute Stereo Mixer 15 */
13636         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13637         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13638         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13639         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13640
13641         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13642         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13643         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13644         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13645         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13646         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13647         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13648         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13649
13650         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13651         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13653         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13654         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13655         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13656         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13657         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13658
13659         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13660
13661         { }
13662 };
13663
13664 static struct hda_verb alc861_toshiba_init_verbs[] = {
13665         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13666
13667         { }
13668 };
13669
13670 /* toggle speaker-output according to the hp-jack state */
13671 static void alc861_toshiba_automute(struct hda_codec *codec)
13672 {
13673         unsigned int present;
13674
13675         present = snd_hda_codec_read(codec, 0x0f, 0,
13676                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13677         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13678                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13679         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13680                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13681 }
13682
13683 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13684                                        unsigned int res)
13685 {
13686         if ((res >> 26) == ALC880_HP_EVENT)
13687                 alc861_toshiba_automute(codec);
13688 }
13689
13690 /* pcm configuration: identiacal with ALC880 */
13691 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13692 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13693 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13694 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13695
13696
13697 #define ALC861_DIGOUT_NID       0x07
13698
13699 static struct hda_channel_mode alc861_8ch_modes[1] = {
13700         { 8, NULL }
13701 };
13702
13703 static hda_nid_t alc861_dac_nids[4] = {
13704         /* front, surround, clfe, side */
13705         0x03, 0x06, 0x05, 0x04
13706 };
13707
13708 static hda_nid_t alc660_dac_nids[3] = {
13709         /* front, clfe, surround */
13710         0x03, 0x05, 0x06
13711 };
13712
13713 static hda_nid_t alc861_adc_nids[1] = {
13714         /* ADC0-2 */
13715         0x08,
13716 };
13717
13718 static struct hda_input_mux alc861_capture_source = {
13719         .num_items = 5,
13720         .items = {
13721                 { "Mic", 0x0 },
13722                 { "Front Mic", 0x3 },
13723                 { "Line", 0x1 },
13724                 { "CD", 0x4 },
13725                 { "Mixer", 0x5 },
13726         },
13727 };
13728
13729 /* fill in the dac_nids table from the parsed pin configuration */
13730 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13731                                      const struct auto_pin_cfg *cfg)
13732 {
13733         int i;
13734         hda_nid_t nid;
13735
13736         spec->multiout.dac_nids = spec->private_dac_nids;
13737         for (i = 0; i < cfg->line_outs; i++) {
13738                 nid = cfg->line_out_pins[i];
13739                 if (nid) {
13740                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13741                                 continue;
13742                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13743                 }
13744         }
13745         spec->multiout.num_dacs = cfg->line_outs;
13746         return 0;
13747 }
13748
13749 /* add playback controls from the parsed DAC table */
13750 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13751                                              const struct auto_pin_cfg *cfg)
13752 {
13753         char name[32];
13754         static const char *chname[4] = {
13755                 "Front", "Surround", NULL /*CLFE*/, "Side"
13756         };
13757         hda_nid_t nid;
13758         int i, idx, err;
13759
13760         for (i = 0; i < cfg->line_outs; i++) {
13761                 nid = spec->multiout.dac_nids[i];
13762                 if (!nid)
13763                         continue;
13764                 if (nid == 0x05) {
13765                         /* Center/LFE */
13766                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13767                                           "Center Playback Switch",
13768                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13769                                                               HDA_OUTPUT));
13770                         if (err < 0)
13771                                 return err;
13772                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13773                                           "LFE Playback Switch",
13774                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13775                                                               HDA_OUTPUT));
13776                         if (err < 0)
13777                                 return err;
13778                 } else {
13779                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13780                              idx++)
13781                                 if (nid == alc861_dac_nids[idx])
13782                                         break;
13783                         sprintf(name, "%s Playback Switch", chname[idx]);
13784                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13785                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13786                                                               HDA_OUTPUT));
13787                         if (err < 0)
13788                                 return err;
13789                 }
13790         }
13791         return 0;
13792 }
13793
13794 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13795 {
13796         int err;
13797         hda_nid_t nid;
13798
13799         if (!pin)
13800                 return 0;
13801
13802         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13803                 nid = 0x03;
13804                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13805                                   "Headphone Playback Switch",
13806                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13807                 if (err < 0)
13808                         return err;
13809                 spec->multiout.hp_nid = nid;
13810         }
13811         return 0;
13812 }
13813
13814 /* create playback/capture controls for input pins */
13815 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13816                                                 const struct auto_pin_cfg *cfg)
13817 {
13818         struct hda_input_mux *imux = &spec->private_imux[0];
13819         int i, err, idx, idx1;
13820
13821         for (i = 0; i < AUTO_PIN_LAST; i++) {
13822                 switch (cfg->input_pins[i]) {
13823                 case 0x0c:
13824                         idx1 = 1;
13825                         idx = 2;        /* Line In */
13826                         break;
13827                 case 0x0f:
13828                         idx1 = 2;
13829                         idx = 2;        /* Line In */
13830                         break;
13831                 case 0x0d:
13832                         idx1 = 0;
13833                         idx = 1;        /* Mic In */
13834                         break;
13835                 case 0x10:
13836                         idx1 = 3;
13837                         idx = 1;        /* Mic In */
13838                         break;
13839                 case 0x11:
13840                         idx1 = 4;
13841                         idx = 0;        /* CD */
13842                         break;
13843                 default:
13844                         continue;
13845                 }
13846
13847                 err = new_analog_input(spec, cfg->input_pins[i],
13848                                        auto_pin_cfg_labels[i], idx, 0x15);
13849                 if (err < 0)
13850                         return err;
13851
13852                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13853                 imux->items[imux->num_items].index = idx1;
13854                 imux->num_items++;
13855         }
13856         return 0;
13857 }
13858
13859 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13860                                               hda_nid_t nid,
13861                                               int pin_type, int dac_idx)
13862 {
13863         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13864                             pin_type);
13865         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13866                             AMP_OUT_UNMUTE);
13867 }
13868
13869 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13870 {
13871         struct alc_spec *spec = codec->spec;
13872         int i;
13873
13874         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13875         for (i = 0; i < spec->autocfg.line_outs; i++) {
13876                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13877                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13878                 if (nid)
13879                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13880                                                           spec->multiout.dac_nids[i]);
13881         }
13882 }
13883
13884 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13885 {
13886         struct alc_spec *spec = codec->spec;
13887         hda_nid_t pin;
13888
13889         pin = spec->autocfg.hp_pins[0];
13890         if (pin) /* connect to front */
13891                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13892                                                   spec->multiout.dac_nids[0]);
13893         pin = spec->autocfg.speaker_pins[0];
13894         if (pin)
13895                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13896 }
13897
13898 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13899 {
13900         struct alc_spec *spec = codec->spec;
13901         int i;
13902
13903         for (i = 0; i < AUTO_PIN_LAST; i++) {
13904                 hda_nid_t nid = spec->autocfg.input_pins[i];
13905                 if (nid >= 0x0c && nid <= 0x11) {
13906                         snd_hda_codec_write(codec, nid, 0,
13907                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
13908                                             i <= AUTO_PIN_FRONT_MIC ?
13909                                             PIN_VREF80 : PIN_IN);
13910                 }
13911         }
13912 }
13913
13914 /* parse the BIOS configuration and set up the alc_spec */
13915 /* return 1 if successful, 0 if the proper config is not found,
13916  * or a negative error code
13917  */
13918 static int alc861_parse_auto_config(struct hda_codec *codec)
13919 {
13920         struct alc_spec *spec = codec->spec;
13921         int err;
13922         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13923
13924         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13925                                            alc861_ignore);
13926         if (err < 0)
13927                 return err;
13928         if (!spec->autocfg.line_outs)
13929                 return 0; /* can't find valid BIOS pin config */
13930
13931         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13932         if (err < 0)
13933                 return err;
13934         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13935         if (err < 0)
13936                 return err;
13937         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13938         if (err < 0)
13939                 return err;
13940         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13941         if (err < 0)
13942                 return err;
13943
13944         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13945
13946         if (spec->autocfg.dig_outs)
13947                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13948
13949         if (spec->kctls.list)
13950                 add_mixer(spec, spec->kctls.list);
13951
13952         add_verb(spec, alc861_auto_init_verbs);
13953
13954         spec->num_mux_defs = 1;
13955         spec->input_mux = &spec->private_imux[0];
13956
13957         spec->adc_nids = alc861_adc_nids;
13958         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13959         set_capture_mixer(spec);
13960
13961         store_pin_configs(codec);
13962         return 1;
13963 }
13964
13965 /* additional initialization for auto-configuration model */
13966 static void alc861_auto_init(struct hda_codec *codec)
13967 {
13968         struct alc_spec *spec = codec->spec;
13969         alc861_auto_init_multi_out(codec);
13970         alc861_auto_init_hp_out(codec);
13971         alc861_auto_init_analog_input(codec);
13972         if (spec->unsol_event)
13973                 alc_inithook(codec);
13974 }
13975
13976 #ifdef CONFIG_SND_HDA_POWER_SAVE
13977 static struct hda_amp_list alc861_loopbacks[] = {
13978         { 0x15, HDA_INPUT, 0 },
13979         { 0x15, HDA_INPUT, 1 },
13980         { 0x15, HDA_INPUT, 2 },
13981         { 0x15, HDA_INPUT, 3 },
13982         { } /* end */
13983 };
13984 #endif
13985
13986
13987 /*
13988  * configuration and preset
13989  */
13990 static const char *alc861_models[ALC861_MODEL_LAST] = {
13991         [ALC861_3ST]            = "3stack",
13992         [ALC660_3ST]            = "3stack-660",
13993         [ALC861_3ST_DIG]        = "3stack-dig",
13994         [ALC861_6ST_DIG]        = "6stack-dig",
13995         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13996         [ALC861_TOSHIBA]        = "toshiba",
13997         [ALC861_ASUS]           = "asus",
13998         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13999         [ALC861_AUTO]           = "auto",
14000 };
14001
14002 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14003         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14004         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14005         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14006         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14007         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14008         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14009         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14010         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14011          *        Any other models that need this preset?
14012          */
14013         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14014         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14015         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14016         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14017         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14018         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14019         /* FIXME: the below seems conflict */
14020         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14021         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14022         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14023         {}
14024 };
14025
14026 static struct alc_config_preset alc861_presets[] = {
14027         [ALC861_3ST] = {
14028                 .mixers = { alc861_3ST_mixer },
14029                 .init_verbs = { alc861_threestack_init_verbs },
14030                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14031                 .dac_nids = alc861_dac_nids,
14032                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14033                 .channel_mode = alc861_threestack_modes,
14034                 .need_dac_fix = 1,
14035                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14036                 .adc_nids = alc861_adc_nids,
14037                 .input_mux = &alc861_capture_source,
14038         },
14039         [ALC861_3ST_DIG] = {
14040                 .mixers = { alc861_base_mixer },
14041                 .init_verbs = { alc861_threestack_init_verbs },
14042                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14043                 .dac_nids = alc861_dac_nids,
14044                 .dig_out_nid = ALC861_DIGOUT_NID,
14045                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14046                 .channel_mode = alc861_threestack_modes,
14047                 .need_dac_fix = 1,
14048                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14049                 .adc_nids = alc861_adc_nids,
14050                 .input_mux = &alc861_capture_source,
14051         },
14052         [ALC861_6ST_DIG] = {
14053                 .mixers = { alc861_base_mixer },
14054                 .init_verbs = { alc861_base_init_verbs },
14055                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14056                 .dac_nids = alc861_dac_nids,
14057                 .dig_out_nid = ALC861_DIGOUT_NID,
14058                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14059                 .channel_mode = alc861_8ch_modes,
14060                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14061                 .adc_nids = alc861_adc_nids,
14062                 .input_mux = &alc861_capture_source,
14063         },
14064         [ALC660_3ST] = {
14065                 .mixers = { alc861_3ST_mixer },
14066                 .init_verbs = { alc861_threestack_init_verbs },
14067                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14068                 .dac_nids = alc660_dac_nids,
14069                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14070                 .channel_mode = alc861_threestack_modes,
14071                 .need_dac_fix = 1,
14072                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14073                 .adc_nids = alc861_adc_nids,
14074                 .input_mux = &alc861_capture_source,
14075         },
14076         [ALC861_UNIWILL_M31] = {
14077                 .mixers = { alc861_uniwill_m31_mixer },
14078                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14079                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14080                 .dac_nids = alc861_dac_nids,
14081                 .dig_out_nid = ALC861_DIGOUT_NID,
14082                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14083                 .channel_mode = alc861_uniwill_m31_modes,
14084                 .need_dac_fix = 1,
14085                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14086                 .adc_nids = alc861_adc_nids,
14087                 .input_mux = &alc861_capture_source,
14088         },
14089         [ALC861_TOSHIBA] = {
14090                 .mixers = { alc861_toshiba_mixer },
14091                 .init_verbs = { alc861_base_init_verbs,
14092                                 alc861_toshiba_init_verbs },
14093                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14094                 .dac_nids = alc861_dac_nids,
14095                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14096                 .channel_mode = alc883_3ST_2ch_modes,
14097                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14098                 .adc_nids = alc861_adc_nids,
14099                 .input_mux = &alc861_capture_source,
14100                 .unsol_event = alc861_toshiba_unsol_event,
14101                 .init_hook = alc861_toshiba_automute,
14102         },
14103         [ALC861_ASUS] = {
14104                 .mixers = { alc861_asus_mixer },
14105                 .init_verbs = { alc861_asus_init_verbs },
14106                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14107                 .dac_nids = alc861_dac_nids,
14108                 .dig_out_nid = ALC861_DIGOUT_NID,
14109                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14110                 .channel_mode = alc861_asus_modes,
14111                 .need_dac_fix = 1,
14112                 .hp_nid = 0x06,
14113                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14114                 .adc_nids = alc861_adc_nids,
14115                 .input_mux = &alc861_capture_source,
14116         },
14117         [ALC861_ASUS_LAPTOP] = {
14118                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14119                 .init_verbs = { alc861_asus_init_verbs,
14120                                 alc861_asus_laptop_init_verbs },
14121                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14122                 .dac_nids = alc861_dac_nids,
14123                 .dig_out_nid = ALC861_DIGOUT_NID,
14124                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14125                 .channel_mode = alc883_3ST_2ch_modes,
14126                 .need_dac_fix = 1,
14127                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14128                 .adc_nids = alc861_adc_nids,
14129                 .input_mux = &alc861_capture_source,
14130         },
14131 };
14132
14133
14134 static int patch_alc861(struct hda_codec *codec)
14135 {
14136         struct alc_spec *spec;
14137         int board_config;
14138         int err;
14139
14140         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14141         if (spec == NULL)
14142                 return -ENOMEM;
14143
14144         codec->spec = spec;
14145
14146         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14147                                                   alc861_models,
14148                                                   alc861_cfg_tbl);
14149
14150         if (board_config < 0) {
14151                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
14152                        "trying auto-probe from BIOS...\n");
14153                 board_config = ALC861_AUTO;
14154         }
14155
14156         if (board_config == ALC861_AUTO) {
14157                 /* automatic parse from the BIOS config */
14158                 err = alc861_parse_auto_config(codec);
14159                 if (err < 0) {
14160                         alc_free(codec);
14161                         return err;
14162                 } else if (!err) {
14163                         printk(KERN_INFO
14164                                "hda_codec: Cannot set up configuration "
14165                                "from BIOS.  Using base mode...\n");
14166                    board_config = ALC861_3ST_DIG;
14167                 }
14168         }
14169
14170         err = snd_hda_attach_beep_device(codec, 0x23);
14171         if (err < 0) {
14172                 alc_free(codec);
14173                 return err;
14174         }
14175
14176         if (board_config != ALC861_AUTO)
14177                 setup_preset(spec, &alc861_presets[board_config]);
14178
14179         spec->stream_name_analog = "ALC861 Analog";
14180         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14181         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14182
14183         spec->stream_name_digital = "ALC861 Digital";
14184         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14185         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14186
14187         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14188
14189         spec->vmaster_nid = 0x03;
14190
14191         codec->patch_ops = alc_patch_ops;
14192         if (board_config == ALC861_AUTO)
14193                 spec->init_hook = alc861_auto_init;
14194 #ifdef CONFIG_SND_HDA_POWER_SAVE
14195         if (!spec->loopback.amplist)
14196                 spec->loopback.amplist = alc861_loopbacks;
14197 #endif
14198         codec->proc_widget_hook = print_realtek_coef;
14199
14200         return 0;
14201 }
14202
14203 /*
14204  * ALC861-VD support
14205  *
14206  * Based on ALC882
14207  *
14208  * In addition, an independent DAC
14209  */
14210 #define ALC861VD_DIGOUT_NID     0x06
14211
14212 static hda_nid_t alc861vd_dac_nids[4] = {
14213         /* front, surr, clfe, side surr */
14214         0x02, 0x03, 0x04, 0x05
14215 };
14216
14217 /* dac_nids for ALC660vd are in a different order - according to
14218  * Realtek's driver.
14219  * This should probably tesult in a different mixer for 6stack models
14220  * of ALC660vd codecs, but for now there is only 3stack mixer
14221  * - and it is the same as in 861vd.
14222  * adc_nids in ALC660vd are (is) the same as in 861vd
14223  */
14224 static hda_nid_t alc660vd_dac_nids[3] = {
14225         /* front, rear, clfe, rear_surr */
14226         0x02, 0x04, 0x03
14227 };
14228
14229 static hda_nid_t alc861vd_adc_nids[1] = {
14230         /* ADC0 */
14231         0x09,
14232 };
14233
14234 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14235
14236 /* input MUX */
14237 /* FIXME: should be a matrix-type input source selection */
14238 static struct hda_input_mux alc861vd_capture_source = {
14239         .num_items = 4,
14240         .items = {
14241                 { "Mic", 0x0 },
14242                 { "Front Mic", 0x1 },
14243                 { "Line", 0x2 },
14244                 { "CD", 0x4 },
14245         },
14246 };
14247
14248 static struct hda_input_mux alc861vd_dallas_capture_source = {
14249         .num_items = 2,
14250         .items = {
14251                 { "Ext Mic", 0x0 },
14252                 { "Int Mic", 0x1 },
14253         },
14254 };
14255
14256 static struct hda_input_mux alc861vd_hp_capture_source = {
14257         .num_items = 2,
14258         .items = {
14259                 { "Front Mic", 0x0 },
14260                 { "ATAPI Mic", 0x1 },
14261         },
14262 };
14263
14264 /*
14265  * 2ch mode
14266  */
14267 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14268         { 2, NULL }
14269 };
14270
14271 /*
14272  * 6ch mode
14273  */
14274 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14275         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14276         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14277         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14278         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14279         { } /* end */
14280 };
14281
14282 /*
14283  * 8ch mode
14284  */
14285 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14286         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14287         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14288         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14289         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14290         { } /* end */
14291 };
14292
14293 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14294         { 6, alc861vd_6stack_ch6_init },
14295         { 8, alc861vd_6stack_ch8_init },
14296 };
14297
14298 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14299         {
14300                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14301                 .name = "Channel Mode",
14302                 .info = alc_ch_mode_info,
14303                 .get = alc_ch_mode_get,
14304                 .put = alc_ch_mode_put,
14305         },
14306         { } /* end */
14307 };
14308
14309 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14310  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14311  */
14312 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14313         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14314         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14315
14316         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14317         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14318
14319         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14320                                 HDA_OUTPUT),
14321         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14322                                 HDA_OUTPUT),
14323         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14324         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14325
14326         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14327         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14328
14329         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14330
14331         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14332         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14333         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14334
14335         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14336         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14337         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14338
14339         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14340         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14341
14342         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14343         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14344
14345         { } /* end */
14346 };
14347
14348 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14349         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14350         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14351
14352         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14353
14354         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14355         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14356         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14357
14358         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14359         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14360         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14361
14362         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14363         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14364
14365         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14366         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14367
14368         { } /* end */
14369 };
14370
14371 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14372         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14373         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14374         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14375
14376         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14377
14378         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14379         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14380         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14381
14382         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14383         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14384         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14385
14386         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14387         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14388
14389         { } /* end */
14390 };
14391
14392 /* Pin assignment: Speaker=0x14, HP = 0x15,
14393  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14394  */
14395 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14396         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14397         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14398         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14399         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14400         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14401         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14402         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14403         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14404         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14405         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14406         { } /* end */
14407 };
14408
14409 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14410  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14411  */
14412 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14413         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14414         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14415         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14416         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14417         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14418         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14419         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14420         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14421
14422         { } /* end */
14423 };
14424
14425 /*
14426  * generic initialization of ADC, input mixers and output mixers
14427  */
14428 static struct hda_verb alc861vd_volume_init_verbs[] = {
14429         /*
14430          * Unmute ADC0 and set the default input to mic-in
14431          */
14432         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14433         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14434
14435         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14436          * the analog-loopback mixer widget
14437          */
14438         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14439         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14440         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14441         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14442         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14443         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14444
14445         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14446         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14448         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14449         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14450
14451         /*
14452          * Set up output mixers (0x02 - 0x05)
14453          */
14454         /* set vol=0 to output mixers */
14455         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14456         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14457         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14458         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14459
14460         /* set up input amps for analog loopback */
14461         /* Amp Indices: DAC = 0, mixer = 1 */
14462         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14463         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14464         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14465         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14466         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14467         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14468         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14469         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14470
14471         { }
14472 };
14473
14474 /*
14475  * 3-stack pin configuration:
14476  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14477  */
14478 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14479         /*
14480          * Set pin mode and muting
14481          */
14482         /* set front pin widgets 0x14 for output */
14483         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14484         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14485         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14486
14487         /* Mic (rear) pin: input vref at 80% */
14488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14489         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14490         /* Front Mic pin: input vref at 80% */
14491         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14492         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14493         /* Line In pin: input */
14494         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14495         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14496         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14497         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14498         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14499         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14500         /* CD pin widget for input */
14501         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14502
14503         { }
14504 };
14505
14506 /*
14507  * 6-stack pin configuration:
14508  */
14509 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14510         /*
14511          * Set pin mode and muting
14512          */
14513         /* set front pin widgets 0x14 for output */
14514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14515         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14516         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14517
14518         /* Rear Pin: output 1 (0x0d) */
14519         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14520         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14521         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14522         /* CLFE Pin: output 2 (0x0e) */
14523         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14524         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14525         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14526         /* Side Pin: output 3 (0x0f) */
14527         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14528         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14529         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14530
14531         /* Mic (rear) pin: input vref at 80% */
14532         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14533         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14534         /* Front Mic pin: input vref at 80% */
14535         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14536         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14537         /* Line In pin: input */
14538         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14539         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14540         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14541         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14542         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14543         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14544         /* CD pin widget for input */
14545         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14546
14547         { }
14548 };
14549
14550 static struct hda_verb alc861vd_eapd_verbs[] = {
14551         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14552         { }
14553 };
14554
14555 static struct hda_verb alc660vd_eapd_verbs[] = {
14556         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14557         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14558         { }
14559 };
14560
14561 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14562         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14563         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14564         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14565         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14566         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14567         {}
14568 };
14569
14570 /* toggle speaker-output according to the hp-jack state */
14571 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14572 {
14573         unsigned int present;
14574         unsigned char bits;
14575
14576         present = snd_hda_codec_read(codec, 0x1b, 0,
14577                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14578         bits = present ? HDA_AMP_MUTE : 0;
14579         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14580                                  HDA_AMP_MUTE, bits);
14581 }
14582
14583 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14584 {
14585         unsigned int present;
14586         unsigned char bits;
14587
14588         present = snd_hda_codec_read(codec, 0x18, 0,
14589                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14590         bits = present ? HDA_AMP_MUTE : 0;
14591         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14592                                  HDA_AMP_MUTE, bits);
14593 }
14594
14595 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14596 {
14597         alc861vd_lenovo_hp_automute(codec);
14598         alc861vd_lenovo_mic_automute(codec);
14599 }
14600
14601 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14602                                         unsigned int res)
14603 {
14604         switch (res >> 26) {
14605         case ALC880_HP_EVENT:
14606                 alc861vd_lenovo_hp_automute(codec);
14607                 break;
14608         case ALC880_MIC_EVENT:
14609                 alc861vd_lenovo_mic_automute(codec);
14610                 break;
14611         }
14612 }
14613
14614 static struct hda_verb alc861vd_dallas_verbs[] = {
14615         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14616         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14617         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14618         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14619
14620         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14621         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14622         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14623         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14624         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14625         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14626         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14627         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14628
14629         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14630         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14631         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14632         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14633         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14634         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14635         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14636         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14637
14638         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14639         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14640         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14641         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14642         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14643         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14644         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14645         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14646
14647         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14648         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14649         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14650         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14651
14652         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14653         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14654         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14655
14656         { } /* end */
14657 };
14658
14659 /* toggle speaker-output according to the hp-jack state */
14660 static void alc861vd_dallas_automute(struct hda_codec *codec)
14661 {
14662         unsigned int present;
14663
14664         present = snd_hda_codec_read(codec, 0x15, 0,
14665                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14666         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14667                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14668 }
14669
14670 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14671 {
14672         if ((res >> 26) == ALC880_HP_EVENT)
14673                 alc861vd_dallas_automute(codec);
14674 }
14675
14676 #ifdef CONFIG_SND_HDA_POWER_SAVE
14677 #define alc861vd_loopbacks      alc880_loopbacks
14678 #endif
14679
14680 /* pcm configuration: identiacal with ALC880 */
14681 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14682 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14683 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14684 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14685
14686 /*
14687  * configuration and preset
14688  */
14689 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14690         [ALC660VD_3ST]          = "3stack-660",
14691         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14692         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14693         [ALC861VD_3ST]          = "3stack",
14694         [ALC861VD_3ST_DIG]      = "3stack-digout",
14695         [ALC861VD_6ST_DIG]      = "6stack-digout",
14696         [ALC861VD_LENOVO]       = "lenovo",
14697         [ALC861VD_DALLAS]       = "dallas",
14698         [ALC861VD_HP]           = "hp",
14699         [ALC861VD_AUTO]         = "auto",
14700 };
14701
14702 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14703         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14704         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14705         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14706         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14707         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14708         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14709         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14710         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14711         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14712         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14713         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14714         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14715         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14716         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14717         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14718         {}
14719 };
14720
14721 static struct alc_config_preset alc861vd_presets[] = {
14722         [ALC660VD_3ST] = {
14723                 .mixers = { alc861vd_3st_mixer },
14724                 .init_verbs = { alc861vd_volume_init_verbs,
14725                                  alc861vd_3stack_init_verbs },
14726                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14727                 .dac_nids = alc660vd_dac_nids,
14728                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14729                 .channel_mode = alc861vd_3stack_2ch_modes,
14730                 .input_mux = &alc861vd_capture_source,
14731         },
14732         [ALC660VD_3ST_DIG] = {
14733                 .mixers = { alc861vd_3st_mixer },
14734                 .init_verbs = { alc861vd_volume_init_verbs,
14735                                  alc861vd_3stack_init_verbs },
14736                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14737                 .dac_nids = alc660vd_dac_nids,
14738                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14739                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14740                 .channel_mode = alc861vd_3stack_2ch_modes,
14741                 .input_mux = &alc861vd_capture_source,
14742         },
14743         [ALC861VD_3ST] = {
14744                 .mixers = { alc861vd_3st_mixer },
14745                 .init_verbs = { alc861vd_volume_init_verbs,
14746                                  alc861vd_3stack_init_verbs },
14747                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14748                 .dac_nids = alc861vd_dac_nids,
14749                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14750                 .channel_mode = alc861vd_3stack_2ch_modes,
14751                 .input_mux = &alc861vd_capture_source,
14752         },
14753         [ALC861VD_3ST_DIG] = {
14754                 .mixers = { alc861vd_3st_mixer },
14755                 .init_verbs = { alc861vd_volume_init_verbs,
14756                                  alc861vd_3stack_init_verbs },
14757                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14758                 .dac_nids = alc861vd_dac_nids,
14759                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14760                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14761                 .channel_mode = alc861vd_3stack_2ch_modes,
14762                 .input_mux = &alc861vd_capture_source,
14763         },
14764         [ALC861VD_6ST_DIG] = {
14765                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14766                 .init_verbs = { alc861vd_volume_init_verbs,
14767                                 alc861vd_6stack_init_verbs },
14768                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14769                 .dac_nids = alc861vd_dac_nids,
14770                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14771                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14772                 .channel_mode = alc861vd_6stack_modes,
14773                 .input_mux = &alc861vd_capture_source,
14774         },
14775         [ALC861VD_LENOVO] = {
14776                 .mixers = { alc861vd_lenovo_mixer },
14777                 .init_verbs = { alc861vd_volume_init_verbs,
14778                                 alc861vd_3stack_init_verbs,
14779                                 alc861vd_eapd_verbs,
14780                                 alc861vd_lenovo_unsol_verbs },
14781                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14782                 .dac_nids = alc660vd_dac_nids,
14783                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14784                 .channel_mode = alc861vd_3stack_2ch_modes,
14785                 .input_mux = &alc861vd_capture_source,
14786                 .unsol_event = alc861vd_lenovo_unsol_event,
14787                 .init_hook = alc861vd_lenovo_automute,
14788         },
14789         [ALC861VD_DALLAS] = {
14790                 .mixers = { alc861vd_dallas_mixer },
14791                 .init_verbs = { alc861vd_dallas_verbs },
14792                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14793                 .dac_nids = alc861vd_dac_nids,
14794                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14795                 .channel_mode = alc861vd_3stack_2ch_modes,
14796                 .input_mux = &alc861vd_dallas_capture_source,
14797                 .unsol_event = alc861vd_dallas_unsol_event,
14798                 .init_hook = alc861vd_dallas_automute,
14799         },
14800         [ALC861VD_HP] = {
14801                 .mixers = { alc861vd_hp_mixer },
14802                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14803                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14804                 .dac_nids = alc861vd_dac_nids,
14805                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14806                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14807                 .channel_mode = alc861vd_3stack_2ch_modes,
14808                 .input_mux = &alc861vd_hp_capture_source,
14809                 .unsol_event = alc861vd_dallas_unsol_event,
14810                 .init_hook = alc861vd_dallas_automute,
14811         },
14812         [ALC660VD_ASUS_V1S] = {
14813                 .mixers = { alc861vd_lenovo_mixer },
14814                 .init_verbs = { alc861vd_volume_init_verbs,
14815                                 alc861vd_3stack_init_verbs,
14816                                 alc861vd_eapd_verbs,
14817                                 alc861vd_lenovo_unsol_verbs },
14818                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14819                 .dac_nids = alc660vd_dac_nids,
14820                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14821                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14822                 .channel_mode = alc861vd_3stack_2ch_modes,
14823                 .input_mux = &alc861vd_capture_source,
14824                 .unsol_event = alc861vd_lenovo_unsol_event,
14825                 .init_hook = alc861vd_lenovo_automute,
14826         },
14827 };
14828
14829 /*
14830  * BIOS auto configuration
14831  */
14832 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14833                                 hda_nid_t nid, int pin_type, int dac_idx)
14834 {
14835         alc_set_pin_output(codec, nid, pin_type);
14836 }
14837
14838 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14839 {
14840         struct alc_spec *spec = codec->spec;
14841         int i;
14842
14843         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14844         for (i = 0; i <= HDA_SIDE; i++) {
14845                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14846                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14847                 if (nid)
14848                         alc861vd_auto_set_output_and_unmute(codec, nid,
14849                                                             pin_type, i);
14850         }
14851 }
14852
14853
14854 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14855 {
14856         struct alc_spec *spec = codec->spec;
14857         hda_nid_t pin;
14858
14859         pin = spec->autocfg.hp_pins[0];
14860         if (pin) /* connect to front and  use dac 0 */
14861                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14862         pin = spec->autocfg.speaker_pins[0];
14863         if (pin)
14864                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14865 }
14866
14867 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14868 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14869
14870 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14871 {
14872         struct alc_spec *spec = codec->spec;
14873         int i;
14874
14875         for (i = 0; i < AUTO_PIN_LAST; i++) {
14876                 hda_nid_t nid = spec->autocfg.input_pins[i];
14877                 if (alc861vd_is_input_pin(nid)) {
14878                         snd_hda_codec_write(codec, nid, 0,
14879                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
14880                                         i <= AUTO_PIN_FRONT_MIC ?
14881                                                         PIN_VREF80 : PIN_IN);
14882                         if (nid != ALC861VD_PIN_CD_NID)
14883                                 snd_hda_codec_write(codec, nid, 0,
14884                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14885                                                 AMP_OUT_MUTE);
14886                 }
14887         }
14888 }
14889
14890 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14891
14892 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14893 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14894
14895 /* add playback controls from the parsed DAC table */
14896 /* Based on ALC880 version. But ALC861VD has separate,
14897  * different NIDs for mute/unmute switch and volume control */
14898 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14899                                              const struct auto_pin_cfg *cfg)
14900 {
14901         char name[32];
14902         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14903         hda_nid_t nid_v, nid_s;
14904         int i, err;
14905
14906         for (i = 0; i < cfg->line_outs; i++) {
14907                 if (!spec->multiout.dac_nids[i])
14908                         continue;
14909                 nid_v = alc861vd_idx_to_mixer_vol(
14910                                 alc880_dac_to_idx(
14911                                         spec->multiout.dac_nids[i]));
14912                 nid_s = alc861vd_idx_to_mixer_switch(
14913                                 alc880_dac_to_idx(
14914                                         spec->multiout.dac_nids[i]));
14915
14916                 if (i == 2) {
14917                         /* Center/LFE */
14918                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14919                                           "Center Playback Volume",
14920                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14921                                                               HDA_OUTPUT));
14922                         if (err < 0)
14923                                 return err;
14924                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14925                                           "LFE Playback Volume",
14926                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14927                                                               HDA_OUTPUT));
14928                         if (err < 0)
14929                                 return err;
14930                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14931                                           "Center Playback Switch",
14932                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14933                                                               HDA_INPUT));
14934                         if (err < 0)
14935                                 return err;
14936                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14937                                           "LFE Playback Switch",
14938                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14939                                                               HDA_INPUT));
14940                         if (err < 0)
14941                                 return err;
14942                 } else {
14943                         sprintf(name, "%s Playback Volume", chname[i]);
14944                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14945                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14946                                                               HDA_OUTPUT));
14947                         if (err < 0)
14948                                 return err;
14949                         sprintf(name, "%s Playback Switch", chname[i]);
14950                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14951                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14952                                                               HDA_INPUT));
14953                         if (err < 0)
14954                                 return err;
14955                 }
14956         }
14957         return 0;
14958 }
14959
14960 /* add playback controls for speaker and HP outputs */
14961 /* Based on ALC880 version. But ALC861VD has separate,
14962  * different NIDs for mute/unmute switch and volume control */
14963 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14964                                         hda_nid_t pin, const char *pfx)
14965 {
14966         hda_nid_t nid_v, nid_s;
14967         int err;
14968         char name[32];
14969
14970         if (!pin)
14971                 return 0;
14972
14973         if (alc880_is_fixed_pin(pin)) {
14974                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14975                 /* specify the DAC as the extra output */
14976                 if (!spec->multiout.hp_nid)
14977                         spec->multiout.hp_nid = nid_v;
14978                 else
14979                         spec->multiout.extra_out_nid[0] = nid_v;
14980                 /* control HP volume/switch on the output mixer amp */
14981                 nid_v = alc861vd_idx_to_mixer_vol(
14982                                 alc880_fixed_pin_idx(pin));
14983                 nid_s = alc861vd_idx_to_mixer_switch(
14984                                 alc880_fixed_pin_idx(pin));
14985
14986                 sprintf(name, "%s Playback Volume", pfx);
14987                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14988                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14989                 if (err < 0)
14990                         return err;
14991                 sprintf(name, "%s Playback Switch", pfx);
14992                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14993                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14994                 if (err < 0)
14995                         return err;
14996         } else if (alc880_is_multi_pin(pin)) {
14997                 /* set manual connection */
14998                 /* we have only a switch on HP-out PIN */
14999                 sprintf(name, "%s Playback Switch", pfx);
15000                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15001                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15002                 if (err < 0)
15003                         return err;
15004         }
15005         return 0;
15006 }
15007
15008 /* parse the BIOS configuration and set up the alc_spec
15009  * return 1 if successful, 0 if the proper config is not found,
15010  * or a negative error code
15011  * Based on ALC880 version - had to change it to override
15012  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15013 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15014 {
15015         struct alc_spec *spec = codec->spec;
15016         int err;
15017         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15018
15019         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15020                                            alc861vd_ignore);
15021         if (err < 0)
15022                 return err;
15023         if (!spec->autocfg.line_outs)
15024                 return 0; /* can't find valid BIOS pin config */
15025
15026         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15027         if (err < 0)
15028                 return err;
15029         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15030         if (err < 0)
15031                 return err;
15032         err = alc861vd_auto_create_extra_out(spec,
15033                                              spec->autocfg.speaker_pins[0],
15034                                              "Speaker");
15035         if (err < 0)
15036                 return err;
15037         err = alc861vd_auto_create_extra_out(spec,
15038                                              spec->autocfg.hp_pins[0],
15039                                              "Headphone");
15040         if (err < 0)
15041                 return err;
15042         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15043         if (err < 0)
15044                 return err;
15045
15046         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15047
15048         if (spec->autocfg.dig_outs)
15049                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15050
15051         if (spec->kctls.list)
15052                 add_mixer(spec, spec->kctls.list);
15053
15054         add_verb(spec, alc861vd_volume_init_verbs);
15055
15056         spec->num_mux_defs = 1;
15057         spec->input_mux = &spec->private_imux[0];
15058
15059         err = alc_auto_add_mic_boost(codec);
15060         if (err < 0)
15061                 return err;
15062
15063         store_pin_configs(codec);
15064         return 1;
15065 }
15066
15067 /* additional initialization for auto-configuration model */
15068 static void alc861vd_auto_init(struct hda_codec *codec)
15069 {
15070         struct alc_spec *spec = codec->spec;
15071         alc861vd_auto_init_multi_out(codec);
15072         alc861vd_auto_init_hp_out(codec);
15073         alc861vd_auto_init_analog_input(codec);
15074         alc861vd_auto_init_input_src(codec);
15075         if (spec->unsol_event)
15076                 alc_inithook(codec);
15077 }
15078
15079 static int patch_alc861vd(struct hda_codec *codec)
15080 {
15081         struct alc_spec *spec;
15082         int err, board_config;
15083
15084         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15085         if (spec == NULL)
15086                 return -ENOMEM;
15087
15088         codec->spec = spec;
15089
15090         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15091                                                   alc861vd_models,
15092                                                   alc861vd_cfg_tbl);
15093
15094         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15095                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
15096                         "ALC861VD, trying auto-probe from BIOS...\n");
15097                 board_config = ALC861VD_AUTO;
15098         }
15099
15100         if (board_config == ALC861VD_AUTO) {
15101                 /* automatic parse from the BIOS config */
15102                 err = alc861vd_parse_auto_config(codec);
15103                 if (err < 0) {
15104                         alc_free(codec);
15105                         return err;
15106                 } else if (!err) {
15107                         printk(KERN_INFO
15108                                "hda_codec: Cannot set up configuration "
15109                                "from BIOS.  Using base mode...\n");
15110                         board_config = ALC861VD_3ST;
15111                 }
15112         }
15113
15114         err = snd_hda_attach_beep_device(codec, 0x23);
15115         if (err < 0) {
15116                 alc_free(codec);
15117                 return err;
15118         }
15119
15120         if (board_config != ALC861VD_AUTO)
15121                 setup_preset(spec, &alc861vd_presets[board_config]);
15122
15123         if (codec->vendor_id == 0x10ec0660) {
15124                 spec->stream_name_analog = "ALC660-VD Analog";
15125                 spec->stream_name_digital = "ALC660-VD Digital";
15126                 /* always turn on EAPD */
15127                 add_verb(spec, alc660vd_eapd_verbs);
15128         } else {
15129                 spec->stream_name_analog = "ALC861VD Analog";
15130                 spec->stream_name_digital = "ALC861VD Digital";
15131         }
15132
15133         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15134         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15135
15136         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15137         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15138
15139         spec->adc_nids = alc861vd_adc_nids;
15140         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15141         spec->capsrc_nids = alc861vd_capsrc_nids;
15142         spec->capture_style = CAPT_MIX;
15143
15144         set_capture_mixer(spec);
15145         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15146
15147         spec->vmaster_nid = 0x02;
15148
15149         codec->patch_ops = alc_patch_ops;
15150
15151         if (board_config == ALC861VD_AUTO)
15152                 spec->init_hook = alc861vd_auto_init;
15153 #ifdef CONFIG_SND_HDA_POWER_SAVE
15154         if (!spec->loopback.amplist)
15155                 spec->loopback.amplist = alc861vd_loopbacks;
15156 #endif
15157         codec->proc_widget_hook = print_realtek_coef;
15158
15159         return 0;
15160 }
15161
15162 /*
15163  * ALC662 support
15164  *
15165  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15166  * configuration.  Each pin widget can choose any input DACs and a mixer.
15167  * Each ADC is connected from a mixer of all inputs.  This makes possible
15168  * 6-channel independent captures.
15169  *
15170  * In addition, an independent DAC for the multi-playback (not used in this
15171  * driver yet).
15172  */
15173 #define ALC662_DIGOUT_NID       0x06
15174 #define ALC662_DIGIN_NID        0x0a
15175
15176 static hda_nid_t alc662_dac_nids[4] = {
15177         /* front, rear, clfe, rear_surr */
15178         0x02, 0x03, 0x04
15179 };
15180
15181 static hda_nid_t alc662_adc_nids[1] = {
15182         /* ADC1-2 */
15183         0x09,
15184 };
15185
15186 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15187
15188 /* input MUX */
15189 /* FIXME: should be a matrix-type input source selection */
15190 static struct hda_input_mux alc662_capture_source = {
15191         .num_items = 4,
15192         .items = {
15193                 { "Mic", 0x0 },
15194                 { "Front Mic", 0x1 },
15195                 { "Line", 0x2 },
15196                 { "CD", 0x4 },
15197         },
15198 };
15199
15200 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15201         .num_items = 2,
15202         .items = {
15203                 { "Mic", 0x1 },
15204                 { "Line", 0x2 },
15205         },
15206 };
15207
15208 static struct hda_input_mux alc662_eeepc_capture_source = {
15209         .num_items = 2,
15210         .items = {
15211                 { "i-Mic", 0x1 },
15212                 { "e-Mic", 0x0 },
15213         },
15214 };
15215
15216 static struct hda_input_mux alc663_capture_source = {
15217         .num_items = 3,
15218         .items = {
15219                 { "Mic", 0x0 },
15220                 { "Front Mic", 0x1 },
15221                 { "Line", 0x2 },
15222         },
15223 };
15224
15225 static struct hda_input_mux alc663_m51va_capture_source = {
15226         .num_items = 2,
15227         .items = {
15228                 { "Ext-Mic", 0x0 },
15229                 { "D-Mic", 0x9 },
15230         },
15231 };
15232
15233 /*
15234  * 2ch mode
15235  */
15236 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15237         { 2, NULL }
15238 };
15239
15240 /*
15241  * 2ch mode
15242  */
15243 static struct hda_verb alc662_3ST_ch2_init[] = {
15244         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15245         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15246         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15247         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15248         { } /* end */
15249 };
15250
15251 /*
15252  * 6ch mode
15253  */
15254 static struct hda_verb alc662_3ST_ch6_init[] = {
15255         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15256         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15257         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15258         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15259         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15260         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15261         { } /* end */
15262 };
15263
15264 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15265         { 2, alc662_3ST_ch2_init },
15266         { 6, alc662_3ST_ch6_init },
15267 };
15268
15269 /*
15270  * 2ch mode
15271  */
15272 static struct hda_verb alc662_sixstack_ch6_init[] = {
15273         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15274         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15275         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15276         { } /* end */
15277 };
15278
15279 /*
15280  * 6ch mode
15281  */
15282 static struct hda_verb alc662_sixstack_ch8_init[] = {
15283         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15284         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15285         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15286         { } /* end */
15287 };
15288
15289 static struct hda_channel_mode alc662_5stack_modes[2] = {
15290         { 2, alc662_sixstack_ch6_init },
15291         { 6, alc662_sixstack_ch8_init },
15292 };
15293
15294 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15295  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15296  */
15297
15298 static struct snd_kcontrol_new alc662_base_mixer[] = {
15299         /* output mixer control */
15300         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15301         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15302         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15303         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15304         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15305         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15306         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15307         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15308         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15309
15310         /*Input mixer control */
15311         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15312         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15313         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15314         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15315         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15316         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15317         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15318         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15319         { } /* end */
15320 };
15321
15322 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15323         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15324         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15325         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15326         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15327         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15328         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15329         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15330         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15331         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15332         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15333         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15334         { } /* end */
15335 };
15336
15337 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15338         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15339         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15340         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15341         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15342         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15343         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15344         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15345         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15346         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15347         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15348         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15349         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15350         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15351         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15352         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15353         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15354         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15355         { } /* end */
15356 };
15357
15358 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15359         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15360         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15361         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15362         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15363         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15364         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15365         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15366         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15367         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15368         { } /* end */
15369 };
15370
15371 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15372         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15373
15374         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15375         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15376
15377         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15378         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15379         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15380
15381         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15382         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15383         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15384         { } /* end */
15385 };
15386
15387 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15388         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15389         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15390         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15391         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15392         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15393         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15394         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15395         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15396         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15397         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15398         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15399         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15400         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15401         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15402         { } /* end */
15403 };
15404
15405 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15406         .ops = &snd_hda_bind_vol,
15407         .values = {
15408                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15409                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15410                 0
15411         },
15412 };
15413
15414 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15415         .ops = &snd_hda_bind_sw,
15416         .values = {
15417                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15418                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15419                 0
15420         },
15421 };
15422
15423 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15424         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15425         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15426         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15427         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15428         { } /* end */
15429 };
15430
15431 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15432         .ops = &snd_hda_bind_sw,
15433         .values = {
15434                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15435                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15436                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15437                 0
15438         },
15439 };
15440
15441 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15442         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15443         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15444         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15445         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15446         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15447         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15448
15449         { } /* end */
15450 };
15451
15452 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15453         .ops = &snd_hda_bind_sw,
15454         .values = {
15455                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15456                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15457                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15458                 0
15459         },
15460 };
15461
15462 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15463         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15464         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15465         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15466         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15467         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15468         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15469         { } /* end */
15470 };
15471
15472 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15473         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15474         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15475         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15476         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15477         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15478         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15479         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15480         { } /* end */
15481 };
15482
15483 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15484         .ops = &snd_hda_bind_vol,
15485         .values = {
15486                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15487                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15488                 0
15489         },
15490 };
15491
15492 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15493         .ops = &snd_hda_bind_sw,
15494         .values = {
15495                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15496                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15497                 0
15498         },
15499 };
15500
15501 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15502         HDA_BIND_VOL("Master Playback Volume",
15503                                 &alc663_asus_two_bind_master_vol),
15504         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15505         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15506         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15507         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15508         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15509         { } /* end */
15510 };
15511
15512 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15513         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15514         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15515         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15516         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15517         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15518         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15519         { } /* end */
15520 };
15521
15522 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15523         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15524         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15525         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15526         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15527         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15528
15529         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15530         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15531         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15532         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15533         { } /* end */
15534 };
15535
15536 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15537         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15538         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15539         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15540
15541         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15542         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15543         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15544         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15545         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15546         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15547         { } /* end */
15548 };
15549
15550 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15551         {
15552                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15553                 .name = "Channel Mode",
15554                 .info = alc_ch_mode_info,
15555                 .get = alc_ch_mode_get,
15556                 .put = alc_ch_mode_put,
15557         },
15558         { } /* end */
15559 };
15560
15561 static struct hda_verb alc662_init_verbs[] = {
15562         /* ADC: mute amp left and right */
15563         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15564         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15565         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15566
15567         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15572
15573         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15574         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15575         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15576         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15577         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15578         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15579
15580         /* Front Pin: output 0 (0x0c) */
15581         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15582         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15583
15584         /* Rear Pin: output 1 (0x0d) */
15585         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15586         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15587
15588         /* CLFE Pin: output 2 (0x0e) */
15589         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15590         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15591
15592         /* Mic (rear) pin: input vref at 80% */
15593         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15594         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15595         /* Front Mic pin: input vref at 80% */
15596         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15597         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15598         /* Line In pin: input */
15599         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15600         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15601         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15602         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15603         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15604         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15605         /* CD pin widget for input */
15606         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15607
15608         /* FIXME: use matrix-type input source selection */
15609         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15610         /* Input mixer */
15611         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15612         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15613         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15614         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15615
15616         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15617         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15618         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15619         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15620
15621         /* always trun on EAPD */
15622         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15623         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15624
15625         { }
15626 };
15627
15628 static struct hda_verb alc662_sue_init_verbs[] = {
15629         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15630         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15631         {}
15632 };
15633
15634 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15635         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15636         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15637         {}
15638 };
15639
15640 /* Set Unsolicited Event*/
15641 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15642         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15643         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15644         {}
15645 };
15646
15647 /*
15648  * generic initialization of ADC, input mixers and output mixers
15649  */
15650 static struct hda_verb alc662_auto_init_verbs[] = {
15651         /*
15652          * Unmute ADC and set the default input to mic-in
15653          */
15654         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15655         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15656
15657         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15658          * mixer widget
15659          * Note: PASD motherboards uses the Line In 2 as the input for front
15660          * panel mic (mic 2)
15661          */
15662         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15663         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15664         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15665         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15666         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15667         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15668
15669         /*
15670          * Set up output mixers (0x0c - 0x0f)
15671          */
15672         /* set vol=0 to output mixers */
15673         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15674         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15675         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15676
15677         /* set up input amps for analog loopback */
15678         /* Amp Indices: DAC = 0, mixer = 1 */
15679         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15680         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15681         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15682         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15683         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15684         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15685
15686
15687         /* FIXME: use matrix-type input source selection */
15688         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15689         /* Input mixer */
15690         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15691         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15692         { }
15693 };
15694
15695 /* additional verbs for ALC663 */
15696 static struct hda_verb alc663_auto_init_verbs[] = {
15697         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15698         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15699         { }
15700 };
15701
15702 static struct hda_verb alc663_m51va_init_verbs[] = {
15703         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15704         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15705         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15706         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15707         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15708         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15709         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15710         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15711         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15712         {}
15713 };
15714
15715 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15716         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15717         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15718         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15719         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15720         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15721         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15722         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15723         {}
15724 };
15725
15726 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15727         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15728         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15729         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15730         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15731         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15732         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15733         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15734         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15735         {}
15736 };
15737
15738 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15739         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15740         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15741         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15742         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15743         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15744         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15745         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15746         {}
15747 };
15748
15749 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15750         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15751         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15752         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15753         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15754         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15755         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15756         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15757         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15758         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15759         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15760         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15761         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15762         {}
15763 };
15764
15765 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15766         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15767         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15768         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15769         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15770         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15771         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15772         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15773         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15774         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15775         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15776         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15777         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15778         {}
15779 };
15780
15781 static struct hda_verb alc663_g71v_init_verbs[] = {
15782         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15783         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15784         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15785
15786         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15787         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15788         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15789
15790         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15791         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15792         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15793         {}
15794 };
15795
15796 static struct hda_verb alc663_g50v_init_verbs[] = {
15797         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15798         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15799         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15800
15801         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15802         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15803         {}
15804 };
15805
15806 static struct hda_verb alc662_ecs_init_verbs[] = {
15807         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15808         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15809         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15810         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15811         {}
15812 };
15813
15814 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15815         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15816         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15817         { } /* end */
15818 };
15819
15820 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15821 {
15822         unsigned int present;
15823         unsigned char bits;
15824
15825         present = snd_hda_codec_read(codec, 0x14, 0,
15826                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15827         bits = present ? HDA_AMP_MUTE : 0;
15828         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15829                                  HDA_AMP_MUTE, bits);
15830 }
15831
15832 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15833 {
15834         unsigned int present;
15835         unsigned char bits;
15836
15837         present = snd_hda_codec_read(codec, 0x1b, 0,
15838                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15839         bits = present ? HDA_AMP_MUTE : 0;
15840         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15841                                  HDA_AMP_MUTE, bits);
15842         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15843                                  HDA_AMP_MUTE, bits);
15844 }
15845
15846 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15847                                            unsigned int res)
15848 {
15849         if ((res >> 26) == ALC880_HP_EVENT)
15850                 alc662_lenovo_101e_all_automute(codec);
15851         if ((res >> 26) == ALC880_FRONT_EVENT)
15852                 alc662_lenovo_101e_ispeaker_automute(codec);
15853 }
15854
15855 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15856 {
15857         unsigned int present;
15858
15859         present = snd_hda_codec_read(codec, 0x18, 0,
15860                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15861         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15862                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15863         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15864                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15865         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15866                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15867         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15868                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15869 }
15870
15871 /* unsolicited event for HP jack sensing */
15872 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15873                                      unsigned int res)
15874 {
15875         if ((res >> 26) == ALC880_HP_EVENT)
15876                 alc262_hippo1_automute( codec );
15877
15878         if ((res >> 26) == ALC880_MIC_EVENT)
15879                 alc662_eeepc_mic_automute(codec);
15880 }
15881
15882 static void alc662_eeepc_inithook(struct hda_codec *codec)
15883 {
15884         alc262_hippo1_automute( codec );
15885         alc662_eeepc_mic_automute(codec);
15886 }
15887
15888 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15889 {
15890         unsigned int mute;
15891         unsigned int present;
15892
15893         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15894         present = snd_hda_codec_read(codec, 0x14, 0,
15895                                      AC_VERB_GET_PIN_SENSE, 0);
15896         present = (present & 0x80000000) != 0;
15897         if (present) {
15898                 /* mute internal speaker */
15899                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15900                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15901         } else {
15902                 /* unmute internal speaker if necessary */
15903                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15904                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15905                                         HDA_AMP_MUTE, mute);
15906         }
15907 }
15908
15909 /* unsolicited event for HP jack sensing */
15910 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15911                                           unsigned int res)
15912 {
15913         if ((res >> 26) == ALC880_HP_EVENT)
15914                 alc662_eeepc_ep20_automute(codec);
15915 }
15916
15917 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15918 {
15919         alc662_eeepc_ep20_automute(codec);
15920 }
15921
15922 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15923 {
15924         unsigned int present;
15925         unsigned char bits;
15926
15927         present = snd_hda_codec_read(codec, 0x21, 0,
15928                         AC_VERB_GET_PIN_SENSE, 0)
15929                         & AC_PINSENSE_PRESENCE;
15930         bits = present ? HDA_AMP_MUTE : 0;
15931         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15932                                 AMP_IN_MUTE(0), bits);
15933         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15934                                 AMP_IN_MUTE(0), bits);
15935 }
15936
15937 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15938 {
15939         unsigned int present;
15940         unsigned char bits;
15941
15942         present = snd_hda_codec_read(codec, 0x21, 0,
15943                         AC_VERB_GET_PIN_SENSE, 0)
15944                         & AC_PINSENSE_PRESENCE;
15945         bits = present ? HDA_AMP_MUTE : 0;
15946         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15947                                 AMP_IN_MUTE(0), bits);
15948         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15949                                 AMP_IN_MUTE(0), bits);
15950         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15951                                 AMP_IN_MUTE(0), bits);
15952         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15953                                 AMP_IN_MUTE(0), bits);
15954 }
15955
15956 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15957 {
15958         unsigned int present;
15959         unsigned char bits;
15960
15961         present = snd_hda_codec_read(codec, 0x15, 0,
15962                         AC_VERB_GET_PIN_SENSE, 0)
15963                         & AC_PINSENSE_PRESENCE;
15964         bits = present ? HDA_AMP_MUTE : 0;
15965         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15966                                 AMP_IN_MUTE(0), bits);
15967         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15968                                 AMP_IN_MUTE(0), bits);
15969         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15970                                 AMP_IN_MUTE(0), bits);
15971         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15972                                 AMP_IN_MUTE(0), bits);
15973 }
15974
15975 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15976 {
15977         unsigned int present;
15978         unsigned char bits;
15979
15980         present = snd_hda_codec_read(codec, 0x1b, 0,
15981                         AC_VERB_GET_PIN_SENSE, 0)
15982                         & AC_PINSENSE_PRESENCE;
15983         bits = present ? 0 : PIN_OUT;
15984         snd_hda_codec_write(codec, 0x14, 0,
15985                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15986 }
15987
15988 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15989 {
15990         unsigned int present1, present2;
15991
15992         present1 = snd_hda_codec_read(codec, 0x21, 0,
15993                         AC_VERB_GET_PIN_SENSE, 0)
15994                         & AC_PINSENSE_PRESENCE;
15995         present2 = snd_hda_codec_read(codec, 0x15, 0,
15996                         AC_VERB_GET_PIN_SENSE, 0)
15997                         & AC_PINSENSE_PRESENCE;
15998
15999         if (present1 || present2) {
16000                 snd_hda_codec_write_cache(codec, 0x14, 0,
16001                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16002         } else {
16003                 snd_hda_codec_write_cache(codec, 0x14, 0,
16004                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16005         }
16006 }
16007
16008 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16009 {
16010         unsigned int present1, present2;
16011
16012         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16013                                 AC_VERB_GET_PIN_SENSE, 0)
16014                                 & AC_PINSENSE_PRESENCE;
16015         present2 = snd_hda_codec_read(codec, 0x15, 0,
16016                                 AC_VERB_GET_PIN_SENSE, 0)
16017                                 & AC_PINSENSE_PRESENCE;
16018
16019         if (present1 || present2) {
16020                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16021                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16022                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16023                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16024         } else {
16025                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16026                                 AMP_IN_MUTE(0), 0);
16027                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16028                                 AMP_IN_MUTE(0), 0);
16029         }
16030 }
16031
16032 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16033 {
16034         unsigned int present;
16035
16036         present = snd_hda_codec_read(codec, 0x18, 0,
16037                         AC_VERB_GET_PIN_SENSE, 0)
16038                         & AC_PINSENSE_PRESENCE;
16039         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16040                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16041         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16042                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16043         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16044                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16045         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16046                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16047 }
16048
16049 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16050                                            unsigned int res)
16051 {
16052         switch (res >> 26) {
16053         case ALC880_HP_EVENT:
16054                 alc663_m51va_speaker_automute(codec);
16055                 break;
16056         case ALC880_MIC_EVENT:
16057                 alc663_m51va_mic_automute(codec);
16058                 break;
16059         }
16060 }
16061
16062 static void alc663_m51va_inithook(struct hda_codec *codec)
16063 {
16064         alc663_m51va_speaker_automute(codec);
16065         alc663_m51va_mic_automute(codec);
16066 }
16067
16068 /* ***************** Mode1 ******************************/
16069 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16070                                            unsigned int res)
16071 {
16072         switch (res >> 26) {
16073         case ALC880_HP_EVENT:
16074                 alc663_m51va_speaker_automute(codec);
16075                 break;
16076         case ALC880_MIC_EVENT:
16077                 alc662_eeepc_mic_automute(codec);
16078                 break;
16079         }
16080 }
16081
16082 static void alc663_mode1_inithook(struct hda_codec *codec)
16083 {
16084         alc663_m51va_speaker_automute(codec);
16085         alc662_eeepc_mic_automute(codec);
16086 }
16087 /* ***************** Mode2 ******************************/
16088 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16089                                            unsigned int res)
16090 {
16091         switch (res >> 26) {
16092         case ALC880_HP_EVENT:
16093                 alc662_f5z_speaker_automute(codec);
16094                 break;
16095         case ALC880_MIC_EVENT:
16096                 alc662_eeepc_mic_automute(codec);
16097                 break;
16098         }
16099 }
16100
16101 static void alc662_mode2_inithook(struct hda_codec *codec)
16102 {
16103         alc662_f5z_speaker_automute(codec);
16104         alc662_eeepc_mic_automute(codec);
16105 }
16106 /* ***************** Mode3 ******************************/
16107 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16108                                            unsigned int res)
16109 {
16110         switch (res >> 26) {
16111         case ALC880_HP_EVENT:
16112                 alc663_two_hp_m1_speaker_automute(codec);
16113                 break;
16114         case ALC880_MIC_EVENT:
16115                 alc662_eeepc_mic_automute(codec);
16116                 break;
16117         }
16118 }
16119
16120 static void alc663_mode3_inithook(struct hda_codec *codec)
16121 {
16122         alc663_two_hp_m1_speaker_automute(codec);
16123         alc662_eeepc_mic_automute(codec);
16124 }
16125 /* ***************** Mode4 ******************************/
16126 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16127                                            unsigned int res)
16128 {
16129         switch (res >> 26) {
16130         case ALC880_HP_EVENT:
16131                 alc663_21jd_two_speaker_automute(codec);
16132                 break;
16133         case ALC880_MIC_EVENT:
16134                 alc662_eeepc_mic_automute(codec);
16135                 break;
16136         }
16137 }
16138
16139 static void alc663_mode4_inithook(struct hda_codec *codec)
16140 {
16141         alc663_21jd_two_speaker_automute(codec);
16142         alc662_eeepc_mic_automute(codec);
16143 }
16144 /* ***************** Mode5 ******************************/
16145 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16146                                            unsigned int res)
16147 {
16148         switch (res >> 26) {
16149         case ALC880_HP_EVENT:
16150                 alc663_15jd_two_speaker_automute(codec);
16151                 break;
16152         case ALC880_MIC_EVENT:
16153                 alc662_eeepc_mic_automute(codec);
16154                 break;
16155         }
16156 }
16157
16158 static void alc663_mode5_inithook(struct hda_codec *codec)
16159 {
16160         alc663_15jd_two_speaker_automute(codec);
16161         alc662_eeepc_mic_automute(codec);
16162 }
16163 /* ***************** Mode6 ******************************/
16164 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16165                                            unsigned int res)
16166 {
16167         switch (res >> 26) {
16168         case ALC880_HP_EVENT:
16169                 alc663_two_hp_m2_speaker_automute(codec);
16170                 break;
16171         case ALC880_MIC_EVENT:
16172                 alc662_eeepc_mic_automute(codec);
16173                 break;
16174         }
16175 }
16176
16177 static void alc663_mode6_inithook(struct hda_codec *codec)
16178 {
16179         alc663_two_hp_m2_speaker_automute(codec);
16180         alc662_eeepc_mic_automute(codec);
16181 }
16182
16183 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16184 {
16185         unsigned int present;
16186         unsigned char bits;
16187
16188         present = snd_hda_codec_read(codec, 0x21, 0,
16189                                      AC_VERB_GET_PIN_SENSE, 0)
16190                 & AC_PINSENSE_PRESENCE;
16191         bits = present ? HDA_AMP_MUTE : 0;
16192         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16193                                  HDA_AMP_MUTE, bits);
16194         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16195                                  HDA_AMP_MUTE, bits);
16196 }
16197
16198 static void alc663_g71v_front_automute(struct hda_codec *codec)
16199 {
16200         unsigned int present;
16201         unsigned char bits;
16202
16203         present = snd_hda_codec_read(codec, 0x15, 0,
16204                                      AC_VERB_GET_PIN_SENSE, 0)
16205                 & AC_PINSENSE_PRESENCE;
16206         bits = present ? HDA_AMP_MUTE : 0;
16207         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16208                                  HDA_AMP_MUTE, bits);
16209 }
16210
16211 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16212                                            unsigned int res)
16213 {
16214         switch (res >> 26) {
16215         case ALC880_HP_EVENT:
16216                 alc663_g71v_hp_automute(codec);
16217                 break;
16218         case ALC880_FRONT_EVENT:
16219                 alc663_g71v_front_automute(codec);
16220                 break;
16221         case ALC880_MIC_EVENT:
16222                 alc662_eeepc_mic_automute(codec);
16223                 break;
16224         }
16225 }
16226
16227 static void alc663_g71v_inithook(struct hda_codec *codec)
16228 {
16229         alc663_g71v_front_automute(codec);
16230         alc663_g71v_hp_automute(codec);
16231         alc662_eeepc_mic_automute(codec);
16232 }
16233
16234 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16235                                            unsigned int res)
16236 {
16237         switch (res >> 26) {
16238         case ALC880_HP_EVENT:
16239                 alc663_m51va_speaker_automute(codec);
16240                 break;
16241         case ALC880_MIC_EVENT:
16242                 alc662_eeepc_mic_automute(codec);
16243                 break;
16244         }
16245 }
16246
16247 static void alc663_g50v_inithook(struct hda_codec *codec)
16248 {
16249         alc663_m51va_speaker_automute(codec);
16250         alc662_eeepc_mic_automute(codec);
16251 }
16252
16253 /* bind hp and internal speaker mute (with plug check) */
16254 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16255                                      struct snd_ctl_elem_value *ucontrol)
16256 {
16257         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16258         long *valp = ucontrol->value.integer.value;
16259         int change;
16260
16261         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16262                                           HDA_AMP_MUTE,
16263                                           valp[0] ? 0 : HDA_AMP_MUTE);
16264         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16265                                            HDA_AMP_MUTE,
16266                                            valp[1] ? 0 : HDA_AMP_MUTE);
16267         if (change)
16268                 alc262_hippo1_automute(codec);
16269         return change;
16270 }
16271
16272 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16273         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16274         {
16275                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16276                 .name = "Master Playback Switch",
16277                 .info = snd_hda_mixer_amp_switch_info,
16278                 .get = snd_hda_mixer_amp_switch_get,
16279                 .put = alc662_ecs_master_sw_put,
16280                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16281         },
16282
16283         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16284         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16285         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16286
16287         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16288         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16289         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16290         { } /* end */
16291 };
16292
16293 #ifdef CONFIG_SND_HDA_POWER_SAVE
16294 #define alc662_loopbacks        alc880_loopbacks
16295 #endif
16296
16297
16298 /* pcm configuration: identiacal with ALC880 */
16299 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16300 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16301 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16302 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16303
16304 /*
16305  * configuration and preset
16306  */
16307 static const char *alc662_models[ALC662_MODEL_LAST] = {
16308         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16309         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16310         [ALC662_3ST_6ch]        = "3stack-6ch",
16311         [ALC662_5ST_DIG]        = "6stack-dig",
16312         [ALC662_LENOVO_101E]    = "lenovo-101e",
16313         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16314         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16315         [ALC662_ECS] = "ecs",
16316         [ALC663_ASUS_M51VA] = "m51va",
16317         [ALC663_ASUS_G71V] = "g71v",
16318         [ALC663_ASUS_H13] = "h13",
16319         [ALC663_ASUS_G50V] = "g50v",
16320         [ALC663_ASUS_MODE1] = "asus-mode1",
16321         [ALC662_ASUS_MODE2] = "asus-mode2",
16322         [ALC663_ASUS_MODE3] = "asus-mode3",
16323         [ALC663_ASUS_MODE4] = "asus-mode4",
16324         [ALC663_ASUS_MODE5] = "asus-mode5",
16325         [ALC663_ASUS_MODE6] = "asus-mode6",
16326         [ALC662_AUTO]           = "auto",
16327 };
16328
16329 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16330         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16331         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16332         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16333         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16334         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16335         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16336         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16337         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16338         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16339         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16340         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16341         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16342         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16343         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16344         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16345         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16346         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16347         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16348         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16349         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16350         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16351         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16352         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16353         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16354         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16355         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16356         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16357         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16358         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16359         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16360         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16361         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16362         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16363         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16364         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16365         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16366         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16367         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16368         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16369         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16370                       ALC662_3ST_6ch_DIG),
16371         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16372                       ALC662_3ST_6ch_DIG),
16373         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16374         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16375         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16376                                         ALC662_3ST_6ch_DIG),
16377         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16378                            ALC663_ASUS_H13),
16379         {}
16380 };
16381
16382 static struct alc_config_preset alc662_presets[] = {
16383         [ALC662_3ST_2ch_DIG] = {
16384                 .mixers = { alc662_3ST_2ch_mixer },
16385                 .init_verbs = { alc662_init_verbs },
16386                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16387                 .dac_nids = alc662_dac_nids,
16388                 .dig_out_nid = ALC662_DIGOUT_NID,
16389                 .dig_in_nid = ALC662_DIGIN_NID,
16390                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16391                 .channel_mode = alc662_3ST_2ch_modes,
16392                 .input_mux = &alc662_capture_source,
16393         },
16394         [ALC662_3ST_6ch_DIG] = {
16395                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16396                 .init_verbs = { alc662_init_verbs },
16397                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16398                 .dac_nids = alc662_dac_nids,
16399                 .dig_out_nid = ALC662_DIGOUT_NID,
16400                 .dig_in_nid = ALC662_DIGIN_NID,
16401                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16402                 .channel_mode = alc662_3ST_6ch_modes,
16403                 .need_dac_fix = 1,
16404                 .input_mux = &alc662_capture_source,
16405         },
16406         [ALC662_3ST_6ch] = {
16407                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16408                 .init_verbs = { alc662_init_verbs },
16409                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16410                 .dac_nids = alc662_dac_nids,
16411                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16412                 .channel_mode = alc662_3ST_6ch_modes,
16413                 .need_dac_fix = 1,
16414                 .input_mux = &alc662_capture_source,
16415         },
16416         [ALC662_5ST_DIG] = {
16417                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16418                 .init_verbs = { alc662_init_verbs },
16419                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16420                 .dac_nids = alc662_dac_nids,
16421                 .dig_out_nid = ALC662_DIGOUT_NID,
16422                 .dig_in_nid = ALC662_DIGIN_NID,
16423                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16424                 .channel_mode = alc662_5stack_modes,
16425                 .input_mux = &alc662_capture_source,
16426         },
16427         [ALC662_LENOVO_101E] = {
16428                 .mixers = { alc662_lenovo_101e_mixer },
16429                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16430                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16431                 .dac_nids = alc662_dac_nids,
16432                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16433                 .channel_mode = alc662_3ST_2ch_modes,
16434                 .input_mux = &alc662_lenovo_101e_capture_source,
16435                 .unsol_event = alc662_lenovo_101e_unsol_event,
16436                 .init_hook = alc662_lenovo_101e_all_automute,
16437         },
16438         [ALC662_ASUS_EEEPC_P701] = {
16439                 .mixers = { alc662_eeepc_p701_mixer },
16440                 .init_verbs = { alc662_init_verbs,
16441                                 alc662_eeepc_sue_init_verbs },
16442                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16443                 .dac_nids = alc662_dac_nids,
16444                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16445                 .channel_mode = alc662_3ST_2ch_modes,
16446                 .input_mux = &alc662_eeepc_capture_source,
16447                 .unsol_event = alc662_eeepc_unsol_event,
16448                 .init_hook = alc662_eeepc_inithook,
16449         },
16450         [ALC662_ASUS_EEEPC_EP20] = {
16451                 .mixers = { alc662_eeepc_ep20_mixer,
16452                             alc662_chmode_mixer },
16453                 .init_verbs = { alc662_init_verbs,
16454                                 alc662_eeepc_ep20_sue_init_verbs },
16455                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16456                 .dac_nids = alc662_dac_nids,
16457                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16458                 .channel_mode = alc662_3ST_6ch_modes,
16459                 .input_mux = &alc662_lenovo_101e_capture_source,
16460                 .unsol_event = alc662_eeepc_ep20_unsol_event,
16461                 .init_hook = alc662_eeepc_ep20_inithook,
16462         },
16463         [ALC662_ECS] = {
16464                 .mixers = { alc662_ecs_mixer },
16465                 .init_verbs = { alc662_init_verbs,
16466                                 alc662_ecs_init_verbs },
16467                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16468                 .dac_nids = alc662_dac_nids,
16469                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16470                 .channel_mode = alc662_3ST_2ch_modes,
16471                 .input_mux = &alc662_eeepc_capture_source,
16472                 .unsol_event = alc662_eeepc_unsol_event,
16473                 .init_hook = alc662_eeepc_inithook,
16474         },
16475         [ALC663_ASUS_M51VA] = {
16476                 .mixers = { alc663_m51va_mixer },
16477                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16478                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16479                 .dac_nids = alc662_dac_nids,
16480                 .dig_out_nid = ALC662_DIGOUT_NID,
16481                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16482                 .channel_mode = alc662_3ST_2ch_modes,
16483                 .input_mux = &alc663_m51va_capture_source,
16484                 .unsol_event = alc663_m51va_unsol_event,
16485                 .init_hook = alc663_m51va_inithook,
16486         },
16487         [ALC663_ASUS_G71V] = {
16488                 .mixers = { alc663_g71v_mixer },
16489                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16490                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16491                 .dac_nids = alc662_dac_nids,
16492                 .dig_out_nid = ALC662_DIGOUT_NID,
16493                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16494                 .channel_mode = alc662_3ST_2ch_modes,
16495                 .input_mux = &alc662_eeepc_capture_source,
16496                 .unsol_event = alc663_g71v_unsol_event,
16497                 .init_hook = alc663_g71v_inithook,
16498         },
16499         [ALC663_ASUS_H13] = {
16500                 .mixers = { alc663_m51va_mixer },
16501                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16502                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16503                 .dac_nids = alc662_dac_nids,
16504                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16505                 .channel_mode = alc662_3ST_2ch_modes,
16506                 .input_mux = &alc663_m51va_capture_source,
16507                 .unsol_event = alc663_m51va_unsol_event,
16508                 .init_hook = alc663_m51va_inithook,
16509         },
16510         [ALC663_ASUS_G50V] = {
16511                 .mixers = { alc663_g50v_mixer },
16512                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16513                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16514                 .dac_nids = alc662_dac_nids,
16515                 .dig_out_nid = ALC662_DIGOUT_NID,
16516                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16517                 .channel_mode = alc662_3ST_6ch_modes,
16518                 .input_mux = &alc663_capture_source,
16519                 .unsol_event = alc663_g50v_unsol_event,
16520                 .init_hook = alc663_g50v_inithook,
16521         },
16522         [ALC663_ASUS_MODE1] = {
16523                 .mixers = { alc663_m51va_mixer },
16524                 .cap_mixer = alc662_auto_capture_mixer,
16525                 .init_verbs = { alc662_init_verbs,
16526                                 alc663_21jd_amic_init_verbs },
16527                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16528                 .hp_nid = 0x03,
16529                 .dac_nids = alc662_dac_nids,
16530                 .dig_out_nid = ALC662_DIGOUT_NID,
16531                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16532                 .channel_mode = alc662_3ST_2ch_modes,
16533                 .input_mux = &alc662_eeepc_capture_source,
16534                 .unsol_event = alc663_mode1_unsol_event,
16535                 .init_hook = alc663_mode1_inithook,
16536         },
16537         [ALC662_ASUS_MODE2] = {
16538                 .mixers = { alc662_1bjd_mixer },
16539                 .cap_mixer = alc662_auto_capture_mixer,
16540                 .init_verbs = { alc662_init_verbs,
16541                                 alc662_1bjd_amic_init_verbs },
16542                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16543                 .dac_nids = alc662_dac_nids,
16544                 .dig_out_nid = ALC662_DIGOUT_NID,
16545                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16546                 .channel_mode = alc662_3ST_2ch_modes,
16547                 .input_mux = &alc662_eeepc_capture_source,
16548                 .unsol_event = alc662_mode2_unsol_event,
16549                 .init_hook = alc662_mode2_inithook,
16550         },
16551         [ALC663_ASUS_MODE3] = {
16552                 .mixers = { alc663_two_hp_m1_mixer },
16553                 .cap_mixer = alc662_auto_capture_mixer,
16554                 .init_verbs = { alc662_init_verbs,
16555                                 alc663_two_hp_amic_m1_init_verbs },
16556                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16557                 .hp_nid = 0x03,
16558                 .dac_nids = alc662_dac_nids,
16559                 .dig_out_nid = ALC662_DIGOUT_NID,
16560                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16561                 .channel_mode = alc662_3ST_2ch_modes,
16562                 .input_mux = &alc662_eeepc_capture_source,
16563                 .unsol_event = alc663_mode3_unsol_event,
16564                 .init_hook = alc663_mode3_inithook,
16565         },
16566         [ALC663_ASUS_MODE4] = {
16567                 .mixers = { alc663_asus_21jd_clfe_mixer },
16568                 .cap_mixer = alc662_auto_capture_mixer,
16569                 .init_verbs = { alc662_init_verbs,
16570                                 alc663_21jd_amic_init_verbs},
16571                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16572                 .hp_nid = 0x03,
16573                 .dac_nids = alc662_dac_nids,
16574                 .dig_out_nid = ALC662_DIGOUT_NID,
16575                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16576                 .channel_mode = alc662_3ST_2ch_modes,
16577                 .input_mux = &alc662_eeepc_capture_source,
16578                 .unsol_event = alc663_mode4_unsol_event,
16579                 .init_hook = alc663_mode4_inithook,
16580         },
16581         [ALC663_ASUS_MODE5] = {
16582                 .mixers = { alc663_asus_15jd_clfe_mixer },
16583                 .cap_mixer = alc662_auto_capture_mixer,
16584                 .init_verbs = { alc662_init_verbs,
16585                                 alc663_15jd_amic_init_verbs },
16586                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16587                 .hp_nid = 0x03,
16588                 .dac_nids = alc662_dac_nids,
16589                 .dig_out_nid = ALC662_DIGOUT_NID,
16590                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16591                 .channel_mode = alc662_3ST_2ch_modes,
16592                 .input_mux = &alc662_eeepc_capture_source,
16593                 .unsol_event = alc663_mode5_unsol_event,
16594                 .init_hook = alc663_mode5_inithook,
16595         },
16596         [ALC663_ASUS_MODE6] = {
16597                 .mixers = { alc663_two_hp_m2_mixer },
16598                 .cap_mixer = alc662_auto_capture_mixer,
16599                 .init_verbs = { alc662_init_verbs,
16600                                 alc663_two_hp_amic_m2_init_verbs },
16601                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16602                 .hp_nid = 0x03,
16603                 .dac_nids = alc662_dac_nids,
16604                 .dig_out_nid = ALC662_DIGOUT_NID,
16605                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16606                 .channel_mode = alc662_3ST_2ch_modes,
16607                 .input_mux = &alc662_eeepc_capture_source,
16608                 .unsol_event = alc663_mode6_unsol_event,
16609                 .init_hook = alc663_mode6_inithook,
16610         },
16611 };
16612
16613
16614 /*
16615  * BIOS auto configuration
16616  */
16617
16618 /* add playback controls from the parsed DAC table */
16619 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16620                                              const struct auto_pin_cfg *cfg)
16621 {
16622         char name[32];
16623         static const char *chname[4] = {
16624                 "Front", "Surround", NULL /*CLFE*/, "Side"
16625         };
16626         hda_nid_t nid;
16627         int i, err;
16628
16629         for (i = 0; i < cfg->line_outs; i++) {
16630                 if (!spec->multiout.dac_nids[i])
16631                         continue;
16632                 nid = alc880_idx_to_dac(i);
16633                 if (i == 2) {
16634                         /* Center/LFE */
16635                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16636                                           "Center Playback Volume",
16637                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16638                                                               HDA_OUTPUT));
16639                         if (err < 0)
16640                                 return err;
16641                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16642                                           "LFE Playback Volume",
16643                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16644                                                               HDA_OUTPUT));
16645                         if (err < 0)
16646                                 return err;
16647                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16648                                           "Center Playback Switch",
16649                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16650                                                               HDA_INPUT));
16651                         if (err < 0)
16652                                 return err;
16653                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16654                                           "LFE Playback Switch",
16655                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16656                                                               HDA_INPUT));
16657                         if (err < 0)
16658                                 return err;
16659                 } else {
16660                         sprintf(name, "%s Playback Volume", chname[i]);
16661                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16662                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16663                                                               HDA_OUTPUT));
16664                         if (err < 0)
16665                                 return err;
16666                         sprintf(name, "%s Playback Switch", chname[i]);
16667                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16668                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16669                                                     3, 0, HDA_INPUT));
16670                         if (err < 0)
16671                                 return err;
16672                 }
16673         }
16674         return 0;
16675 }
16676
16677 /* add playback controls for speaker and HP outputs */
16678 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16679                                         const char *pfx)
16680 {
16681         hda_nid_t nid;
16682         int err;
16683         char name[32];
16684
16685         if (!pin)
16686                 return 0;
16687
16688         if (pin == 0x17) {
16689                 /* ALC663 has a mono output pin on 0x17 */
16690                 sprintf(name, "%s Playback Switch", pfx);
16691                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16692                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16693                 return err;
16694         }
16695
16696         if (alc880_is_fixed_pin(pin)) {
16697                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16698                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16699                 /* specify the DAC as the extra output */
16700                 if (!spec->multiout.hp_nid)
16701                         spec->multiout.hp_nid = nid;
16702                 else
16703                         spec->multiout.extra_out_nid[0] = nid;
16704                 /* control HP volume/switch on the output mixer amp */
16705                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16706                 sprintf(name, "%s Playback Volume", pfx);
16707                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16708                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16709                 if (err < 0)
16710                         return err;
16711                 sprintf(name, "%s Playback Switch", pfx);
16712                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16713                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16714                 if (err < 0)
16715                         return err;
16716         } else if (alc880_is_multi_pin(pin)) {
16717                 /* set manual connection */
16718                 /* we have only a switch on HP-out PIN */
16719                 sprintf(name, "%s Playback Switch", pfx);
16720                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16721                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16722                 if (err < 0)
16723                         return err;
16724         }
16725         return 0;
16726 }
16727
16728 /* create playback/capture controls for input pins */
16729 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16730                                                 const struct auto_pin_cfg *cfg)
16731 {
16732         struct hda_input_mux *imux = &spec->private_imux[0];
16733         int i, err, idx;
16734
16735         for (i = 0; i < AUTO_PIN_LAST; i++) {
16736                 if (alc880_is_input_pin(cfg->input_pins[i])) {
16737                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
16738                         err = new_analog_input(spec, cfg->input_pins[i],
16739                                                auto_pin_cfg_labels[i],
16740                                                idx, 0x0b);
16741                         if (err < 0)
16742                                 return err;
16743                         imux->items[imux->num_items].label =
16744                                 auto_pin_cfg_labels[i];
16745                         imux->items[imux->num_items].index =
16746                                 alc880_input_pin_idx(cfg->input_pins[i]);
16747                         imux->num_items++;
16748                 }
16749         }
16750         return 0;
16751 }
16752
16753 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16754                                               hda_nid_t nid, int pin_type,
16755                                               int dac_idx)
16756 {
16757         alc_set_pin_output(codec, nid, pin_type);
16758         /* need the manual connection? */
16759         if (alc880_is_multi_pin(nid)) {
16760                 struct alc_spec *spec = codec->spec;
16761                 int idx = alc880_multi_pin_idx(nid);
16762                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16763                                     AC_VERB_SET_CONNECT_SEL,
16764                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16765         }
16766 }
16767
16768 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16769 {
16770         struct alc_spec *spec = codec->spec;
16771         int i;
16772
16773         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16774         for (i = 0; i <= HDA_SIDE; i++) {
16775                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16776                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16777                 if (nid)
16778                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16779                                                           i);
16780         }
16781 }
16782
16783 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16784 {
16785         struct alc_spec *spec = codec->spec;
16786         hda_nid_t pin;
16787
16788         pin = spec->autocfg.hp_pins[0];
16789         if (pin) /* connect to front */
16790                 /* use dac 0 */
16791                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16792         pin = spec->autocfg.speaker_pins[0];
16793         if (pin)
16794                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16795 }
16796
16797 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
16798 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16799
16800 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16801 {
16802         struct alc_spec *spec = codec->spec;
16803         int i;
16804
16805         for (i = 0; i < AUTO_PIN_LAST; i++) {
16806                 hda_nid_t nid = spec->autocfg.input_pins[i];
16807                 if (alc662_is_input_pin(nid)) {
16808                         snd_hda_codec_write(codec, nid, 0,
16809                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
16810                                             (i <= AUTO_PIN_FRONT_MIC ?
16811                                              PIN_VREF80 : PIN_IN));
16812                         if (nid != ALC662_PIN_CD_NID)
16813                                 snd_hda_codec_write(codec, nid, 0,
16814                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16815                                                     AMP_OUT_MUTE);
16816                 }
16817         }
16818 }
16819
16820 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16821
16822 static int alc662_parse_auto_config(struct hda_codec *codec)
16823 {
16824         struct alc_spec *spec = codec->spec;
16825         int err;
16826         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16827
16828         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16829                                            alc662_ignore);
16830         if (err < 0)
16831                 return err;
16832         if (!spec->autocfg.line_outs)
16833                 return 0; /* can't find valid BIOS pin config */
16834
16835         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16836         if (err < 0)
16837                 return err;
16838         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16839         if (err < 0)
16840                 return err;
16841         err = alc662_auto_create_extra_out(spec,
16842                                            spec->autocfg.speaker_pins[0],
16843                                            "Speaker");
16844         if (err < 0)
16845                 return err;
16846         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16847                                            "Headphone");
16848         if (err < 0)
16849                 return err;
16850         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16851         if (err < 0)
16852                 return err;
16853
16854         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16855
16856         if (spec->autocfg.dig_outs)
16857                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16858
16859         if (spec->kctls.list)
16860                 add_mixer(spec, spec->kctls.list);
16861
16862         spec->num_mux_defs = 1;
16863         spec->input_mux = &spec->private_imux[0];
16864
16865         add_verb(spec, alc662_auto_init_verbs);
16866         if (codec->vendor_id == 0x10ec0663)
16867                 add_verb(spec, alc663_auto_init_verbs);
16868
16869         err = alc_auto_add_mic_boost(codec);
16870         if (err < 0)
16871                 return err;
16872
16873         store_pin_configs(codec);
16874         return 1;
16875 }
16876
16877 /* additional initialization for auto-configuration model */
16878 static void alc662_auto_init(struct hda_codec *codec)
16879 {
16880         struct alc_spec *spec = codec->spec;
16881         alc662_auto_init_multi_out(codec);
16882         alc662_auto_init_hp_out(codec);
16883         alc662_auto_init_analog_input(codec);
16884         alc662_auto_init_input_src(codec);
16885         if (spec->unsol_event)
16886                 alc_inithook(codec);
16887 }
16888
16889 static int patch_alc662(struct hda_codec *codec)
16890 {
16891         struct alc_spec *spec;
16892         int err, board_config;
16893
16894         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16895         if (!spec)
16896                 return -ENOMEM;
16897
16898         codec->spec = spec;
16899
16900         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16901
16902         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16903                                                   alc662_models,
16904                                                   alc662_cfg_tbl);
16905         if (board_config < 0) {
16906                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16907                        "trying auto-probe from BIOS...\n");
16908                 board_config = ALC662_AUTO;
16909         }
16910
16911         if (board_config == ALC662_AUTO) {
16912                 /* automatic parse from the BIOS config */
16913                 err = alc662_parse_auto_config(codec);
16914                 if (err < 0) {
16915                         alc_free(codec);
16916                         return err;
16917                 } else if (!err) {
16918                         printk(KERN_INFO
16919                                "hda_codec: Cannot set up configuration "
16920                                "from BIOS.  Using base mode...\n");
16921                         board_config = ALC662_3ST_2ch_DIG;
16922                 }
16923         }
16924
16925         err = snd_hda_attach_beep_device(codec, 0x1);
16926         if (err < 0) {
16927                 alc_free(codec);
16928                 return err;
16929         }
16930
16931         if (board_config != ALC662_AUTO)
16932                 setup_preset(spec, &alc662_presets[board_config]);
16933
16934         if (codec->vendor_id == 0x10ec0663) {
16935                 spec->stream_name_analog = "ALC663 Analog";
16936                 spec->stream_name_digital = "ALC663 Digital";
16937         } else if (codec->vendor_id == 0x10ec0272) {
16938                 spec->stream_name_analog = "ALC272 Analog";
16939                 spec->stream_name_digital = "ALC272 Digital";
16940         } else {
16941                 spec->stream_name_analog = "ALC662 Analog";
16942                 spec->stream_name_digital = "ALC662 Digital";
16943         }
16944
16945         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16946         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16947
16948         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16949         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16950
16951         spec->adc_nids = alc662_adc_nids;
16952         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16953         spec->capsrc_nids = alc662_capsrc_nids;
16954         spec->capture_style = CAPT_MIX;
16955
16956         if (!spec->cap_mixer)
16957                 set_capture_mixer(spec);
16958         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16959
16960         spec->vmaster_nid = 0x02;
16961
16962         codec->patch_ops = alc_patch_ops;
16963         if (board_config == ALC662_AUTO)
16964                 spec->init_hook = alc662_auto_init;
16965 #ifdef CONFIG_SND_HDA_POWER_SAVE
16966         if (!spec->loopback.amplist)
16967                 spec->loopback.amplist = alc662_loopbacks;
16968 #endif
16969         codec->proc_widget_hook = print_realtek_coef;
16970
16971         return 0;
16972 }
16973
16974 /*
16975  * patch entries
16976  */
16977 static struct hda_codec_preset snd_hda_preset_realtek[] = {
16978         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16979         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16980         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16981         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16982         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16983         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16984         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16985           .patch = patch_alc861 },
16986         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16987         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16988         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16989         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16990           .patch = patch_alc883 },
16991         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16992           .patch = patch_alc662 },
16993         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16994         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16995         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16996         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16997         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16998           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16999         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17000           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17001         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17002         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
17003         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17004           .patch = patch_alc883 },
17005         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
17006         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
17007         {} /* terminator */
17008 };
17009
17010 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17011
17012 MODULE_LICENSE("GPL");
17013 MODULE_DESCRIPTION("Realtek HD-audio codec");
17014
17015 static struct hda_codec_preset_list realtek_list = {
17016         .preset = snd_hda_preset_realtek,
17017         .owner = THIS_MODULE,
17018 };
17019
17020 static int __init patch_realtek_init(void)
17021 {
17022         return snd_hda_add_codec_preset(&realtek_list);
17023 }
17024
17025 static void __exit patch_realtek_exit(void)
17026 {
17027         snd_hda_delete_codec_preset(&realtek_list);
17028 }
17029
17030 module_init(patch_realtek_init)
17031 module_exit(patch_realtek_exit)