git.oblomov.eu Git - linux-2.6/blob - sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_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         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC662_AUTO,
 194         ALC662_MODEL_LAST,
 195 };
 196
 197 /* ALC882 models */
 198 enum {
 199         ALC882_3ST_DIG,
 200         ALC882_6ST_DIG,
 201         ALC882_ARIMA,
 202         ALC882_W2JC,
 203         ALC882_TARGA,
 204         ALC882_ASUS_A7J,
 205         ALC882_ASUS_A7M,
 206         ALC885_MACPRO,
 207         ALC885_MBP3,
 208         ALC885_IMAC24,
 209         ALC882_AUTO,
 210         ALC882_MODEL_LAST,
 211 };
 212
 213 /* ALC883 models */
 214 enum {
 215         ALC883_3ST_2ch_DIG,
 216         ALC883_3ST_6ch_DIG,
 217         ALC883_3ST_6ch,
 218         ALC883_6ST_DIG,
 219         ALC883_TARGA_DIG,
 220         ALC883_TARGA_2ch_DIG,
 221         ALC883_ACER,
 222         ALC883_ACER_ASPIRE,
 223         ALC888_ACER_ASPIRE_4930G,
 224         ALC883_MEDION,
 225         ALC883_MEDION_MD2,
 226         ALC883_LAPTOP_EAPD,
 227         ALC883_LENOVO_101E_2ch,
 228         ALC883_LENOVO_NB0763,
 229         ALC888_LENOVO_MS7195_DIG,
 230         ALC888_LENOVO_SKY,
 231         ALC883_HAIER_W66,
 232         ALC888_3ST_HP,
 233         ALC888_6ST_DELL,
 234         ALC883_MITAC,
 235         ALC883_CLEVO_M720,
 236         ALC883_FUJITSU_PI2515,
 237         ALC888_FUJITSU_XA3530,
 238         ALC883_3ST_6ch_INTEL,
 239         ALC888_ASUS_M90V,
 240         ALC888_ASUS_EEE1601,
 241         ALC1200_ASUS_P5Q,
 242         ALC883_AUTO,
 243         ALC883_MODEL_LAST,
 244 };
 245
 246 /* styles of capture selection */
 247 enum {
 248         CAPT_MUX = 0,   /* only mux based */
 249         CAPT_MIX,       /* only mixer based */
 250         CAPT_1MUX_MIX,  /* first mux and other mixers */
 251 };
 252
 253 /* for GPIO Poll */
 254 #define GPIO_MASK       0x03
 255
 256 struct alc_spec {
 257         /* codec parameterization */
 258         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 259         unsigned int num_mixers;
 260         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 261         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 262
 263         const struct hda_verb *init_verbs[5];   /* initialization verbs
 264                                                  * don't forget NULL
 265                                                  * termination!
 266                                                  */
 267         unsigned int num_init_verbs;
 268
 269         char *stream_name_analog;       /* analog PCM stream */
 270         struct hda_pcm_stream *stream_analog_playback;
 271         struct hda_pcm_stream *stream_analog_capture;
 272         struct hda_pcm_stream *stream_analog_alt_playback;
 273         struct hda_pcm_stream *stream_analog_alt_capture;
 274
 275         char *stream_name_digital;      /* digital PCM stream */
 276         struct hda_pcm_stream *stream_digital_playback;
 277         struct hda_pcm_stream *stream_digital_capture;
 278
 279         /* playback */
 280         struct hda_multi_out multiout;  /* playback set-up
 281                                          * max_channels, dacs must be set
 282                                          * dig_out_nid and hp_nid are optional
 283                                          */
 284         hda_nid_t alt_dac_nid;
 285         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 286         int dig_out_type;
 287
 288         /* capture */
 289         unsigned int num_adc_nids;
 290         hda_nid_t *adc_nids;
 291         hda_nid_t *capsrc_nids;
 292         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 293         int capture_style;              /* capture style (CAPT_*) */
 294
 295         /* capture source */
 296         unsigned int num_mux_defs;
 297         const struct hda_input_mux *input_mux;
 298         unsigned int cur_mux[3];
 299
 300         /* channel model */
 301         const struct hda_channel_mode *channel_mode;
 302         int num_channel_mode;
 303         int need_dac_fix;
 304
 305         /* PCM information */
 306         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 307
 308         /* dynamic controls, init_verbs and input_mux */
 309         struct auto_pin_cfg autocfg;
 310         struct snd_array kctls;
 311         struct hda_input_mux private_imux[3];
 312         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 313
 314         /* hooks */
 315         void (*init_hook)(struct hda_codec *codec);
 316         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 317
 318         /* for pin sensing */
 319         unsigned int sense_updated: 1;
 320         unsigned int jack_present: 1;
 321         unsigned int master_sw: 1;
 322
 323         /* other flags */
 324         unsigned int no_analog :1; /* digital I/O only */
 325
 326         /* for virtual master */
 327         hda_nid_t vmaster_nid;
 328 #ifdef CONFIG_SND_HDA_POWER_SAVE
 329         struct hda_loopback_check loopback;
 330 #endif
 331
 332         /* for PLL fix */
 333         hda_nid_t pll_nid;
 334         unsigned int pll_coef_idx, pll_coef_bit;
 335 };
 336
 337 /*
 338  * configuration template - to be copied to the spec instance
 339  */
 340 struct alc_config_preset {
 341         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 342                                              * with spec
 343                                              */
 344         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 345         const struct hda_verb *init_verbs[5];
 346         unsigned int num_dacs;
 347         hda_nid_t *dac_nids;
 348         hda_nid_t dig_out_nid;          /* optional */
 349         hda_nid_t hp_nid;               /* optional */
 350         hda_nid_t *slave_dig_outs;
 351         unsigned int num_adc_nids;
 352         hda_nid_t *adc_nids;
 353         hda_nid_t *capsrc_nids;
 354         hda_nid_t dig_in_nid;
 355         unsigned int num_channel_mode;
 356         const struct hda_channel_mode *channel_mode;
 357         int need_dac_fix;
 358         unsigned int num_mux_defs;
 359         const struct hda_input_mux *input_mux;
 360         void (*unsol_event)(struct hda_codec *, unsigned int);
 361         void (*init_hook)(struct hda_codec *);
 362 #ifdef CONFIG_SND_HDA_POWER_SAVE
 363         struct hda_amp_list *loopbacks;
 364 #endif
 365 };
 366
 367
 368 /*
 369  * input MUX handling
 370  */
 371 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 372                              struct snd_ctl_elem_info *uinfo)
 373 {
 374         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 375         struct alc_spec *spec = codec->spec;
 376         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 377         if (mux_idx >= spec->num_mux_defs)
 378                 mux_idx = 0;
 379         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 380 }
 381
 382 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 383                             struct snd_ctl_elem_value *ucontrol)
 384 {
 385         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 386         struct alc_spec *spec = codec->spec;
 387         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 388
 389         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 390         return 0;
 391 }
 392
 393 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 394                             struct snd_ctl_elem_value *ucontrol)
 395 {
 396         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 397         struct alc_spec *spec = codec->spec;
 398         const struct hda_input_mux *imux;
 399         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 400         unsigned int mux_idx;
 401         hda_nid_t nid = spec->capsrc_nids ?
 402                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 403
 404         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 405         imux = &spec->input_mux[mux_idx];
 406
 407         if (spec->capture_style &&
 408             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 409                 /* Matrix-mixer style (e.g. ALC882) */
 410                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 411                 unsigned int i, idx;
 412
 413                 idx = ucontrol->value.enumerated.item[0];
 414                 if (idx >= imux->num_items)
 415                         idx = imux->num_items - 1;
 416                 if (*cur_val == idx)
 417                         return 0;
 418                 for (i = 0; i < imux->num_items; i++) {
 419                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 420                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 421                                                  imux->items[i].index,
 422                                                  HDA_AMP_MUTE, v);
 423                 }
 424                 *cur_val = idx;
 425                 return 1;
 426         } else {
 427                 /* MUX style (e.g. ALC880) */
 428                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 429                                              &spec->cur_mux[adc_idx]);
 430         }
 431 }
 432
 433 /*
 434  * channel mode setting
 435  */
 436 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 437                             struct snd_ctl_elem_info *uinfo)
 438 {
 439         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 440         struct alc_spec *spec = codec->spec;
 441         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 442                                     spec->num_channel_mode);
 443 }
 444
 445 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 446                            struct snd_ctl_elem_value *ucontrol)
 447 {
 448         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 449         struct alc_spec *spec = codec->spec;
 450         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 451                                    spec->num_channel_mode,
 452                                    spec->multiout.max_channels);
 453 }
 454
 455 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 456                            struct snd_ctl_elem_value *ucontrol)
 457 {
 458         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 459         struct alc_spec *spec = codec->spec;
 460         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 461                                       spec->num_channel_mode,
 462                                       &spec->multiout.max_channels);
 463         if (err >= 0 && spec->need_dac_fix)
 464                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 465         return err;
 466 }
 467
 468 /*
 469  * Control the mode of pin widget settings via the mixer.  "pc" is used
 470  * instead of "%" to avoid consequences of accidently treating the % as
 471  * being part of a format specifier.  Maximum allowed length of a value is
 472  * 63 characters plus NULL terminator.
 473  *
 474  * Note: some retasking pin complexes seem to ignore requests for input
 475  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 476  * are requested.  Therefore order this list so that this behaviour will not
 477  * cause problems when mixer clients move through the enum sequentially.
 478  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 479  * March 2006.
 480  */
 481 static char *alc_pin_mode_names[] = {
 482         "Mic 50pc bias", "Mic 80pc bias",
 483         "Line in", "Line out", "Headphone out",
 484 };
 485 static unsigned char alc_pin_mode_values[] = {
 486         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 487 };
 488 /* The control can present all 5 options, or it can limit the options based
 489  * in the pin being assumed to be exclusively an input or an output pin.  In
 490  * addition, "input" pins may or may not process the mic bias option
 491  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 492  * accept requests for bias as of chip versions up to March 2006) and/or
 493  * wiring in the computer.
 494  */
 495 #define ALC_PIN_DIR_IN              0x00
 496 #define ALC_PIN_DIR_OUT             0x01
 497 #define ALC_PIN_DIR_INOUT           0x02
 498 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 499 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 500
 501 /* Info about the pin modes supported by the different pin direction modes.
 502  * For each direction the minimum and maximum values are given.
 503  */
 504 static signed char alc_pin_mode_dir_info[5][2] = {
 505         { 0, 2 },    /* ALC_PIN_DIR_IN */
 506         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 507         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 508         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 509         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 510 };
 511 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 512 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 513 #define alc_pin_mode_n_items(_dir) \
 514         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 515
 516 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 517                              struct snd_ctl_elem_info *uinfo)
 518 {
 519         unsigned int item_num = uinfo->value.enumerated.item;
 520         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 521
 522         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 523         uinfo->count = 1;
 524         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 525
 526         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 527                 item_num = alc_pin_mode_min(dir);
 528         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 529         return 0;
 530 }
 531
 532 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 533                             struct snd_ctl_elem_value *ucontrol)
 534 {
 535         unsigned int i;
 536         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 537         hda_nid_t nid = kcontrol->private_value & 0xffff;
 538         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 539         long *valp = ucontrol->value.integer.value;
 540         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 541                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 542                                                  0x00);
 543
 544         /* Find enumerated value for current pinctl setting */
 545         i = alc_pin_mode_min(dir);
 546         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 547                 i++;
 548         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 549         return 0;
 550 }
 551
 552 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 553                             struct snd_ctl_elem_value *ucontrol)
 554 {
 555         signed int change;
 556         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 557         hda_nid_t nid = kcontrol->private_value & 0xffff;
 558         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 559         long val = *ucontrol->value.integer.value;
 560         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 561                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 562                                                  0x00);
 563
 564         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 565                 val = alc_pin_mode_min(dir);
 566
 567         change = pinctl != alc_pin_mode_values[val];
 568         if (change) {
 569                 /* Set pin mode to that requested */
 570                 snd_hda_codec_write_cache(codec, nid, 0,
 571                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 572                                           alc_pin_mode_values[val]);
 573
 574                 /* Also enable the retasking pin's input/output as required
 575                  * for the requested pin mode.  Enum values of 2 or less are
 576                  * input modes.
 577                  *
 578                  * Dynamically switching the input/output buffers probably
 579                  * reduces noise slightly (particularly on input) so we'll
 580                  * do it.  However, having both input and output buffers
 581                  * enabled simultaneously doesn't seem to be problematic if
 582                  * this turns out to be necessary in the future.
 583                  */
 584                 if (val <= 2) {
 585                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 586                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 587                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 588                                                  HDA_AMP_MUTE, 0);
 589                 } else {
 590                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 591                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 592                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 593                                                  HDA_AMP_MUTE, 0);
 594                 }
 595         }
 596         return change;
 597 }
 598
 599 #define ALC_PIN_MODE(xname, nid, dir) \
 600         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 601           .info = alc_pin_mode_info, \
 602           .get = alc_pin_mode_get, \
 603           .put = alc_pin_mode_put, \
 604           .private_value = nid | (dir<<16) }
 605
 606 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 607  * together using a mask with more than one bit set.  This control is
 608  * currently used only by the ALC260 test model.  At this stage they are not
 609  * needed for any "production" models.
 610  */
 611 #ifdef CONFIG_SND_DEBUG
 612 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 613
 614 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 615                              struct snd_ctl_elem_value *ucontrol)
 616 {
 617         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 618         hda_nid_t nid = kcontrol->private_value & 0xffff;
 619         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 620         long *valp = ucontrol->value.integer.value;
 621         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 622                                               AC_VERB_GET_GPIO_DATA, 0x00);
 623
 624         *valp = (val & mask) != 0;
 625         return 0;
 626 }
 627 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 628                              struct snd_ctl_elem_value *ucontrol)
 629 {
 630         signed int change;
 631         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 632         hda_nid_t nid = kcontrol->private_value & 0xffff;
 633         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 634         long val = *ucontrol->value.integer.value;
 635         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 636                                                     AC_VERB_GET_GPIO_DATA,
 637                                                     0x00);
 638
 639         /* Set/unset the masked GPIO bit(s) as needed */
 640         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 641         if (val == 0)
 642                 gpio_data &= ~mask;
 643         else
 644                 gpio_data |= mask;
 645         snd_hda_codec_write_cache(codec, nid, 0,
 646                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 647
 648         return change;
 649 }
 650 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 651         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 652           .info = alc_gpio_data_info, \
 653           .get = alc_gpio_data_get, \
 654           .put = alc_gpio_data_put, \
 655           .private_value = nid | (mask<<16) }
 656 #endif   /* CONFIG_SND_DEBUG */
 657
 658 /* A switch control to allow the enabling of the digital IO pins on the
 659  * ALC260.  This is incredibly simplistic; the intention of this control is
 660  * to provide something in the test model allowing digital outputs to be
 661  * identified if present.  If models are found which can utilise these
 662  * outputs a more complete mixer control can be devised for those models if
 663  * necessary.
 664  */
 665 #ifdef CONFIG_SND_DEBUG
 666 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 667
 668 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 669                               struct snd_ctl_elem_value *ucontrol)
 670 {
 671         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 672         hda_nid_t nid = kcontrol->private_value & 0xffff;
 673         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 674         long *valp = ucontrol->value.integer.value;
 675         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 676                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 677
 678         *valp = (val & mask) != 0;
 679         return 0;
 680 }
 681 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 682                               struct snd_ctl_elem_value *ucontrol)
 683 {
 684         signed int change;
 685         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 686         hda_nid_t nid = kcontrol->private_value & 0xffff;
 687         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 688         long val = *ucontrol->value.integer.value;
 689         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 690                                                     AC_VERB_GET_DIGI_CONVERT_1,
 691                                                     0x00);
 692
 693         /* Set/unset the masked control bit(s) as needed */
 694         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 695         if (val==0)
 696                 ctrl_data &= ~mask;
 697         else
 698                 ctrl_data |= mask;
 699         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 700                                   ctrl_data);
 701
 702         return change;
 703 }
 704 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 705         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 706           .info = alc_spdif_ctrl_info, \
 707           .get = alc_spdif_ctrl_get, \
 708           .put = alc_spdif_ctrl_put, \
 709           .private_value = nid | (mask<<16) }
 710 #endif   /* CONFIG_SND_DEBUG */
 711
 712 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 713  * Again, this is only used in the ALC26x test models to help identify when
 714  * the EAPD line must be asserted for features to work.
 715  */
 716 #ifdef CONFIG_SND_DEBUG
 717 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 718
 719 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 720                               struct snd_ctl_elem_value *ucontrol)
 721 {
 722         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 723         hda_nid_t nid = kcontrol->private_value & 0xffff;
 724         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 725         long *valp = ucontrol->value.integer.value;
 726         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 727                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 728
 729         *valp = (val & mask) != 0;
 730         return 0;
 731 }
 732
 733 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 734                               struct snd_ctl_elem_value *ucontrol)
 735 {
 736         int change;
 737         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 738         hda_nid_t nid = kcontrol->private_value & 0xffff;
 739         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 740         long val = *ucontrol->value.integer.value;
 741         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 742                                                     AC_VERB_GET_EAPD_BTLENABLE,
 743                                                     0x00);
 744
 745         /* Set/unset the masked control bit(s) as needed */
 746         change = (!val ? 0 : mask) != (ctrl_data & mask);
 747         if (!val)
 748                 ctrl_data &= ~mask;
 749         else
 750                 ctrl_data |= mask;
 751         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 752                                   ctrl_data);
 753
 754         return change;
 755 }
 756
 757 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 758         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 759           .info = alc_eapd_ctrl_info, \
 760           .get = alc_eapd_ctrl_get, \
 761           .put = alc_eapd_ctrl_put, \
 762           .private_value = nid | (mask<<16) }
 763 #endif   /* CONFIG_SND_DEBUG */
 764
 765 /*
 766  * set up the input pin config (depending on the given auto-pin type)
 767  */
 768 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 769                               int auto_pin_type)
 770 {
 771         unsigned int val = PIN_IN;
 772
 773         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 774                 unsigned int pincap;
 775                 pincap = snd_hda_query_pin_caps(codec, nid);
 776                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 777                 if (pincap & AC_PINCAP_VREF_80)
 778                         val = PIN_VREF80;
 779         }
 780         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 781 }
 782
 783 /*
 784  */
 785 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 786 {
 787         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 788                 return;
 789         spec->mixers[spec->num_mixers++] = mix;
 790 }
 791
 792 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 793 {
 794         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 795                 return;
 796         spec->init_verbs[spec->num_init_verbs++] = verb;
 797 }
 798
 799 #ifdef CONFIG_PROC_FS
 800 /*
 801  * hook for proc
 802  */
 803 static void print_realtek_coef(struct snd_info_buffer *buffer,
 804                                struct hda_codec *codec, hda_nid_t nid)
 805 {
 806         int coeff;
 807
 808         if (nid != 0x20)
 809                 return;
 810         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 811         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 812         coeff = snd_hda_codec_read(codec, nid, 0,
 813                                    AC_VERB_GET_COEF_INDEX, 0);
 814         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 815 }
 816 #else
 817 #define print_realtek_coef      NULL
 818 #endif
 819
 820 /*
 821  * set up from the preset table
 822  */
 823 static void setup_preset(struct alc_spec *spec,
 824                          const struct alc_config_preset *preset)
 825 {
 826         int i;
 827
 828         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 829                 add_mixer(spec, preset->mixers[i]);
 830         spec->cap_mixer = preset->cap_mixer;
 831         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 832              i++)
 833                 add_verb(spec, preset->init_verbs[i]);
 834
 835         spec->channel_mode = preset->channel_mode;
 836         spec->num_channel_mode = preset->num_channel_mode;
 837         spec->need_dac_fix = preset->need_dac_fix;
 838
 839         spec->multiout.max_channels = spec->channel_mode[0].channels;
 840
 841         spec->multiout.num_dacs = preset->num_dacs;
 842         spec->multiout.dac_nids = preset->dac_nids;
 843         spec->multiout.dig_out_nid = preset->dig_out_nid;
 844         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 845         spec->multiout.hp_nid = preset->hp_nid;
 846
 847         spec->num_mux_defs = preset->num_mux_defs;
 848         if (!spec->num_mux_defs)
 849                 spec->num_mux_defs = 1;
 850         spec->input_mux = preset->input_mux;
 851
 852         spec->num_adc_nids = preset->num_adc_nids;
 853         spec->adc_nids = preset->adc_nids;
 854         spec->capsrc_nids = preset->capsrc_nids;
 855         spec->dig_in_nid = preset->dig_in_nid;
 856
 857         spec->unsol_event = preset->unsol_event;
 858         spec->init_hook = preset->init_hook;
 859 #ifdef CONFIG_SND_HDA_POWER_SAVE
 860         spec->loopback.amplist = preset->loopbacks;
 861 #endif
 862 }
 863
 864 /* Enable GPIO mask and set output */
 865 static struct hda_verb alc_gpio1_init_verbs[] = {
 866         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 867         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 868         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 869         { }
 870 };
 871
 872 static struct hda_verb alc_gpio2_init_verbs[] = {
 873         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 874         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 875         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 876         { }
 877 };
 878
 879 static struct hda_verb alc_gpio3_init_verbs[] = {
 880         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 881         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 882         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 883         { }
 884 };
 885
 886 /*
 887  * Fix hardware PLL issue
 888  * On some codecs, the analog PLL gating control must be off while
 889  * the default value is 1.
 890  */
 891 static void alc_fix_pll(struct hda_codec *codec)
 892 {
 893         struct alc_spec *spec = codec->spec;
 894         unsigned int val;
 895
 896         if (!spec->pll_nid)
 897                 return;
 898         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 899                             spec->pll_coef_idx);
 900         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 901                                  AC_VERB_GET_PROC_COEF, 0);
 902         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 903                             spec->pll_coef_idx);
 904         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 905                             val & ~(1 << spec->pll_coef_bit));
 906 }
 907
 908 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 909                              unsigned int coef_idx, unsigned int coef_bit)
 910 {
 911         struct alc_spec *spec = codec->spec;
 912         spec->pll_nid = nid;
 913         spec->pll_coef_idx = coef_idx;
 914         spec->pll_coef_bit = coef_bit;
 915         alc_fix_pll(codec);
 916 }
 917
 918 static void alc_sku_automute(struct hda_codec *codec)
 919 {
 920         struct alc_spec *spec = codec->spec;
 921         unsigned int present;
 922         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 923         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 924
 925         /* need to execute and sync at first */
 926         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 927         present = snd_hda_codec_read(codec, hp_nid, 0,
 928                                      AC_VERB_GET_PIN_SENSE, 0);
 929         spec->jack_present = (present & 0x80000000) != 0;
 930         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 931                             spec->jack_present ? 0 : PIN_OUT);
 932 }
 933
 934 #if 0 /* it's broken in some acses -- temporarily disabled */
 935 static void alc_mic_automute(struct hda_codec *codec)
 936 {
 937         struct alc_spec *spec = codec->spec;
 938         unsigned int present;
 939         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 940         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 941         unsigned int mix_nid = spec->capsrc_nids[0];
 942         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 943
 944         capsrc_idx_mic = mic_nid - 0x18;
 945         capsrc_idx_fmic = fmic_nid - 0x18;
 946         present = snd_hda_codec_read(codec, mic_nid, 0,
 947                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 948         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 949                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 950         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 951                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 952         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 953                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 954 }
 955 #else
 956 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 957 #endif /* disabled */
 958
 959 /* unsolicited event for HP jack sensing */
 960 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 961 {
 962         if (codec->vendor_id == 0x10ec0880)
 963                 res >>= 28;
 964         else
 965                 res >>= 26;
 966         if (res == ALC880_HP_EVENT)
 967                 alc_sku_automute(codec);
 968
 969         if (res == ALC880_MIC_EVENT)
 970                 alc_mic_automute(codec);
 971 }
 972
 973 static void alc_inithook(struct hda_codec *codec)
 974 {
 975         alc_sku_automute(codec);
 976         alc_mic_automute(codec);
 977 }
 978
 979 /* additional initialization for ALC888 variants */
 980 static void alc888_coef_init(struct hda_codec *codec)
 981 {
 982         unsigned int tmp;
 983
 984         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 985         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 986         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 987         if ((tmp & 0xf0) == 0x20)
 988                 /* alc888S-VC */
 989                 snd_hda_codec_read(codec, 0x20, 0,
 990                                    AC_VERB_SET_PROC_COEF, 0x830);
 991          else
 992                  /* alc888-VB */
 993                  snd_hda_codec_read(codec, 0x20, 0,
 994                                     AC_VERB_SET_PROC_COEF, 0x3030);
 995 }
 996
 997 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 998  *      31 ~ 16 :       Manufacture ID
 999  *      15 ~ 8  :       SKU ID
1000  *      7  ~ 0  :       Assembly ID
1001  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1002  */
1003 static void alc_subsystem_id(struct hda_codec *codec,
1004                              unsigned int porta, unsigned int porte,
1005                              unsigned int portd)
1006 {
1007         unsigned int ass, tmp, i;
1008         unsigned nid;
1009         struct alc_spec *spec = codec->spec;
1010
1011         ass = codec->subsystem_id & 0xffff;
1012         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1013                 goto do_sku;
1014
1015         /*
1016          * 31~30        : port conetcivity
1017          * 29~21        : reserve
1018          * 20           : PCBEEP input
1019          * 19~16        : Check sum (15:1)
1020          * 15~1         : Custom
1021          * 0            : override
1022         */
1023         nid = 0x1d;
1024         if (codec->vendor_id == 0x10ec0260)
1025                 nid = 0x17;
1026         ass = snd_hda_codec_get_pincfg(codec, nid);
1027         if (!(ass & 1) && !(ass & 0x100000))
1028                 return;
1029         if ((ass >> 30) != 1)   /* no physical connection */
1030                 return;
1031
1032         /* check sum */
1033         tmp = 0;
1034         for (i = 1; i < 16; i++) {
1035                 if ((ass >> i) & 1)
1036                         tmp++;
1037         }
1038         if (((ass >> 16) & 0xf) != tmp)
1039                 return;
1040 do_sku:
1041         /*
1042          * 0 : override
1043          * 1 :  Swap Jack
1044          * 2 : 0 --> Desktop, 1 --> Laptop
1045          * 3~5 : External Amplifier control
1046          * 7~6 : Reserved
1047         */
1048         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1049         switch (tmp) {
1050         case 1:
1051                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1052                 break;
1053         case 3:
1054                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1055                 break;
1056         case 7:
1057                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1058                 break;
1059         case 5: /* set EAPD output high */
1060                 switch (codec->vendor_id) {
1061                 case 0x10ec0260:
1062                         snd_hda_codec_write(codec, 0x0f, 0,
1063                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1064                         snd_hda_codec_write(codec, 0x10, 0,
1065                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1066                         break;
1067                 case 0x10ec0262:
1068                 case 0x10ec0267:
1069                 case 0x10ec0268:
1070                 case 0x10ec0269:
1071                 case 0x10ec0272:
1072                 case 0x10ec0660:
1073                 case 0x10ec0662:
1074                 case 0x10ec0663:
1075                 case 0x10ec0862:
1076                 case 0x10ec0889:
1077                         snd_hda_codec_write(codec, 0x14, 0,
1078                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1079                         snd_hda_codec_write(codec, 0x15, 0,
1080                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1081                         break;
1082                 }
1083                 switch (codec->vendor_id) {
1084                 case 0x10ec0260:
1085                         snd_hda_codec_write(codec, 0x1a, 0,
1086                                             AC_VERB_SET_COEF_INDEX, 7);
1087                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1088                                                  AC_VERB_GET_PROC_COEF, 0);
1089                         snd_hda_codec_write(codec, 0x1a, 0,
1090                                             AC_VERB_SET_COEF_INDEX, 7);
1091                         snd_hda_codec_write(codec, 0x1a, 0,
1092                                             AC_VERB_SET_PROC_COEF,
1093                                             tmp | 0x2010);
1094                         break;
1095                 case 0x10ec0262:
1096                 case 0x10ec0880:
1097                 case 0x10ec0882:
1098                 case 0x10ec0883:
1099                 case 0x10ec0885:
1100                 case 0x10ec0887:
1101                 case 0x10ec0889:
1102                         snd_hda_codec_write(codec, 0x20, 0,
1103                                             AC_VERB_SET_COEF_INDEX, 7);
1104                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1105                                                  AC_VERB_GET_PROC_COEF, 0);
1106                         snd_hda_codec_write(codec, 0x20, 0,
1107                                             AC_VERB_SET_COEF_INDEX, 7);
1108                         snd_hda_codec_write(codec, 0x20, 0,
1109                                             AC_VERB_SET_PROC_COEF,
1110                                             tmp | 0x2010);
1111                         break;
1112                 case 0x10ec0888:
1113                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1114                         break;
1115                 case 0x10ec0267:
1116                 case 0x10ec0268:
1117                         snd_hda_codec_write(codec, 0x20, 0,
1118                                             AC_VERB_SET_COEF_INDEX, 7);
1119                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1120                                                  AC_VERB_GET_PROC_COEF, 0);
1121                         snd_hda_codec_write(codec, 0x20, 0,
1122                                             AC_VERB_SET_COEF_INDEX, 7);
1123                         snd_hda_codec_write(codec, 0x20, 0,
1124                                             AC_VERB_SET_PROC_COEF,
1125                                             tmp | 0x3000);
1126                         break;
1127                 }
1128         default:
1129                 break;
1130         }
1131
1132         /* is laptop or Desktop and enable the function "Mute internal speaker
1133          * when the external headphone out jack is plugged"
1134          */
1135         if (!(ass & 0x8000))
1136                 return;
1137         /*
1138          * 10~8 : Jack location
1139          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1140          * 14~13: Resvered
1141          * 15   : 1 --> enable the function "Mute internal speaker
1142          *              when the external headphone out jack is plugged"
1143          */
1144         if (!spec->autocfg.speaker_pins[0]) {
1145                 if (spec->autocfg.line_out_pins[0])
1146                         spec->autocfg.speaker_pins[0] =
1147                                 spec->autocfg.line_out_pins[0];
1148                 else
1149                         return;
1150         }
1151
1152         if (!spec->autocfg.hp_pins[0]) {
1153                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1154                 if (tmp == 0)
1155                         spec->autocfg.hp_pins[0] = porta;
1156                 else if (tmp == 1)
1157                         spec->autocfg.hp_pins[0] = porte;
1158                 else if (tmp == 2)
1159                         spec->autocfg.hp_pins[0] = portd;
1160                 else
1161                         return;
1162         }
1163         if (spec->autocfg.hp_pins[0])
1164                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1165                         AC_VERB_SET_UNSOLICITED_ENABLE,
1166                         AC_USRSP_EN | ALC880_HP_EVENT);
1167
1168 #if 0 /* it's broken in some acses -- temporarily disabled */
1169         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1170                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1171                 snd_hda_codec_write(codec,
1172                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1173                         AC_VERB_SET_UNSOLICITED_ENABLE,
1174                         AC_USRSP_EN | ALC880_MIC_EVENT);
1175 #endif /* disabled */
1176
1177         spec->unsol_event = alc_sku_unsol_event;
1178 }
1179
1180 /*
1181  * Fix-up pin default configurations
1182  */
1183
1184 struct alc_pincfg {
1185         hda_nid_t nid;
1186         u32 val;
1187 };
1188
1189 static void alc_fix_pincfg(struct hda_codec *codec,
1190                            const struct snd_pci_quirk *quirk,
1191                            const struct alc_pincfg **pinfix)
1192 {
1193         const struct alc_pincfg *cfg;
1194
1195         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1196         if (!quirk)
1197                 return;
1198
1199         cfg = pinfix[quirk->value];
1200         for (; cfg->nid; cfg++)
1201                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1202 }
1203
1204 /*
1205  * ALC888
1206  */
1207
1208 /*
1209  * 2ch mode
1210  */
1211 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1212 /* Mic-in jack as mic in */
1213         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1214         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1215 /* Line-in jack as Line in */
1216         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1217         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1218 /* Line-Out as Front */
1219         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1220         { } /* end */
1221 };
1222
1223 /*
1224  * 4ch mode
1225  */
1226 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1227 /* Mic-in jack as mic in */
1228         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1229         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1230 /* Line-in jack as Surround */
1231         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1232         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1233 /* Line-Out as Front */
1234         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1235         { } /* end */
1236 };
1237
1238 /*
1239  * 6ch mode
1240  */
1241 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1242 /* Mic-in jack as CLFE */
1243         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1244         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1245 /* Line-in jack as Surround */
1246         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1247         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1248 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1249         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1250         { } /* end */
1251 };
1252
1253 /*
1254  * 8ch mode
1255  */
1256 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1257 /* Mic-in jack as CLFE */
1258         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1259         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1260 /* Line-in jack as Surround */
1261         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1262         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1263 /* Line-Out as Side */
1264         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1265         { } /* end */
1266 };
1267
1268 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1269         { 2, alc888_4ST_ch2_intel_init },
1270         { 4, alc888_4ST_ch4_intel_init },
1271         { 6, alc888_4ST_ch6_intel_init },
1272         { 8, alc888_4ST_ch8_intel_init },
1273 };
1274
1275 /*
1276  * ALC888 Fujitsu Siemens Amillo xa3530
1277  */
1278
1279 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1280 /* Front Mic: set to PIN_IN (empty by default) */
1281         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1282 /* Connect Internal HP to Front */
1283         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1284         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1285         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1286 /* Connect Bass HP to Front */
1287         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1288         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1289         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1290 /* Connect Line-Out side jack (SPDIF) to Side */
1291         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1292         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1293         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1294 /* Connect Mic jack to CLFE */
1295         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1296         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1297         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1298 /* Connect Line-in jack to Surround */
1299         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1300         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1301         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1302 /* Connect HP out jack to Front */
1303         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1304         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1305         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1306 /* Enable unsolicited event for HP jack and Line-out jack */
1307         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1308         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1309         {}
1310 };
1311
1312 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1313 {
1314         unsigned int present;
1315         unsigned int bits;
1316         /* Line out presence */
1317         present = snd_hda_codec_read(codec, 0x17, 0,
1318                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1319         /* HP out presence */
1320         present = present || snd_hda_codec_read(codec, 0x1b, 0,
1321                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1322         bits = present ? HDA_AMP_MUTE : 0;
1323         /* Toggle internal speakers muting */
1324         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1325                                  HDA_AMP_MUTE, bits);
1326         /* Toggle internal bass muting */
1327         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1328                                  HDA_AMP_MUTE, bits);
1329 }
1330
1331 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1332                 unsigned int res)
1333 {
1334         if (res >> 26 == ALC880_HP_EVENT)
1335                 alc888_fujitsu_xa3530_automute(codec);
1336 }
1337
1338
1339 /*
1340  * ALC888 Acer Aspire 4930G model
1341  */
1342
1343 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1344 /* Front Mic: set to PIN_IN (empty by default) */
1345         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1346 /* Unselect Front Mic by default in input mixer 3 */
1347         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1348 /* Enable unsolicited event for HP jack */
1349         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1350 /* Connect Internal HP to front */
1351         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1352         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1353         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1354 /* Connect HP out to front */
1355         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1356         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1357         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1358         { }
1359 };
1360
1361 static struct hda_input_mux alc888_2_capture_sources[2] = {
1362         /* Front mic only available on one ADC */
1363         {
1364                 .num_items = 4,
1365                 .items = {
1366                         { "Mic", 0x0 },
1367                         { "Line", 0x2 },
1368                         { "CD", 0x4 },
1369                         { "Front Mic", 0xb },
1370                 },
1371         },
1372         {
1373                 .num_items = 3,
1374                 .items = {
1375                         { "Mic", 0x0 },
1376                         { "Line", 0x2 },
1377                         { "CD", 0x4 },
1378                 },
1379         }
1380 };
1381
1382 static struct snd_kcontrol_new alc888_base_mixer[] = {
1383         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1384         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1385         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1386         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1387         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1388                 HDA_OUTPUT),
1389         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1390         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1391         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1392         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1393         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1394         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1395         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1396         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1397         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1399         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1400         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1401         { } /* end */
1402 };
1403
1404 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1405 {
1406         unsigned int present;
1407         unsigned int bits;
1408         present = snd_hda_codec_read(codec, 0x15, 0,
1409                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1410         bits = present ? HDA_AMP_MUTE : 0;
1411         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1412                                  HDA_AMP_MUTE, bits);
1413 }
1414
1415 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1416                 unsigned int res)
1417 {
1418         if (res >> 26 == ALC880_HP_EVENT)
1419                 alc888_acer_aspire_4930g_automute(codec);
1420 }
1421
1422 /*
1423  * ALC880 3-stack model
1424  *
1425  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1426  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1427  *                 F-Mic = 0x1b, HP = 0x19
1428  */
1429
1430 static hda_nid_t alc880_dac_nids[4] = {
1431         /* front, rear, clfe, rear_surr */
1432         0x02, 0x05, 0x04, 0x03
1433 };
1434
1435 static hda_nid_t alc880_adc_nids[3] = {
1436         /* ADC0-2 */
1437         0x07, 0x08, 0x09,
1438 };
1439
1440 /* The datasheet says the node 0x07 is connected from inputs,
1441  * but it shows zero connection in the real implementation on some devices.
1442  * Note: this is a 915GAV bug, fixed on 915GLV
1443  */
1444 static hda_nid_t alc880_adc_nids_alt[2] = {
1445         /* ADC1-2 */
1446         0x08, 0x09,
1447 };
1448
1449 #define ALC880_DIGOUT_NID       0x06
1450 #define ALC880_DIGIN_NID        0x0a
1451
1452 static struct hda_input_mux alc880_capture_source = {
1453         .num_items = 4,
1454         .items = {
1455                 { "Mic", 0x0 },
1456                 { "Front Mic", 0x3 },
1457                 { "Line", 0x2 },
1458                 { "CD", 0x4 },
1459         },
1460 };
1461
1462 /* channel source setting (2/6 channel selection for 3-stack) */
1463 /* 2ch mode */
1464 static struct hda_verb alc880_threestack_ch2_init[] = {
1465         /* set line-in to input, mute it */
1466         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1467         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1468         /* set mic-in to input vref 80%, mute it */
1469         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1470         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1471         { } /* end */
1472 };
1473
1474 /* 6ch mode */
1475 static struct hda_verb alc880_threestack_ch6_init[] = {
1476         /* set line-in to output, unmute it */
1477         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1478         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1479         /* set mic-in to output, unmute it */
1480         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1481         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1482         { } /* end */
1483 };
1484
1485 static struct hda_channel_mode alc880_threestack_modes[2] = {
1486         { 2, alc880_threestack_ch2_init },
1487         { 6, alc880_threestack_ch6_init },
1488 };
1489
1490 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1491         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1492         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1493         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1494         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1495         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1496         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1497         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1498         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1499         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1500         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1501         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1502         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1503         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1504         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1505         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1506         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1507         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1508         {
1509                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1510                 .name = "Channel Mode",
1511                 .info = alc_ch_mode_info,
1512                 .get = alc_ch_mode_get,
1513                 .put = alc_ch_mode_put,
1514         },
1515         { } /* end */
1516 };
1517
1518 /* capture mixer elements */
1519 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1520                             struct snd_ctl_elem_info *uinfo)
1521 {
1522         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1523         struct alc_spec *spec = codec->spec;
1524         int err;
1525
1526         mutex_lock(&codec->control_mutex);
1527         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1528                                                       HDA_INPUT);
1529         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1530         mutex_unlock(&codec->control_mutex);
1531         return err;
1532 }
1533
1534 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1535                            unsigned int size, unsigned int __user *tlv)
1536 {
1537         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1538         struct alc_spec *spec = codec->spec;
1539         int err;
1540
1541         mutex_lock(&codec->control_mutex);
1542         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1543                                                       HDA_INPUT);
1544         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1545         mutex_unlock(&codec->control_mutex);
1546         return err;
1547 }
1548
1549 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1550                              struct snd_ctl_elem_value *ucontrol);
1551
1552 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1553                                  struct snd_ctl_elem_value *ucontrol,
1554                                  getput_call_t func)
1555 {
1556         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1557         struct alc_spec *spec = codec->spec;
1558         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1559         int err;
1560
1561         mutex_lock(&codec->control_mutex);
1562         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1563                                                       3, 0, HDA_INPUT);
1564         err = func(kcontrol, ucontrol);
1565         mutex_unlock(&codec->control_mutex);
1566         return err;
1567 }
1568
1569 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1570                            struct snd_ctl_elem_value *ucontrol)
1571 {
1572         return alc_cap_getput_caller(kcontrol, ucontrol,
1573                                      snd_hda_mixer_amp_volume_get);
1574 }
1575
1576 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1577                            struct snd_ctl_elem_value *ucontrol)
1578 {
1579         return alc_cap_getput_caller(kcontrol, ucontrol,
1580                                      snd_hda_mixer_amp_volume_put);
1581 }
1582
1583 /* capture mixer elements */
1584 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1585
1586 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1587                           struct snd_ctl_elem_value *ucontrol)
1588 {
1589         return alc_cap_getput_caller(kcontrol, ucontrol,
1590                                      snd_hda_mixer_amp_switch_get);
1591 }
1592
1593 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1594                           struct snd_ctl_elem_value *ucontrol)
1595 {
1596         return alc_cap_getput_caller(kcontrol, ucontrol,
1597                                      snd_hda_mixer_amp_switch_put);
1598 }
1599
1600 #define _DEFINE_CAPMIX(num) \
1601         { \
1602                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1603                 .name = "Capture Switch", \
1604                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1605                 .count = num, \
1606                 .info = alc_cap_sw_info, \
1607                 .get = alc_cap_sw_get, \
1608                 .put = alc_cap_sw_put, \
1609         }, \
1610         { \
1611                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1612                 .name = "Capture Volume", \
1613                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1614                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1615                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1616                 .count = num, \
1617                 .info = alc_cap_vol_info, \
1618                 .get = alc_cap_vol_get, \
1619                 .put = alc_cap_vol_put, \
1620                 .tlv = { .c = alc_cap_vol_tlv }, \
1621         }
1622
1623 #define _DEFINE_CAPSRC(num) \
1624         { \
1625                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1626                 /* .name = "Capture Source", */ \
1627                 .name = "Input Source", \
1628                 .count = num, \
1629                 .info = alc_mux_enum_info, \
1630                 .get = alc_mux_enum_get, \
1631                 .put = alc_mux_enum_put, \
1632         }
1633
1634 #define DEFINE_CAPMIX(num) \
1635 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1636         _DEFINE_CAPMIX(num),                                  \
1637         _DEFINE_CAPSRC(num),                                  \
1638         { } /* end */                                         \
1639 }
1640
1641 #define DEFINE_CAPMIX_NOSRC(num) \
1642 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1643         _DEFINE_CAPMIX(num),                                        \
1644         { } /* end */                                               \
1645 }
1646
1647 /* up to three ADCs */
1648 DEFINE_CAPMIX(1);
1649 DEFINE_CAPMIX(2);
1650 DEFINE_CAPMIX(3);
1651 DEFINE_CAPMIX_NOSRC(1);
1652 DEFINE_CAPMIX_NOSRC(2);
1653 DEFINE_CAPMIX_NOSRC(3);
1654
1655 /*
1656  * ALC880 5-stack model
1657  *
1658  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1659  *      Side = 0x02 (0xd)
1660  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1661  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1662  */
1663
1664 /* additional mixers to alc880_three_stack_mixer */
1665 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1666         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1667         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1668         { } /* end */
1669 };
1670
1671 /* channel source setting (6/8 channel selection for 5-stack) */
1672 /* 6ch mode */
1673 static struct hda_verb alc880_fivestack_ch6_init[] = {
1674         /* set line-in to input, mute it */
1675         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1676         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1677         { } /* end */
1678 };
1679
1680 /* 8ch mode */
1681 static struct hda_verb alc880_fivestack_ch8_init[] = {
1682         /* set line-in to output, unmute it */
1683         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1684         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1685         { } /* end */
1686 };
1687
1688 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1689         { 6, alc880_fivestack_ch6_init },
1690         { 8, alc880_fivestack_ch8_init },
1691 };
1692
1693
1694 /*
1695  * ALC880 6-stack model
1696  *
1697  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1698  *      Side = 0x05 (0x0f)
1699  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1700  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1701  */
1702
1703 static hda_nid_t alc880_6st_dac_nids[4] = {
1704         /* front, rear, clfe, rear_surr */
1705         0x02, 0x03, 0x04, 0x05
1706 };
1707
1708 static struct hda_input_mux alc880_6stack_capture_source = {
1709         .num_items = 4,
1710         .items = {
1711                 { "Mic", 0x0 },
1712                 { "Front Mic", 0x1 },
1713                 { "Line", 0x2 },
1714                 { "CD", 0x4 },
1715         },
1716 };
1717
1718 /* fixed 8-channels */
1719 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1720         { 8, NULL },
1721 };
1722
1723 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1724         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1725         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1726         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1727         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1728         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1729         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1730         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1731         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1732         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1733         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1734         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1735         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1736         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1737         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1738         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1739         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1740         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1741         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1742         {
1743                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1744                 .name = "Channel Mode",
1745                 .info = alc_ch_mode_info,
1746                 .get = alc_ch_mode_get,
1747                 .put = alc_ch_mode_put,
1748         },
1749         { } /* end */
1750 };
1751
1752
1753 /*
1754  * ALC880 W810 model
1755  *
1756  * W810 has rear IO for:
1757  * Front (DAC 02)
1758  * Surround (DAC 03)
1759  * Center/LFE (DAC 04)
1760  * Digital out (06)
1761  *
1762  * The system also has a pair of internal speakers, and a headphone jack.
1763  * These are both connected to Line2 on the codec, hence to DAC 02.
1764  *
1765  * There is a variable resistor to control the speaker or headphone
1766  * volume. This is a hardware-only device without a software API.
1767  *
1768  * Plugging headphones in will disable the internal speakers. This is
1769  * implemented in hardware, not via the driver using jack sense. In
1770  * a similar fashion, plugging into the rear socket marked "front" will
1771  * disable both the speakers and headphones.
1772  *
1773  * For input, there's a microphone jack, and an "audio in" jack.
1774  * These may not do anything useful with this driver yet, because I
1775  * haven't setup any initialization verbs for these yet...
1776  */
1777
1778 static hda_nid_t alc880_w810_dac_nids[3] = {
1779         /* front, rear/surround, clfe */
1780         0x02, 0x03, 0x04
1781 };
1782
1783 /* fixed 6 channels */
1784 static struct hda_channel_mode alc880_w810_modes[1] = {
1785         { 6, NULL }
1786 };
1787
1788 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1789 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1790         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1791         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1792         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1793         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1794         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1795         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1796         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1797         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1798         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1799         { } /* end */
1800 };
1801
1802
1803 /*
1804  * Z710V model
1805  *
1806  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1807  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1808  *                 Line = 0x1a
1809  */
1810
1811 static hda_nid_t alc880_z71v_dac_nids[1] = {
1812         0x02
1813 };
1814 #define ALC880_Z71V_HP_DAC      0x03
1815
1816 /* fixed 2 channels */
1817 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1818         { 2, NULL }
1819 };
1820
1821 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1822         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1823         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1824         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1825         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1826         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1827         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1828         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1829         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1830         { } /* end */
1831 };
1832
1833
1834 /*
1835  * ALC880 F1734 model
1836  *
1837  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1838  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1839  */
1840
1841 static hda_nid_t alc880_f1734_dac_nids[1] = {
1842         0x03
1843 };
1844 #define ALC880_F1734_HP_DAC     0x02
1845
1846 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1847         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1848         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1849         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1850         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1851         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1852         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1853         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1854         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1855         { } /* end */
1856 };
1857
1858 static struct hda_input_mux alc880_f1734_capture_source = {
1859         .num_items = 2,
1860         .items = {
1861                 { "Mic", 0x1 },
1862                 { "CD", 0x4 },
1863         },
1864 };
1865
1866
1867 /*
1868  * ALC880 ASUS model
1869  *
1870  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1871  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1872  *  Mic = 0x18, Line = 0x1a
1873  */
1874
1875 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1876 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1877
1878 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1880         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1881         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1882         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1883         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1884         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1885         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1886         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1887         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1888         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1889         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1890         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1893         {
1894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1895                 .name = "Channel Mode",
1896                 .info = alc_ch_mode_info,
1897                 .get = alc_ch_mode_get,
1898                 .put = alc_ch_mode_put,
1899         },
1900         { } /* end */
1901 };
1902
1903 /*
1904  * ALC880 ASUS W1V model
1905  *
1906  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1907  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1908  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1909  */
1910
1911 /* additional mixers to alc880_asus_mixer */
1912 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1913         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1914         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1915         { } /* end */
1916 };
1917
1918 /* TCL S700 */
1919 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1920         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1921         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1922         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1923         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1924         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1925         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1926         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1927         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1928         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1929         { } /* end */
1930 };
1931
1932 /* Uniwill */
1933 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1934         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1935         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1936         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1937         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1938         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1939         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1940         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1941         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1942         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1943         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1944         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1945         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1946         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1947         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1948         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1949         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1950         {
1951                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1952                 .name = "Channel Mode",
1953                 .info = alc_ch_mode_info,
1954                 .get = alc_ch_mode_get,
1955                 .put = alc_ch_mode_put,
1956         },
1957         { } /* end */
1958 };
1959
1960 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1961         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1962         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1963         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1964         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1965         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1966         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1967         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1968         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1969         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1970         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1971         { } /* end */
1972 };
1973
1974 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1975         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1976         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1977         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1978         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1979         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1980         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1981         { } /* end */
1982 };
1983
1984 /*
1985  * virtual master controls
1986  */
1987
1988 /*
1989  * slave controls for virtual master
1990  */
1991 static const char *alc_slave_vols[] = {
1992         "Front Playback Volume",
1993         "Surround Playback Volume",
1994         "Center Playback Volume",
1995         "LFE Playback Volume",
1996         "Side Playback Volume",
1997         "Headphone Playback Volume",
1998         "Speaker Playback Volume",
1999         "Mono Playback Volume",
2000         "Line-Out Playback Volume",
2001         "PCM Playback Volume",
2002         NULL,
2003 };
2004
2005 static const char *alc_slave_sws[] = {
2006         "Front Playback Switch",
2007         "Surround Playback Switch",
2008         "Center Playback Switch",
2009         "LFE Playback Switch",
2010         "Side Playback Switch",
2011         "Headphone Playback Switch",
2012         "Speaker Playback Switch",
2013         "Mono Playback Switch",
2014         "IEC958 Playback Switch",
2015         NULL,
2016 };
2017
2018 /*
2019  * build control elements
2020  */
2021
2022 static void alc_free_kctls(struct hda_codec *codec);
2023
2024 /* additional beep mixers; the actual parameters are overwritten at build */
2025 static struct snd_kcontrol_new alc_beep_mixer[] = {
2026         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2027         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2028         { } /* end */
2029 };
2030
2031 static int alc_build_controls(struct hda_codec *codec)
2032 {
2033         struct alc_spec *spec = codec->spec;
2034         int err;
2035         int i;
2036
2037         for (i = 0; i < spec->num_mixers; i++) {
2038                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2039                 if (err < 0)
2040                         return err;
2041         }
2042         if (spec->cap_mixer) {
2043                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2044                 if (err < 0)
2045                         return err;
2046         }
2047         if (spec->multiout.dig_out_nid) {
2048                 err = snd_hda_create_spdif_out_ctls(codec,
2049                                                     spec->multiout.dig_out_nid);
2050                 if (err < 0)
2051                         return err;
2052                 if (!spec->no_analog) {
2053                         err = snd_hda_create_spdif_share_sw(codec,
2054                                                             &spec->multiout);
2055                         if (err < 0)
2056                                 return err;
2057                         spec->multiout.share_spdif = 1;
2058                 }
2059         }
2060         if (spec->dig_in_nid) {
2061                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2062                 if (err < 0)
2063                         return err;
2064         }
2065
2066         /* create beep controls if needed */
2067         if (spec->beep_amp) {
2068                 struct snd_kcontrol_new *knew;
2069                 for (knew = alc_beep_mixer; knew->name; knew++) {
2070                         struct snd_kcontrol *kctl;
2071                         kctl = snd_ctl_new1(knew, codec);
2072                         if (!kctl)
2073                                 return -ENOMEM;
2074                         kctl->private_value = spec->beep_amp;
2075                         err = snd_hda_ctl_add(codec, kctl);
2076                         if (err < 0)
2077                                 return err;
2078                 }
2079         }
2080
2081         /* if we have no master control, let's create it */
2082         if (!spec->no_analog &&
2083             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2084                 unsigned int vmaster_tlv[4];
2085                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2086                                         HDA_OUTPUT, vmaster_tlv);
2087                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2088                                           vmaster_tlv, alc_slave_vols);
2089                 if (err < 0)
2090                         return err;
2091         }
2092         if (!spec->no_analog &&
2093             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2094                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2095                                           NULL, alc_slave_sws);
2096                 if (err < 0)
2097                         return err;
2098         }
2099
2100         alc_free_kctls(codec); /* no longer needed */
2101         return 0;
2102 }
2103
2104
2105 /*
2106  * initialize the codec volumes, etc
2107  */
2108
2109 /*
2110  * generic initialization of ADC, input mixers and output mixers
2111  */
2112 static struct hda_verb alc880_volume_init_verbs[] = {
2113         /*
2114          * Unmute ADC0-2 and set the default input to mic-in
2115          */
2116         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2117         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2118         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2119         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2120         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2121         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2122
2123         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2124          * mixer widget
2125          * Note: PASD motherboards uses the Line In 2 as the input for front
2126          * panel mic (mic 2)
2127          */
2128         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2129         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2130         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2131         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2132         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2133         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2134         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2135         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2136
2137         /*
2138          * Set up output mixers (0x0c - 0x0f)
2139          */
2140         /* set vol=0 to output mixers */
2141         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2142         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2143         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2144         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2145         /* set up input amps for analog loopback */
2146         /* Amp Indices: DAC = 0, mixer = 1 */
2147         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2148         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2149         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2150         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2151         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2152         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2153         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2154         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2155
2156         { }
2157 };
2158
2159 /*
2160  * 3-stack pin configuration:
2161  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2162  */
2163 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2164         /*
2165          * preset connection lists of input pins
2166          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2167          */
2168         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2169         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2170         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2171
2172         /*
2173          * Set pin mode and muting
2174          */
2175         /* set front pin widgets 0x14 for output */
2176         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2177         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2178         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2179         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2180         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2181         /* Mic2 (as headphone out) for HP output */
2182         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2183         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2184         /* Line In pin widget for input */
2185         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2186         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2187         /* Line2 (as front mic) pin widget for input and vref at 80% */
2188         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2189         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2190         /* CD pin widget for input */
2191         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2192
2193         { }
2194 };
2195
2196 /*
2197  * 5-stack pin configuration:
2198  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2199  * line-in/side = 0x1a, f-mic = 0x1b
2200  */
2201 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2202         /*
2203          * preset connection lists of input pins
2204          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2205          */
2206         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2207         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2208
2209         /*
2210          * Set pin mode and muting
2211          */
2212         /* set pin widgets 0x14-0x17 for output */
2213         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2214         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2215         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2216         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2217         /* unmute pins for output (no gain on this amp) */
2218         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2219         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2220         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2221         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2222
2223         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2224         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2225         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2226         /* Mic2 (as headphone out) for HP output */
2227         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2228         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2229         /* Line In pin widget for input */
2230         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2231         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2232         /* Line2 (as front mic) pin widget for input and vref at 80% */
2233         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2234         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2235         /* CD pin widget for input */
2236         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2237
2238         { }
2239 };
2240
2241 /*
2242  * W810 pin configuration:
2243  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2244  */
2245 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2246         /* hphone/speaker input selector: front DAC */
2247         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2248
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_OUT},
2252         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2253         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2254         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2255
2256         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2257         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2258
2259         { }
2260 };
2261
2262 /*
2263  * Z71V pin configuration:
2264  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2265  */
2266 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2267         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2268         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2269         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2271
2272         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2273         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2274         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2275         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2276
2277         { }
2278 };
2279
2280 /*
2281  * 6-stack pin configuration:
2282  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2283  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2284  */
2285 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2286         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2287
2288         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2289         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2290         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2291         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2292         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2293         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2294         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2295         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2296
2297         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2298         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2299         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2300         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2301         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2302         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2303         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2304         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2305         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2306
2307         { }
2308 };
2309
2310 /*
2311  * Uniwill pin configuration:
2312  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2313  * line = 0x1a
2314  */
2315 static struct hda_verb alc880_uniwill_init_verbs[] = {
2316         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2317
2318         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2319         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2320         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2321         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2322         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2323         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2324         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2325         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2326         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2327         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2328         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2329         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2330         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2331         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2332
2333         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2334         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2335         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2336         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2337         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2338         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2339         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2340         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2341         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2342
2343         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2344         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2345
2346         { }
2347 };
2348
2349 /*
2350 * Uniwill P53
2351 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2352  */
2353 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2354         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2355
2356         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2357         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2358         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2359         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2360         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2361         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2362         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2363         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2364         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2365         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2366         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2367         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2368
2369         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2370         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2371         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2372         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2373         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2374         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2375
2376         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2377         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2378
2379         { }
2380 };
2381
2382 static struct hda_verb alc880_beep_init_verbs[] = {
2383         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2384         { }
2385 };
2386
2387 /* toggle speaker-output according to the hp-jack state */
2388 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2389 {
2390         unsigned int present;
2391         unsigned char bits;
2392
2393         present = snd_hda_codec_read(codec, 0x14, 0,
2394                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2395         bits = present ? HDA_AMP_MUTE : 0;
2396         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2397                                  HDA_AMP_MUTE, bits);
2398         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2399                                  HDA_AMP_MUTE, bits);
2400 }
2401
2402 /* auto-toggle front mic */
2403 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2404 {
2405         unsigned int present;
2406         unsigned char bits;
2407
2408         present = snd_hda_codec_read(codec, 0x18, 0,
2409                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2410         bits = present ? HDA_AMP_MUTE : 0;
2411         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2412 }
2413
2414 static void alc880_uniwill_automute(struct hda_codec *codec)
2415 {
2416         alc880_uniwill_hp_automute(codec);
2417         alc880_uniwill_mic_automute(codec);
2418 }
2419
2420 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2421                                        unsigned int res)
2422 {
2423         /* Looks like the unsol event is incompatible with the standard
2424          * definition.  4bit tag is placed at 28 bit!
2425          */
2426         switch (res >> 28) {
2427         case ALC880_HP_EVENT:
2428                 alc880_uniwill_hp_automute(codec);
2429                 break;
2430         case ALC880_MIC_EVENT:
2431                 alc880_uniwill_mic_automute(codec);
2432                 break;
2433         }
2434 }
2435
2436 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2437 {
2438         unsigned int present;
2439         unsigned char bits;
2440
2441         present = snd_hda_codec_read(codec, 0x14, 0,
2442                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2443         bits = present ? HDA_AMP_MUTE : 0;
2444         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2445 }
2446
2447 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2448 {
2449         unsigned int present;
2450
2451         present = snd_hda_codec_read(codec, 0x21, 0,
2452                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2453         present &= HDA_AMP_VOLMASK;
2454         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2455                                  HDA_AMP_VOLMASK, present);
2456         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2457                                  HDA_AMP_VOLMASK, present);
2458 }
2459
2460 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2461                                            unsigned int res)
2462 {
2463         /* Looks like the unsol event is incompatible with the standard
2464          * definition.  4bit tag is placed at 28 bit!
2465          */
2466         if ((res >> 28) == ALC880_HP_EVENT)
2467                 alc880_uniwill_p53_hp_automute(codec);
2468         if ((res >> 28) == ALC880_DCVOL_EVENT)
2469                 alc880_uniwill_p53_dcvol_automute(codec);
2470 }
2471
2472 /*
2473  * F1734 pin configuration:
2474  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2475  */
2476 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2477         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2478         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2479         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2480         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2481         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2482
2483         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2484         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2485         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2486         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2487
2488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2489         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2490         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2491         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2492         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2493         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2494         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2495         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2496         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2497
2498         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2499         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2500
2501         { }
2502 };
2503
2504 /*
2505  * ASUS pin configuration:
2506  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2507  */
2508 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2509         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2510         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2511         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2512         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2513
2514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2515         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2516         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2517         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2518         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2519         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2520         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2521         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2522
2523         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2524         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2525         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2526         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2527         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2528         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2529         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2530         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2531         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2532
2533         { }
2534 };
2535
2536 /* Enable GPIO mask and set output */
2537 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2538 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2539
2540 /* Clevo m520g init */
2541 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2542         /* headphone output */
2543         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2544         /* line-out */
2545         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2546         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2547         /* Line-in */
2548         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2549         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2550         /* CD */
2551         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2552         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2553         /* Mic1 (rear panel) */
2554         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2555         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2556         /* Mic2 (front panel) */
2557         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2558         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2559         /* headphone */
2560         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2561         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2562         /* change to EAPD mode */
2563         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2564         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2565
2566         { }
2567 };
2568
2569 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2570         /* change to EAPD mode */
2571         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2572         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2573
2574         /* Headphone output */
2575         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2576         /* Front output*/
2577         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2578         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2579
2580         /* Line In pin widget for input */
2581         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2582         /* CD pin widget for input */
2583         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2584         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2585         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2586
2587         /* change to EAPD mode */
2588         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2589         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2590
2591         { }
2592 };
2593
2594 /*
2595  * LG m1 express dual
2596  *
2597  * Pin assignment:
2598  *   Rear Line-In/Out (blue): 0x14
2599  *   Build-in Mic-In: 0x15
2600  *   Speaker-out: 0x17
2601  *   HP-Out (green): 0x1b
2602  *   Mic-In/Out (red): 0x19
2603  *   SPDIF-Out: 0x1e
2604  */
2605
2606 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2607 static hda_nid_t alc880_lg_dac_nids[3] = {
2608         0x05, 0x02, 0x03
2609 };
2610
2611 /* seems analog CD is not working */
2612 static struct hda_input_mux alc880_lg_capture_source = {
2613         .num_items = 3,
2614         .items = {
2615                 { "Mic", 0x1 },
2616                 { "Line", 0x5 },
2617                 { "Internal Mic", 0x6 },
2618         },
2619 };
2620
2621 /* 2,4,6 channel modes */
2622 static struct hda_verb alc880_lg_ch2_init[] = {
2623         /* set line-in and mic-in to input */
2624         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2625         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2626         { }
2627 };
2628
2629 static struct hda_verb alc880_lg_ch4_init[] = {
2630         /* set line-in to out and mic-in to input */
2631         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2632         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2633         { }
2634 };
2635
2636 static struct hda_verb alc880_lg_ch6_init[] = {
2637         /* set line-in and mic-in to output */
2638         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2639         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2640         { }
2641 };
2642
2643 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2644         { 2, alc880_lg_ch2_init },
2645         { 4, alc880_lg_ch4_init },
2646         { 6, alc880_lg_ch6_init },
2647 };
2648
2649 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2650         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2651         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2652         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2653         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2654         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2655         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2656         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2657         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2658         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2659         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2660         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2661         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2662         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2663         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2664         {
2665                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2666                 .name = "Channel Mode",
2667                 .info = alc_ch_mode_info,
2668                 .get = alc_ch_mode_get,
2669                 .put = alc_ch_mode_put,
2670         },
2671         { } /* end */
2672 };
2673
2674 static struct hda_verb alc880_lg_init_verbs[] = {
2675         /* set capture source to mic-in */
2676         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2677         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2678         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2679         /* mute all amp mixer inputs */
2680         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2681         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2682         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2683         /* line-in to input */
2684         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2685         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2686         /* built-in mic */
2687         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2688         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2689         /* speaker-out */
2690         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2691         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2692         /* mic-in to input */
2693         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2694         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2695         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2696         /* HP-out */
2697         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2698         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2699         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2700         /* jack sense */
2701         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2702         { }
2703 };
2704
2705 /* toggle speaker-output according to the hp-jack state */
2706 static void alc880_lg_automute(struct hda_codec *codec)
2707 {
2708         unsigned int present;
2709         unsigned char bits;
2710
2711         present = snd_hda_codec_read(codec, 0x1b, 0,
2712                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2713         bits = present ? HDA_AMP_MUTE : 0;
2714         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2715                                  HDA_AMP_MUTE, bits);
2716 }
2717
2718 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2719 {
2720         /* Looks like the unsol event is incompatible with the standard
2721          * definition.  4bit tag is placed at 28 bit!
2722          */
2723         if ((res >> 28) == 0x01)
2724                 alc880_lg_automute(codec);
2725 }
2726
2727 /*
2728  * LG LW20
2729  *
2730  * Pin assignment:
2731  *   Speaker-out: 0x14
2732  *   Mic-In: 0x18
2733  *   Built-in Mic-In: 0x19
2734  *   Line-In: 0x1b
2735  *   HP-Out: 0x1a
2736  *   SPDIF-Out: 0x1e
2737  */
2738
2739 static struct hda_input_mux alc880_lg_lw_capture_source = {
2740         .num_items = 3,
2741         .items = {
2742                 { "Mic", 0x0 },
2743                 { "Internal Mic", 0x1 },
2744                 { "Line In", 0x2 },
2745         },
2746 };
2747
2748 #define alc880_lg_lw_modes alc880_threestack_modes
2749
2750 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2751         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2752         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2753         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2754         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2755         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2756         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2757         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2758         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2759         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2760         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2761         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2762         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2763         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2764         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2765         {
2766                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2767                 .name = "Channel Mode",
2768                 .info = alc_ch_mode_info,
2769                 .get = alc_ch_mode_get,
2770                 .put = alc_ch_mode_put,
2771         },
2772         { } /* end */
2773 };
2774
2775 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2776         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2777         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2778         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2779
2780         /* set capture source to mic-in */
2781         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2782         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2783         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2784         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2785         /* speaker-out */
2786         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2787         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2788         /* HP-out */
2789         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2790         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2791         /* mic-in to input */
2792         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2793         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2794         /* built-in mic */
2795         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2796         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2797         /* jack sense */
2798         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2799         { }
2800 };
2801
2802 /* toggle speaker-output according to the hp-jack state */
2803 static void alc880_lg_lw_automute(struct hda_codec *codec)
2804 {
2805         unsigned int present;
2806         unsigned char bits;
2807
2808         present = snd_hda_codec_read(codec, 0x1b, 0,
2809                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2810         bits = present ? HDA_AMP_MUTE : 0;
2811         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2812                                  HDA_AMP_MUTE, bits);
2813 }
2814
2815 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2816 {
2817         /* Looks like the unsol event is incompatible with the standard
2818          * definition.  4bit tag is placed at 28 bit!
2819          */
2820         if ((res >> 28) == 0x01)
2821                 alc880_lg_lw_automute(codec);
2822 }
2823
2824 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2825         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2826         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2827         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2828         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2829         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2830         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2831         { } /* end */
2832 };
2833
2834 static struct hda_input_mux alc880_medion_rim_capture_source = {
2835         .num_items = 2,
2836         .items = {
2837                 { "Mic", 0x0 },
2838                 { "Internal Mic", 0x1 },
2839         },
2840 };
2841
2842 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2843         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2844
2845         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2846         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2847
2848         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2849         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2850         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2851         /* Mic2 (as headphone out) for HP output */
2852         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2853         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2854         /* Internal Speaker */
2855         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2856         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2857
2858         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2859         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2860
2861         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2862         { }
2863 };
2864
2865 /* toggle speaker-output according to the hp-jack state */
2866 static void alc880_medion_rim_automute(struct hda_codec *codec)
2867 {
2868         unsigned int present;
2869         unsigned char bits;
2870
2871         present = snd_hda_codec_read(codec, 0x14, 0,
2872                                      AC_VERB_GET_PIN_SENSE, 0)
2873                 & AC_PINSENSE_PRESENCE;
2874         bits = present ? HDA_AMP_MUTE : 0;
2875         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2876                                  HDA_AMP_MUTE, bits);
2877         if (present)
2878                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2879         else
2880                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2881 }
2882
2883 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2884                                           unsigned int res)
2885 {
2886         /* Looks like the unsol event is incompatible with the standard
2887          * definition.  4bit tag is placed at 28 bit!
2888          */
2889         if ((res >> 28) == ALC880_HP_EVENT)
2890                 alc880_medion_rim_automute(codec);
2891 }
2892
2893 #ifdef CONFIG_SND_HDA_POWER_SAVE
2894 static struct hda_amp_list alc880_loopbacks[] = {
2895         { 0x0b, HDA_INPUT, 0 },
2896         { 0x0b, HDA_INPUT, 1 },
2897         { 0x0b, HDA_INPUT, 2 },
2898         { 0x0b, HDA_INPUT, 3 },
2899         { 0x0b, HDA_INPUT, 4 },
2900         { } /* end */
2901 };
2902
2903 static struct hda_amp_list alc880_lg_loopbacks[] = {
2904         { 0x0b, HDA_INPUT, 1 },
2905         { 0x0b, HDA_INPUT, 6 },
2906         { 0x0b, HDA_INPUT, 7 },
2907         { } /* end */
2908 };
2909 #endif
2910
2911 /*
2912  * Common callbacks
2913  */
2914
2915 static int alc_init(struct hda_codec *codec)
2916 {
2917         struct alc_spec *spec = codec->spec;
2918         unsigned int i;
2919
2920         alc_fix_pll(codec);
2921         if (codec->vendor_id == 0x10ec0888)
2922                 alc888_coef_init(codec);
2923
2924         for (i = 0; i < spec->num_init_verbs; i++)
2925                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2926
2927         if (spec->init_hook)
2928                 spec->init_hook(codec);
2929
2930         return 0;
2931 }
2932
2933 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2934 {
2935         struct alc_spec *spec = codec->spec;
2936
2937         if (spec->unsol_event)
2938                 spec->unsol_event(codec, res);
2939 }
2940
2941 #ifdef CONFIG_SND_HDA_POWER_SAVE
2942 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2943 {
2944         struct alc_spec *spec = codec->spec;
2945         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2946 }
2947 #endif
2948
2949 /*
2950  * Analog playback callbacks
2951  */
2952 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2953                                     struct hda_codec *codec,
2954                                     struct snd_pcm_substream *substream)
2955 {
2956         struct alc_spec *spec = codec->spec;
2957         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2958                                              hinfo);
2959 }
2960
2961 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2962                                        struct hda_codec *codec,
2963                                        unsigned int stream_tag,
2964                                        unsigned int format,
2965                                        struct snd_pcm_substream *substream)
2966 {
2967         struct alc_spec *spec = codec->spec;
2968         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2969                                                 stream_tag, format, substream);
2970 }
2971
2972 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2973                                        struct hda_codec *codec,
2974                                        struct snd_pcm_substream *substream)
2975 {
2976         struct alc_spec *spec = codec->spec;
2977         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2978 }
2979
2980 /*
2981  * Digital out
2982  */
2983 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2984                                         struct hda_codec *codec,
2985                                         struct snd_pcm_substream *substream)
2986 {
2987         struct alc_spec *spec = codec->spec;
2988         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2989 }
2990
2991 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2992                                            struct hda_codec *codec,
2993                                            unsigned int stream_tag,
2994                                            unsigned int format,
2995                                            struct snd_pcm_substream *substream)
2996 {
2997         struct alc_spec *spec = codec->spec;
2998         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2999                                              stream_tag, format, substream);
3000 }
3001
3002 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3003                                            struct hda_codec *codec,
3004                                            struct snd_pcm_substream *substream)
3005 {
3006         struct alc_spec *spec = codec->spec;
3007         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3008 }
3009
3010 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3011                                          struct hda_codec *codec,
3012                                          struct snd_pcm_substream *substream)
3013 {
3014         struct alc_spec *spec = codec->spec;
3015         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3016 }
3017
3018 /*
3019  * Analog capture
3020  */
3021 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3022                                       struct hda_codec *codec,
3023                                       unsigned int stream_tag,
3024                                       unsigned int format,
3025                                       struct snd_pcm_substream *substream)
3026 {
3027         struct alc_spec *spec = codec->spec;
3028
3029         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3030                                    stream_tag, 0, format);
3031         return 0;
3032 }
3033
3034 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3035                                       struct hda_codec *codec,
3036                                       struct snd_pcm_substream *substream)
3037 {
3038         struct alc_spec *spec = codec->spec;
3039
3040         snd_hda_codec_cleanup_stream(codec,
3041                                      spec->adc_nids[substream->number + 1]);
3042         return 0;
3043 }
3044
3045
3046 /*
3047  */
3048 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3049         .substreams = 1,
3050         .channels_min = 2,
3051         .channels_max = 8,
3052         /* NID is set in alc_build_pcms */
3053         .ops = {
3054                 .open = alc880_playback_pcm_open,
3055                 .prepare = alc880_playback_pcm_prepare,
3056                 .cleanup = alc880_playback_pcm_cleanup
3057         },
3058 };
3059
3060 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3061         .substreams = 1,
3062         .channels_min = 2,
3063         .channels_max = 2,
3064         /* NID is set in alc_build_pcms */
3065 };
3066
3067 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3068         .substreams = 1,
3069         .channels_min = 2,
3070         .channels_max = 2,
3071         /* NID is set in alc_build_pcms */
3072 };
3073
3074 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3075         .substreams = 2, /* can be overridden */
3076         .channels_min = 2,
3077         .channels_max = 2,
3078         /* NID is set in alc_build_pcms */
3079         .ops = {
3080                 .prepare = alc880_alt_capture_pcm_prepare,
3081                 .cleanup = alc880_alt_capture_pcm_cleanup
3082         },
3083 };
3084
3085 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3086         .substreams = 1,
3087         .channels_min = 2,
3088         .channels_max = 2,
3089         /* NID is set in alc_build_pcms */
3090         .ops = {
3091                 .open = alc880_dig_playback_pcm_open,
3092                 .close = alc880_dig_playback_pcm_close,
3093                 .prepare = alc880_dig_playback_pcm_prepare,
3094                 .cleanup = alc880_dig_playback_pcm_cleanup
3095         },
3096 };
3097
3098 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3099         .substreams = 1,
3100         .channels_min = 2,
3101         .channels_max = 2,
3102         /* NID is set in alc_build_pcms */
3103 };
3104
3105 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3106 static struct hda_pcm_stream alc_pcm_null_stream = {
3107         .substreams = 0,
3108         .channels_min = 0,
3109         .channels_max = 0,
3110 };
3111
3112 static int alc_build_pcms(struct hda_codec *codec)
3113 {
3114         struct alc_spec *spec = codec->spec;
3115         struct hda_pcm *info = spec->pcm_rec;
3116         int i;
3117
3118         codec->num_pcms = 1;
3119         codec->pcm_info = info;
3120
3121         if (spec->no_analog)
3122                 goto skip_analog;
3123
3124         info->name = spec->stream_name_analog;
3125         if (spec->stream_analog_playback) {
3126                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3127                         return -EINVAL;
3128                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3129                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3130         }
3131         if (spec->stream_analog_capture) {
3132                 if (snd_BUG_ON(!spec->adc_nids))
3133                         return -EINVAL;
3134                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3135                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3136         }
3137
3138         if (spec->channel_mode) {
3139                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3140                 for (i = 0; i < spec->num_channel_mode; i++) {
3141                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3142                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3143                         }
3144                 }
3145         }
3146
3147  skip_analog:
3148         /* SPDIF for stream index #1 */
3149         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3150                 codec->num_pcms = 2;
3151                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3152                 info = spec->pcm_rec + 1;
3153                 info->name = spec->stream_name_digital;
3154                 if (spec->dig_out_type)
3155                         info->pcm_type = spec->dig_out_type;
3156                 else
3157                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3158                 if (spec->multiout.dig_out_nid &&
3159                     spec->stream_digital_playback) {
3160                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3161                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3162                 }
3163                 if (spec->dig_in_nid &&
3164                     spec->stream_digital_capture) {
3165                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3166                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3167                 }
3168                 /* FIXME: do we need this for all Realtek codec models? */
3169                 codec->spdif_status_reset = 1;
3170         }
3171
3172         if (spec->no_analog)
3173                 return 0;
3174
3175         /* If the use of more than one ADC is requested for the current
3176          * model, configure a second analog capture-only PCM.
3177          */
3178         /* Additional Analaog capture for index #2 */
3179         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3180             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3181                 codec->num_pcms = 3;
3182                 info = spec->pcm_rec + 2;
3183                 info->name = spec->stream_name_analog;
3184                 if (spec->alt_dac_nid) {
3185                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3186                                 *spec->stream_analog_alt_playback;
3187                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3188                                 spec->alt_dac_nid;
3189                 } else {
3190                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3191                                 alc_pcm_null_stream;
3192                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3193                 }
3194                 if (spec->num_adc_nids > 1) {
3195                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3196                                 *spec->stream_analog_alt_capture;
3197                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3198                                 spec->adc_nids[1];
3199                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3200                                 spec->num_adc_nids - 1;
3201                 } else {
3202                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3203                                 alc_pcm_null_stream;
3204                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3205                 }
3206         }
3207
3208         return 0;
3209 }
3210
3211 static void alc_free_kctls(struct hda_codec *codec)
3212 {
3213         struct alc_spec *spec = codec->spec;
3214
3215         if (spec->kctls.list) {
3216                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3217                 int i;
3218                 for (i = 0; i < spec->kctls.used; i++)
3219                         kfree(kctl[i].name);
3220         }
3221         snd_array_free(&spec->kctls);
3222 }
3223
3224 static void alc_free(struct hda_codec *codec)
3225 {
3226         struct alc_spec *spec = codec->spec;
3227
3228         if (!spec)
3229                 return;
3230
3231         alc_free_kctls(codec);
3232         kfree(spec);
3233         snd_hda_detach_beep_device(codec);
3234 }
3235
3236 #ifdef SND_HDA_NEEDS_RESUME
3237 static int alc_resume(struct hda_codec *codec)
3238 {
3239         codec->patch_ops.init(codec);
3240         snd_hda_codec_resume_amp(codec);
3241         snd_hda_codec_resume_cache(codec);
3242         return 0;
3243 }
3244 #endif
3245
3246 /*
3247  */
3248 static struct hda_codec_ops alc_patch_ops = {
3249         .build_controls = alc_build_controls,
3250         .build_pcms = alc_build_pcms,
3251         .init = alc_init,
3252         .free = alc_free,
3253         .unsol_event = alc_unsol_event,
3254 #ifdef SND_HDA_NEEDS_RESUME
3255         .resume = alc_resume,
3256 #endif
3257 #ifdef CONFIG_SND_HDA_POWER_SAVE
3258         .check_power_status = alc_check_power_status,
3259 #endif
3260 };
3261
3262
3263 /*
3264  * Test configuration for debugging
3265  *
3266  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3267  * enum controls.
3268  */
3269 #ifdef CONFIG_SND_DEBUG
3270 static hda_nid_t alc880_test_dac_nids[4] = {
3271         0x02, 0x03, 0x04, 0x05
3272 };
3273
3274 static struct hda_input_mux alc880_test_capture_source = {
3275         .num_items = 7,
3276         .items = {
3277                 { "In-1", 0x0 },
3278                 { "In-2", 0x1 },
3279                 { "In-3", 0x2 },
3280                 { "In-4", 0x3 },
3281                 { "CD", 0x4 },
3282                 { "Front", 0x5 },
3283                 { "Surround", 0x6 },
3284         },
3285 };
3286
3287 static struct hda_channel_mode alc880_test_modes[4] = {
3288         { 2, NULL },
3289         { 4, NULL },
3290         { 6, NULL },
3291         { 8, NULL },
3292 };
3293
3294 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3295                                  struct snd_ctl_elem_info *uinfo)
3296 {
3297         static char *texts[] = {
3298                 "N/A", "Line Out", "HP Out",
3299                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3300         };
3301         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3302         uinfo->count = 1;
3303         uinfo->value.enumerated.items = 8;
3304         if (uinfo->value.enumerated.item >= 8)
3305                 uinfo->value.enumerated.item = 7;
3306         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3307         return 0;
3308 }
3309
3310 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3311                                 struct snd_ctl_elem_value *ucontrol)
3312 {
3313         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3314         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3315         unsigned int pin_ctl, item = 0;
3316
3317         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3318                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3319         if (pin_ctl & AC_PINCTL_OUT_EN) {
3320                 if (pin_ctl & AC_PINCTL_HP_EN)
3321                         item = 2;
3322                 else
3323                         item = 1;
3324         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3325                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3326                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3327                 case AC_PINCTL_VREF_50:  item = 4; break;
3328                 case AC_PINCTL_VREF_GRD: item = 5; break;
3329                 case AC_PINCTL_VREF_80:  item = 6; break;
3330                 case AC_PINCTL_VREF_100: item = 7; break;
3331                 }
3332         }
3333         ucontrol->value.enumerated.item[0] = item;
3334         return 0;
3335 }
3336
3337 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3338                                 struct snd_ctl_elem_value *ucontrol)
3339 {
3340         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3341         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3342         static unsigned int ctls[] = {
3343                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3344                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3345                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3346                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3347                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3348                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3349         };
3350         unsigned int old_ctl, new_ctl;
3351
3352         old_ctl = snd_hda_codec_read(codec, nid, 0,
3353                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3354         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3355         if (old_ctl != new_ctl) {
3356                 int val;
3357                 snd_hda_codec_write_cache(codec, nid, 0,
3358                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3359                                           new_ctl);
3360                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3361                         HDA_AMP_MUTE : 0;
3362                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3363                                          HDA_AMP_MUTE, val);
3364                 return 1;
3365         }
3366         return 0;
3367 }
3368
3369 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3370                                  struct snd_ctl_elem_info *uinfo)
3371 {
3372         static char *texts[] = {
3373                 "Front", "Surround", "CLFE", "Side"
3374         };
3375         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3376         uinfo->count = 1;
3377         uinfo->value.enumerated.items = 4;
3378         if (uinfo->value.enumerated.item >= 4)
3379                 uinfo->value.enumerated.item = 3;
3380         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3381         return 0;
3382 }
3383
3384 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3385                                 struct snd_ctl_elem_value *ucontrol)
3386 {
3387         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3388         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3389         unsigned int sel;
3390
3391         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3392         ucontrol->value.enumerated.item[0] = sel & 3;
3393         return 0;
3394 }
3395
3396 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3397                                 struct snd_ctl_elem_value *ucontrol)
3398 {
3399         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3400         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3401         unsigned int sel;
3402
3403         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3404         if (ucontrol->value.enumerated.item[0] != sel) {
3405                 sel = ucontrol->value.enumerated.item[0] & 3;
3406                 snd_hda_codec_write_cache(codec, nid, 0,
3407                                           AC_VERB_SET_CONNECT_SEL, sel);
3408                 return 1;
3409         }
3410         return 0;
3411 }
3412
3413 #define PIN_CTL_TEST(xname,nid) {                       \
3414                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3415                         .name = xname,                 \
3416                         .info = alc_test_pin_ctl_info, \
3417                         .get = alc_test_pin_ctl_get,   \
3418                         .put = alc_test_pin_ctl_put,   \
3419                         .private_value = nid           \
3420                         }
3421
3422 #define PIN_SRC_TEST(xname,nid) {                       \
3423                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3424                         .name = xname,                 \
3425                         .info = alc_test_pin_src_info, \
3426                         .get = alc_test_pin_src_get,   \
3427                         .put = alc_test_pin_src_put,   \
3428                         .private_value = nid           \
3429                         }
3430
3431 static struct snd_kcontrol_new alc880_test_mixer[] = {
3432         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3433         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3434         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3435         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3436         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3437         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3438         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3439         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3440         PIN_CTL_TEST("Front Pin Mode", 0x14),
3441         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3442         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3443         PIN_CTL_TEST("Side Pin Mode", 0x17),
3444         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3445         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3446         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3447         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3448         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3449         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3450         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3451         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3452         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3453         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3454         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3455         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3456         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3457         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3458         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3459         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3460         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3461         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3462         {
3463                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3464                 .name = "Channel Mode",
3465                 .info = alc_ch_mode_info,
3466                 .get = alc_ch_mode_get,
3467                 .put = alc_ch_mode_put,
3468         },
3469         { } /* end */
3470 };
3471
3472 static struct hda_verb alc880_test_init_verbs[] = {
3473         /* Unmute inputs of 0x0c - 0x0f */
3474         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3475         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3476         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3478         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3479         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3480         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3481         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3482         /* Vol output for 0x0c-0x0f */
3483         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3484         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3485         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3486         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3487         /* Set output pins 0x14-0x17 */
3488         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3489         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3490         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3491         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3492         /* Unmute output pins 0x14-0x17 */
3493         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3494         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3495         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3496         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3497         /* Set input pins 0x18-0x1c */
3498         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3499         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3500         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3501         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3502         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3503         /* Mute input pins 0x18-0x1b */
3504         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3505         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3506         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3507         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3508         /* ADC set up */
3509         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3510         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3511         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3512         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3513         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3514         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3515         /* Analog input/passthru */
3516         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3517         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3518         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3519         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3520         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3521         { }
3522 };
3523 #endif
3524
3525 /*
3526  */
3527
3528 static const char *alc880_models[ALC880_MODEL_LAST] = {
3529         [ALC880_3ST]            = "3stack",
3530         [ALC880_TCL_S700]       = "tcl",
3531         [ALC880_3ST_DIG]        = "3stack-digout",
3532         [ALC880_CLEVO]          = "clevo",
3533         [ALC880_5ST]            = "5stack",
3534         [ALC880_5ST_DIG]        = "5stack-digout",
3535         [ALC880_W810]           = "w810",
3536         [ALC880_Z71V]           = "z71v",
3537         [ALC880_6ST]            = "6stack",
3538         [ALC880_6ST_DIG]        = "6stack-digout",
3539         [ALC880_ASUS]           = "asus",
3540         [ALC880_ASUS_W1V]       = "asus-w1v",
3541         [ALC880_ASUS_DIG]       = "asus-dig",
3542         [ALC880_ASUS_DIG2]      = "asus-dig2",
3543         [ALC880_UNIWILL_DIG]    = "uniwill",
3544         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3545         [ALC880_FUJITSU]        = "fujitsu",
3546         [ALC880_F1734]          = "F1734",
3547         [ALC880_LG]             = "lg",
3548         [ALC880_LG_LW]          = "lg-lw",
3549         [ALC880_MEDION_RIM]     = "medion",
3550 #ifdef CONFIG_SND_DEBUG
3551         [ALC880_TEST]           = "test",
3552 #endif
3553         [ALC880_AUTO]           = "auto",
3554 };
3555
3556 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3557         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3558         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3559         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3560         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3561         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3562         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3563         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3564         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3565         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3566         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3567         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3568         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3569         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3570         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3571         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3572         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3573         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3574         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3575         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3576         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3577         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3578         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3579         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3580         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3581         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3582         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3583         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3584         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3585         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3586         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3587         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3588         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3589         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3590         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3591         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3592         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3593         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3594         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3595         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3596         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3597         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3598         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3599         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3600         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3601         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3602         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3603         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3604         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3605         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3606         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3607         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3608         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3609         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3610         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3611         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3612         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3613         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3614         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3615         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3616         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3617         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3618         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3619         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3620         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3621         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3622         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3623         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3624         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3625         /* default Intel */
3626         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3627         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3628         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3629         {}
3630 };
3631
3632 /*
3633  * ALC880 codec presets
3634  */
3635 static struct alc_config_preset alc880_presets[] = {
3636         [ALC880_3ST] = {
3637                 .mixers = { alc880_three_stack_mixer },
3638                 .init_verbs = { alc880_volume_init_verbs,
3639                                 alc880_pin_3stack_init_verbs },
3640                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3641                 .dac_nids = alc880_dac_nids,
3642                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3643                 .channel_mode = alc880_threestack_modes,
3644                 .need_dac_fix = 1,
3645                 .input_mux = &alc880_capture_source,
3646         },
3647         [ALC880_3ST_DIG] = {
3648                 .mixers = { alc880_three_stack_mixer },
3649                 .init_verbs = { alc880_volume_init_verbs,
3650                                 alc880_pin_3stack_init_verbs },
3651                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3652                 .dac_nids = alc880_dac_nids,
3653                 .dig_out_nid = ALC880_DIGOUT_NID,
3654                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3655                 .channel_mode = alc880_threestack_modes,
3656                 .need_dac_fix = 1,
3657                 .input_mux = &alc880_capture_source,
3658         },
3659         [ALC880_TCL_S700] = {
3660                 .mixers = { alc880_tcl_s700_mixer },
3661                 .init_verbs = { alc880_volume_init_verbs,
3662                                 alc880_pin_tcl_S700_init_verbs,
3663                                 alc880_gpio2_init_verbs },
3664                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3665                 .dac_nids = alc880_dac_nids,
3666                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3667                 .num_adc_nids = 1, /* single ADC */
3668                 .hp_nid = 0x03,
3669                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3670                 .channel_mode = alc880_2_jack_modes,
3671                 .input_mux = &alc880_capture_source,
3672         },
3673         [ALC880_5ST] = {
3674                 .mixers = { alc880_three_stack_mixer,
3675                             alc880_five_stack_mixer},
3676                 .init_verbs = { alc880_volume_init_verbs,
3677                                 alc880_pin_5stack_init_verbs },
3678                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3679                 .dac_nids = alc880_dac_nids,
3680                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3681                 .channel_mode = alc880_fivestack_modes,
3682                 .input_mux = &alc880_capture_source,
3683         },
3684         [ALC880_5ST_DIG] = {
3685                 .mixers = { alc880_three_stack_mixer,
3686                             alc880_five_stack_mixer },
3687                 .init_verbs = { alc880_volume_init_verbs,
3688                                 alc880_pin_5stack_init_verbs },
3689                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3690                 .dac_nids = alc880_dac_nids,
3691                 .dig_out_nid = ALC880_DIGOUT_NID,
3692                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3693                 .channel_mode = alc880_fivestack_modes,
3694                 .input_mux = &alc880_capture_source,
3695         },
3696         [ALC880_6ST] = {
3697                 .mixers = { alc880_six_stack_mixer },
3698                 .init_verbs = { alc880_volume_init_verbs,
3699                                 alc880_pin_6stack_init_verbs },
3700                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3701                 .dac_nids = alc880_6st_dac_nids,
3702                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3703                 .channel_mode = alc880_sixstack_modes,
3704                 .input_mux = &alc880_6stack_capture_source,
3705         },
3706         [ALC880_6ST_DIG] = {
3707                 .mixers = { alc880_six_stack_mixer },
3708                 .init_verbs = { alc880_volume_init_verbs,
3709                                 alc880_pin_6stack_init_verbs },
3710                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3711                 .dac_nids = alc880_6st_dac_nids,
3712                 .dig_out_nid = ALC880_DIGOUT_NID,
3713                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3714                 .channel_mode = alc880_sixstack_modes,
3715                 .input_mux = &alc880_6stack_capture_source,
3716         },
3717         [ALC880_W810] = {
3718                 .mixers = { alc880_w810_base_mixer },
3719                 .init_verbs = { alc880_volume_init_verbs,
3720                                 alc880_pin_w810_init_verbs,
3721                                 alc880_gpio2_init_verbs },
3722                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3723                 .dac_nids = alc880_w810_dac_nids,
3724                 .dig_out_nid = ALC880_DIGOUT_NID,
3725                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3726                 .channel_mode = alc880_w810_modes,
3727                 .input_mux = &alc880_capture_source,
3728         },
3729         [ALC880_Z71V] = {
3730                 .mixers = { alc880_z71v_mixer },
3731                 .init_verbs = { alc880_volume_init_verbs,
3732                                 alc880_pin_z71v_init_verbs },
3733                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3734                 .dac_nids = alc880_z71v_dac_nids,
3735                 .dig_out_nid = ALC880_DIGOUT_NID,
3736                 .hp_nid = 0x03,
3737                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3738                 .channel_mode = alc880_2_jack_modes,
3739                 .input_mux = &alc880_capture_source,
3740         },
3741         [ALC880_F1734] = {
3742                 .mixers = { alc880_f1734_mixer },
3743                 .init_verbs = { alc880_volume_init_verbs,
3744                                 alc880_pin_f1734_init_verbs },
3745                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3746                 .dac_nids = alc880_f1734_dac_nids,
3747                 .hp_nid = 0x02,
3748                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3749                 .channel_mode = alc880_2_jack_modes,
3750                 .input_mux = &alc880_f1734_capture_source,
3751                 .unsol_event = alc880_uniwill_p53_unsol_event,
3752                 .init_hook = alc880_uniwill_p53_hp_automute,
3753         },
3754         [ALC880_ASUS] = {
3755                 .mixers = { alc880_asus_mixer },
3756                 .init_verbs = { alc880_volume_init_verbs,
3757                                 alc880_pin_asus_init_verbs,
3758                                 alc880_gpio1_init_verbs },
3759                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3760                 .dac_nids = alc880_asus_dac_nids,
3761                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3762                 .channel_mode = alc880_asus_modes,
3763                 .need_dac_fix = 1,
3764                 .input_mux = &alc880_capture_source,
3765         },
3766         [ALC880_ASUS_DIG] = {
3767                 .mixers = { alc880_asus_mixer },
3768                 .init_verbs = { alc880_volume_init_verbs,
3769                                 alc880_pin_asus_init_verbs,
3770                                 alc880_gpio1_init_verbs },
3771                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3772                 .dac_nids = alc880_asus_dac_nids,
3773                 .dig_out_nid = ALC880_DIGOUT_NID,
3774                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3775                 .channel_mode = alc880_asus_modes,
3776                 .need_dac_fix = 1,
3777                 .input_mux = &alc880_capture_source,
3778         },
3779         [ALC880_ASUS_DIG2] = {
3780                 .mixers = { alc880_asus_mixer },
3781                 .init_verbs = { alc880_volume_init_verbs,
3782                                 alc880_pin_asus_init_verbs,
3783                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3784                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3785                 .dac_nids = alc880_asus_dac_nids,
3786                 .dig_out_nid = ALC880_DIGOUT_NID,
3787                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3788                 .channel_mode = alc880_asus_modes,
3789                 .need_dac_fix = 1,
3790                 .input_mux = &alc880_capture_source,
3791         },
3792         [ALC880_ASUS_W1V] = {
3793                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3794                 .init_verbs = { alc880_volume_init_verbs,
3795                                 alc880_pin_asus_init_verbs,
3796                                 alc880_gpio1_init_verbs },
3797                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3798                 .dac_nids = alc880_asus_dac_nids,
3799                 .dig_out_nid = ALC880_DIGOUT_NID,
3800                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3801                 .channel_mode = alc880_asus_modes,
3802                 .need_dac_fix = 1,
3803                 .input_mux = &alc880_capture_source,
3804         },
3805         [ALC880_UNIWILL_DIG] = {
3806                 .mixers = { alc880_asus_mixer },
3807                 .init_verbs = { alc880_volume_init_verbs,
3808                                 alc880_pin_asus_init_verbs },
3809                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3810                 .dac_nids = alc880_asus_dac_nids,
3811                 .dig_out_nid = ALC880_DIGOUT_NID,
3812                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3813                 .channel_mode = alc880_asus_modes,
3814                 .need_dac_fix = 1,
3815                 .input_mux = &alc880_capture_source,
3816         },
3817         [ALC880_UNIWILL] = {
3818                 .mixers = { alc880_uniwill_mixer },
3819                 .init_verbs = { alc880_volume_init_verbs,
3820                                 alc880_uniwill_init_verbs },
3821                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3822                 .dac_nids = alc880_asus_dac_nids,
3823                 .dig_out_nid = ALC880_DIGOUT_NID,
3824                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3825                 .channel_mode = alc880_threestack_modes,
3826                 .need_dac_fix = 1,
3827                 .input_mux = &alc880_capture_source,
3828                 .unsol_event = alc880_uniwill_unsol_event,
3829                 .init_hook = alc880_uniwill_automute,
3830         },
3831         [ALC880_UNIWILL_P53] = {
3832                 .mixers = { alc880_uniwill_p53_mixer },
3833                 .init_verbs = { alc880_volume_init_verbs,
3834                                 alc880_uniwill_p53_init_verbs },
3835                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3836                 .dac_nids = alc880_asus_dac_nids,
3837                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3838                 .channel_mode = alc880_threestack_modes,
3839                 .input_mux = &alc880_capture_source,
3840                 .unsol_event = alc880_uniwill_p53_unsol_event,
3841                 .init_hook = alc880_uniwill_p53_hp_automute,
3842         },
3843         [ALC880_FUJITSU] = {
3844                 .mixers = { alc880_fujitsu_mixer },
3845                 .init_verbs = { alc880_volume_init_verbs,
3846                                 alc880_uniwill_p53_init_verbs,
3847                                 alc880_beep_init_verbs },
3848                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3849                 .dac_nids = alc880_dac_nids,
3850                 .dig_out_nid = ALC880_DIGOUT_NID,
3851                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3852                 .channel_mode = alc880_2_jack_modes,
3853                 .input_mux = &alc880_capture_source,
3854                 .unsol_event = alc880_uniwill_p53_unsol_event,
3855                 .init_hook = alc880_uniwill_p53_hp_automute,
3856         },
3857         [ALC880_CLEVO] = {
3858                 .mixers = { alc880_three_stack_mixer },
3859                 .init_verbs = { alc880_volume_init_verbs,
3860                                 alc880_pin_clevo_init_verbs },
3861                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3862                 .dac_nids = alc880_dac_nids,
3863                 .hp_nid = 0x03,
3864                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3865                 .channel_mode = alc880_threestack_modes,
3866                 .need_dac_fix = 1,
3867                 .input_mux = &alc880_capture_source,
3868         },
3869         [ALC880_LG] = {
3870                 .mixers = { alc880_lg_mixer },
3871                 .init_verbs = { alc880_volume_init_verbs,
3872                                 alc880_lg_init_verbs },
3873                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3874                 .dac_nids = alc880_lg_dac_nids,
3875                 .dig_out_nid = ALC880_DIGOUT_NID,
3876                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3877                 .channel_mode = alc880_lg_ch_modes,
3878                 .need_dac_fix = 1,
3879                 .input_mux = &alc880_lg_capture_source,
3880                 .unsol_event = alc880_lg_unsol_event,
3881                 .init_hook = alc880_lg_automute,
3882 #ifdef CONFIG_SND_HDA_POWER_SAVE
3883                 .loopbacks = alc880_lg_loopbacks,
3884 #endif
3885         },
3886         [ALC880_LG_LW] = {
3887                 .mixers = { alc880_lg_lw_mixer },
3888                 .init_verbs = { alc880_volume_init_verbs,
3889                                 alc880_lg_lw_init_verbs },
3890                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3891                 .dac_nids = alc880_dac_nids,
3892                 .dig_out_nid = ALC880_DIGOUT_NID,
3893                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3894                 .channel_mode = alc880_lg_lw_modes,
3895                 .input_mux = &alc880_lg_lw_capture_source,
3896                 .unsol_event = alc880_lg_lw_unsol_event,
3897                 .init_hook = alc880_lg_lw_automute,
3898         },
3899         [ALC880_MEDION_RIM] = {
3900                 .mixers = { alc880_medion_rim_mixer },
3901                 .init_verbs = { alc880_volume_init_verbs,
3902                                 alc880_medion_rim_init_verbs,
3903                                 alc_gpio2_init_verbs },
3904                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3905                 .dac_nids = alc880_dac_nids,
3906                 .dig_out_nid = ALC880_DIGOUT_NID,
3907                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3908                 .channel_mode = alc880_2_jack_modes,
3909                 .input_mux = &alc880_medion_rim_capture_source,
3910                 .unsol_event = alc880_medion_rim_unsol_event,
3911                 .init_hook = alc880_medion_rim_automute,
3912         },
3913 #ifdef CONFIG_SND_DEBUG
3914         [ALC880_TEST] = {
3915                 .mixers = { alc880_test_mixer },
3916                 .init_verbs = { alc880_test_init_verbs },
3917                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3918                 .dac_nids = alc880_test_dac_nids,
3919                 .dig_out_nid = ALC880_DIGOUT_NID,
3920                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3921                 .channel_mode = alc880_test_modes,
3922                 .input_mux = &alc880_test_capture_source,
3923         },
3924 #endif
3925 };
3926
3927 /*
3928  * Automatic parse of I/O pins from the BIOS configuration
3929  */
3930
3931 enum {
3932         ALC_CTL_WIDGET_VOL,
3933         ALC_CTL_WIDGET_MUTE,
3934         ALC_CTL_BIND_MUTE,
3935 };
3936 static struct snd_kcontrol_new alc880_control_templates[] = {
3937         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3938         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3939         HDA_BIND_MUTE(NULL, 0, 0, 0),
3940 };
3941
3942 /* add dynamic controls */
3943 static int add_control(struct alc_spec *spec, int type, const char *name,
3944                        unsigned long val)
3945 {
3946         struct snd_kcontrol_new *knew;
3947
3948         snd_array_init(&spec->kctls, sizeof(*knew), 32);
3949         knew = snd_array_new(&spec->kctls);
3950         if (!knew)
3951                 return -ENOMEM;
3952         *knew = alc880_control_templates[type];
3953         knew->name = kstrdup(name, GFP_KERNEL);
3954         if (!knew->name)
3955                 return -ENOMEM;
3956         knew->private_value = val;
3957         return 0;
3958 }
3959
3960 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3961 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3962 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3963 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3964 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3965 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3966 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3967 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3968 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3969 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3970 #define ALC880_PIN_CD_NID               0x1c
3971
3972 /* fill in the dac_nids table from the parsed pin configuration */
3973 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3974                                      const struct auto_pin_cfg *cfg)
3975 {
3976         hda_nid_t nid;
3977         int assigned[4];
3978         int i, j;
3979
3980         memset(assigned, 0, sizeof(assigned));
3981         spec->multiout.dac_nids = spec->private_dac_nids;
3982
3983         /* check the pins hardwired to audio widget */
3984         for (i = 0; i < cfg->line_outs; i++) {
3985                 nid = cfg->line_out_pins[i];
3986                 if (alc880_is_fixed_pin(nid)) {
3987                         int idx = alc880_fixed_pin_idx(nid);
3988                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3989                         assigned[idx] = 1;
3990                 }
3991         }
3992         /* left pins can be connect to any audio widget */
3993         for (i = 0; i < cfg->line_outs; i++) {
3994                 nid = cfg->line_out_pins[i];
3995                 if (alc880_is_fixed_pin(nid))
3996                         continue;
3997                 /* search for an empty channel */
3998                 for (j = 0; j < cfg->line_outs; j++) {
3999                         if (!assigned[j]) {
4000                                 spec->multiout.dac_nids[i] =
4001                                         alc880_idx_to_dac(j);
4002                                 assigned[j] = 1;
4003                                 break;
4004                         }
4005                 }
4006         }
4007         spec->multiout.num_dacs = cfg->line_outs;
4008         return 0;
4009 }
4010
4011 /* add playback controls from the parsed DAC table */
4012 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4013                                              const struct auto_pin_cfg *cfg)
4014 {
4015         char name[32];
4016         static const char *chname[4] = {
4017                 "Front", "Surround", NULL /*CLFE*/, "Side"
4018         };
4019         hda_nid_t nid;
4020         int i, err;
4021
4022         for (i = 0; i < cfg->line_outs; i++) {
4023                 if (!spec->multiout.dac_nids[i])
4024                         continue;
4025                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4026                 if (i == 2) {
4027                         /* Center/LFE */
4028                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4029                                           "Center Playback Volume",
4030                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4031                                                               HDA_OUTPUT));
4032                         if (err < 0)
4033                                 return err;
4034                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4035                                           "LFE Playback Volume",
4036                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4037                                                               HDA_OUTPUT));
4038                         if (err < 0)
4039                                 return err;
4040                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4041                                           "Center Playback Switch",
4042                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4043                                                               HDA_INPUT));
4044                         if (err < 0)
4045                                 return err;
4046                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4047                                           "LFE Playback Switch",
4048                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4049                                                               HDA_INPUT));
4050                         if (err < 0)
4051                                 return err;
4052                 } else {
4053                         sprintf(name, "%s Playback Volume", chname[i]);
4054                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4055                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4056                                                               HDA_OUTPUT));
4057                         if (err < 0)
4058                                 return err;
4059                         sprintf(name, "%s Playback Switch", chname[i]);
4060                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4061                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4062                                                               HDA_INPUT));
4063                         if (err < 0)
4064                                 return err;
4065                 }
4066         }
4067         return 0;
4068 }
4069
4070 /* add playback controls for speaker and HP outputs */
4071 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4072                                         const char *pfx)
4073 {
4074         hda_nid_t nid;
4075         int err;
4076         char name[32];
4077
4078         if (!pin)
4079                 return 0;
4080
4081         if (alc880_is_fixed_pin(pin)) {
4082                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4083                 /* specify the DAC as the extra output */
4084                 if (!spec->multiout.hp_nid)
4085                         spec->multiout.hp_nid = nid;
4086                 else
4087                         spec->multiout.extra_out_nid[0] = nid;
4088                 /* control HP volume/switch on the output mixer amp */
4089                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4090                 sprintf(name, "%s Playback Volume", pfx);
4091                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4092                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4093                 if (err < 0)
4094                         return err;
4095                 sprintf(name, "%s Playback Switch", pfx);
4096                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4097                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4098                 if (err < 0)
4099                         return err;
4100         } else if (alc880_is_multi_pin(pin)) {
4101                 /* set manual connection */
4102                 /* we have only a switch on HP-out PIN */
4103                 sprintf(name, "%s Playback Switch", pfx);
4104                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4105                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4106                 if (err < 0)
4107                         return err;
4108         }
4109         return 0;
4110 }
4111
4112 /* create input playback/capture controls for the given pin */
4113 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4114                             const char *ctlname,
4115                             int idx, hda_nid_t mix_nid)
4116 {
4117         char name[32];
4118         int err;
4119
4120         sprintf(name, "%s Playback Volume", ctlname);
4121         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4122                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4123         if (err < 0)
4124                 return err;
4125         sprintf(name, "%s Playback Switch", ctlname);
4126         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4127                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4128         if (err < 0)
4129                 return err;
4130         return 0;
4131 }
4132
4133 /* create playback/capture controls for input pins */
4134 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4135                                                 const struct auto_pin_cfg *cfg)
4136 {
4137         struct hda_input_mux *imux = &spec->private_imux[0];
4138         int i, err, idx;
4139
4140         for (i = 0; i < AUTO_PIN_LAST; i++) {
4141                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4142                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4143                         err = new_analog_input(spec, cfg->input_pins[i],
4144                                                auto_pin_cfg_labels[i],
4145                                                idx, 0x0b);
4146                         if (err < 0)
4147                                 return err;
4148                         imux->items[imux->num_items].label =
4149                                 auto_pin_cfg_labels[i];
4150                         imux->items[imux->num_items].index =
4151                                 alc880_input_pin_idx(cfg->input_pins[i]);
4152                         imux->num_items++;
4153                 }
4154         }
4155         return 0;
4156 }
4157
4158 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4159                                unsigned int pin_type)
4160 {
4161         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4162                             pin_type);
4163         /* unmute pin */
4164         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4165                             AMP_OUT_UNMUTE);
4166 }
4167
4168 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4169                                               hda_nid_t nid, int pin_type,
4170                                               int dac_idx)
4171 {
4172         alc_set_pin_output(codec, nid, pin_type);
4173         /* need the manual connection? */
4174         if (alc880_is_multi_pin(nid)) {
4175                 struct alc_spec *spec = codec->spec;
4176                 int idx = alc880_multi_pin_idx(nid);
4177                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4178                                     AC_VERB_SET_CONNECT_SEL,
4179                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4180         }
4181 }
4182
4183 static int get_pin_type(int line_out_type)
4184 {
4185         if (line_out_type == AUTO_PIN_HP_OUT)
4186                 return PIN_HP;
4187         else
4188                 return PIN_OUT;
4189 }
4190
4191 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4192 {
4193         struct alc_spec *spec = codec->spec;
4194         int i;
4195
4196         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4197         for (i = 0; i < spec->autocfg.line_outs; i++) {
4198                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4199                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4200                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4201         }
4202 }
4203
4204 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4205 {
4206         struct alc_spec *spec = codec->spec;
4207         hda_nid_t pin;
4208
4209         pin = spec->autocfg.speaker_pins[0];
4210         if (pin) /* connect to front */
4211                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4212         pin = spec->autocfg.hp_pins[0];
4213         if (pin) /* connect to front */
4214                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4215 }
4216
4217 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4218 {
4219         struct alc_spec *spec = codec->spec;
4220         int i;
4221
4222         for (i = 0; i < AUTO_PIN_LAST; i++) {
4223                 hda_nid_t nid = spec->autocfg.input_pins[i];
4224                 if (alc880_is_input_pin(nid)) {
4225                         alc_set_input_pin(codec, nid, i);
4226                         if (nid != ALC880_PIN_CD_NID &&
4227                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4228                                 snd_hda_codec_write(codec, nid, 0,
4229                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4230                                                     AMP_OUT_MUTE);
4231                 }
4232         }
4233 }
4234
4235 /* parse the BIOS configuration and set up the alc_spec */
4236 /* return 1 if successful, 0 if the proper config is not found,
4237  * or a negative error code
4238  */
4239 static int alc880_parse_auto_config(struct hda_codec *codec)
4240 {
4241         struct alc_spec *spec = codec->spec;
4242         int i, err;
4243         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4244
4245         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4246                                            alc880_ignore);
4247         if (err < 0)
4248                 return err;
4249         if (!spec->autocfg.line_outs)
4250                 return 0; /* can't find valid BIOS pin config */
4251
4252         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4253         if (err < 0)
4254                 return err;
4255         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4256         if (err < 0)
4257                 return err;
4258         err = alc880_auto_create_extra_out(spec,
4259                                            spec->autocfg.speaker_pins[0],
4260                                            "Speaker");
4261         if (err < 0)
4262                 return err;
4263         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4264                                            "Headphone");
4265         if (err < 0)
4266                 return err;
4267         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4268         if (err < 0)
4269                 return err;
4270
4271         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4272
4273         /* check multiple SPDIF-out (for recent codecs) */
4274         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4275                 hda_nid_t dig_nid;
4276                 err = snd_hda_get_connections(codec,
4277                                               spec->autocfg.dig_out_pins[i],
4278                                               &dig_nid, 1);
4279                 if (err < 0)
4280                         continue;
4281                 if (!i)
4282                         spec->multiout.dig_out_nid = dig_nid;
4283                 else {
4284                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4285                         spec->slave_dig_outs[i - 1] = dig_nid;
4286                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4287                                 break;
4288                 }
4289         }
4290         if (spec->autocfg.dig_in_pin)
4291                 spec->dig_in_nid = ALC880_DIGIN_NID;
4292
4293         if (spec->kctls.list)
4294                 add_mixer(spec, spec->kctls.list);
4295
4296         add_verb(spec, alc880_volume_init_verbs);
4297
4298         spec->num_mux_defs = 1;
4299         spec->input_mux = &spec->private_imux[0];
4300
4301         return 1;
4302 }
4303
4304 /* additional initialization for auto-configuration model */
4305 static void alc880_auto_init(struct hda_codec *codec)
4306 {
4307         struct alc_spec *spec = codec->spec;
4308         alc880_auto_init_multi_out(codec);
4309         alc880_auto_init_extra_out(codec);
4310         alc880_auto_init_analog_input(codec);
4311         if (spec->unsol_event)
4312                 alc_inithook(codec);
4313 }
4314
4315 static void set_capture_mixer(struct alc_spec *spec)
4316 {
4317         static struct snd_kcontrol_new *caps[2][3] = {
4318                 { alc_capture_mixer_nosrc1,
4319                   alc_capture_mixer_nosrc2,
4320                   alc_capture_mixer_nosrc3 },
4321                 { alc_capture_mixer1,
4322                   alc_capture_mixer2,
4323                   alc_capture_mixer3 },
4324         };
4325         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4326                 int mux;
4327                 if (spec->input_mux && spec->input_mux->num_items > 1)
4328                         mux = 1;
4329                 else
4330                         mux = 0;
4331                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4332         }
4333 }
4334
4335 #define set_beep_amp(spec, nid, idx, dir) \
4336         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4337
4338 /*
4339  * OK, here we have finally the patch for ALC880
4340  */
4341
4342 static int patch_alc880(struct hda_codec *codec)
4343 {
4344         struct alc_spec *spec;
4345         int board_config;
4346         int err;
4347
4348         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4349         if (spec == NULL)
4350                 return -ENOMEM;
4351
4352         codec->spec = spec;
4353
4354         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4355                                                   alc880_models,
4356                                                   alc880_cfg_tbl);
4357         if (board_config < 0) {
4358                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4359                        "trying auto-probe from BIOS...\n");
4360                 board_config = ALC880_AUTO;
4361         }
4362
4363         if (board_config == ALC880_AUTO) {
4364                 /* automatic parse from the BIOS config */
4365                 err = alc880_parse_auto_config(codec);
4366                 if (err < 0) {
4367                         alc_free(codec);
4368                         return err;
4369                 } else if (!err) {
4370                         printk(KERN_INFO
4371                                "hda_codec: Cannot set up configuration "
4372                                "from BIOS.  Using 3-stack mode...\n");
4373                         board_config = ALC880_3ST;
4374                 }
4375         }
4376
4377         err = snd_hda_attach_beep_device(codec, 0x1);
4378         if (err < 0) {
4379                 alc_free(codec);
4380                 return err;
4381         }
4382
4383         if (board_config != ALC880_AUTO)
4384                 setup_preset(spec, &alc880_presets[board_config]);
4385
4386         spec->stream_name_analog = "ALC880 Analog";
4387         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4388         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4389         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4390
4391         spec->stream_name_digital = "ALC880 Digital";
4392         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4393         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4394
4395         if (!spec->adc_nids && spec->input_mux) {
4396                 /* check whether NID 0x07 is valid */
4397                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4398                 /* get type */
4399                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4400                 if (wcap != AC_WID_AUD_IN) {
4401                         spec->adc_nids = alc880_adc_nids_alt;
4402                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4403                 } else {
4404                         spec->adc_nids = alc880_adc_nids;
4405                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4406                 }
4407         }
4408         set_capture_mixer(spec);
4409         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4410
4411         spec->vmaster_nid = 0x0c;
4412
4413         codec->patch_ops = alc_patch_ops;
4414         if (board_config == ALC880_AUTO)
4415                 spec->init_hook = alc880_auto_init;
4416 #ifdef CONFIG_SND_HDA_POWER_SAVE
4417         if (!spec->loopback.amplist)
4418                 spec->loopback.amplist = alc880_loopbacks;
4419 #endif
4420         codec->proc_widget_hook = print_realtek_coef;
4421
4422         return 0;
4423 }
4424
4425
4426 /*
4427  * ALC260 support
4428  */
4429
4430 static hda_nid_t alc260_dac_nids[1] = {
4431         /* front */
4432         0x02,
4433 };
4434
4435 static hda_nid_t alc260_adc_nids[1] = {
4436         /* ADC0 */
4437         0x04,
4438 };
4439
4440 static hda_nid_t alc260_adc_nids_alt[1] = {
4441         /* ADC1 */
4442         0x05,
4443 };
4444
4445 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4446  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4447  */
4448 static hda_nid_t alc260_dual_adc_nids[2] = {
4449         /* ADC0, ADC1 */
4450         0x04, 0x05
4451 };
4452
4453 #define ALC260_DIGOUT_NID       0x03
4454 #define ALC260_DIGIN_NID        0x06
4455
4456 static struct hda_input_mux alc260_capture_source = {
4457         .num_items = 4,
4458         .items = {
4459                 { "Mic", 0x0 },
4460                 { "Front Mic", 0x1 },
4461                 { "Line", 0x2 },
4462                 { "CD", 0x4 },
4463         },
4464 };
4465
4466 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4467  * headphone jack and the internal CD lines since these are the only pins at
4468  * which audio can appear.  For flexibility, also allow the option of
4469  * recording the mixer output on the second ADC (ADC0 doesn't have a
4470  * connection to the mixer output).
4471  */
4472 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4473         {
4474                 .num_items = 3,
4475                 .items = {
4476                         { "Mic/Line", 0x0 },
4477                         { "CD", 0x4 },
4478                         { "Headphone", 0x2 },
4479                 },
4480         },
4481         {
4482                 .num_items = 4,
4483                 .items = {
4484                         { "Mic/Line", 0x0 },
4485                         { "CD", 0x4 },
4486                         { "Headphone", 0x2 },
4487                         { "Mixer", 0x5 },
4488                 },
4489         },
4490
4491 };
4492
4493 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4494  * the Fujitsu S702x, but jacks are marked differently.
4495  */
4496 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4497         {
4498                 .num_items = 4,
4499                 .items = {
4500                         { "Mic", 0x0 },
4501                         { "Line", 0x2 },
4502                         { "CD", 0x4 },
4503                         { "Headphone", 0x5 },
4504                 },
4505         },
4506         {
4507                 .num_items = 5,
4508                 .items = {
4509                         { "Mic", 0x0 },
4510                         { "Line", 0x2 },
4511                         { "CD", 0x4 },
4512                         { "Headphone", 0x6 },
4513                         { "Mixer", 0x5 },
4514                 },
4515         },
4516 };
4517
4518 /* Maxdata Favorit 100XS */
4519 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4520         {
4521                 .num_items = 2,
4522                 .items = {
4523                         { "Line/Mic", 0x0 },
4524                         { "CD", 0x4 },
4525                 },
4526         },
4527         {
4528                 .num_items = 3,
4529                 .items = {
4530                         { "Line/Mic", 0x0 },
4531                         { "CD", 0x4 },
4532                         { "Mixer", 0x5 },
4533                 },
4534         },
4535 };
4536
4537 /*
4538  * This is just place-holder, so there's something for alc_build_pcms to look
4539  * at when it calculates the maximum number of channels. ALC260 has no mixer
4540  * element which allows changing the channel mode, so the verb list is
4541  * never used.
4542  */
4543 static struct hda_channel_mode alc260_modes[1] = {
4544         { 2, NULL },
4545 };
4546
4547
4548 /* Mixer combinations
4549  *
4550  * basic: base_output + input + pc_beep + capture
4551  * HP: base_output + input + capture_alt
4552  * HP_3013: hp_3013 + input + capture
4553  * fujitsu: fujitsu + capture
4554  * acer: acer + capture
4555  */
4556
4557 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4558         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4559         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4560         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4561         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4562         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4563         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4564         { } /* end */
4565 };
4566
4567 static struct snd_kcontrol_new alc260_input_mixer[] = {
4568         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4569         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4570         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4571         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4572         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4573         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4574         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4575         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4576         { } /* end */
4577 };
4578
4579 /* update HP, line and mono out pins according to the master switch */
4580 static void alc260_hp_master_update(struct hda_codec *codec,
4581                                     hda_nid_t hp, hda_nid_t line,
4582                                     hda_nid_t mono)
4583 {
4584         struct alc_spec *spec = codec->spec;
4585         unsigned int val = spec->master_sw ? PIN_HP : 0;
4586         /* change HP and line-out pins */
4587         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4588                             val);
4589         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4590                             val);
4591         /* mono (speaker) depending on the HP jack sense */
4592         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4593         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4594                             val);
4595 }
4596
4597 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4598                                    struct snd_ctl_elem_value *ucontrol)
4599 {
4600         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4601         struct alc_spec *spec = codec->spec;
4602         *ucontrol->value.integer.value = spec->master_sw;
4603         return 0;
4604 }
4605
4606 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4607                                    struct snd_ctl_elem_value *ucontrol)
4608 {
4609         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4610         struct alc_spec *spec = codec->spec;
4611         int val = !!*ucontrol->value.integer.value;
4612         hda_nid_t hp, line, mono;
4613
4614         if (val == spec->master_sw)
4615                 return 0;
4616         spec->master_sw = val;
4617         hp = (kcontrol->private_value >> 16) & 0xff;
4618         line = (kcontrol->private_value >> 8) & 0xff;
4619         mono = kcontrol->private_value & 0xff;
4620         alc260_hp_master_update(codec, hp, line, mono);
4621         return 1;
4622 }
4623
4624 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4625         {
4626                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4627                 .name = "Master Playback Switch",
4628                 .info = snd_ctl_boolean_mono_info,
4629                 .get = alc260_hp_master_sw_get,
4630                 .put = alc260_hp_master_sw_put,
4631                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4632         },
4633         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4634         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4635         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4636         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4637         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4638                               HDA_OUTPUT),
4639         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4640         { } /* end */
4641 };
4642
4643 static struct hda_verb alc260_hp_unsol_verbs[] = {
4644         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4645         {},
4646 };
4647
4648 static void alc260_hp_automute(struct hda_codec *codec)
4649 {
4650         struct alc_spec *spec = codec->spec;
4651         unsigned int present;
4652
4653         present = snd_hda_codec_read(codec, 0x10, 0,
4654                                      AC_VERB_GET_PIN_SENSE, 0);
4655         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4656         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4657 }
4658
4659 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4660 {
4661         if ((res >> 26) == ALC880_HP_EVENT)
4662                 alc260_hp_automute(codec);
4663 }
4664
4665 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4666         {
4667                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4668                 .name = "Master Playback Switch",
4669                 .info = snd_ctl_boolean_mono_info,
4670                 .get = alc260_hp_master_sw_get,
4671                 .put = alc260_hp_master_sw_put,
4672                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4673         },
4674         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4675         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4676         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4677         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4678         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4679         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4680         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4681         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4682         { } /* end */
4683 };
4684
4685 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4686         .ops = &snd_hda_bind_vol,
4687         .values = {
4688                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4689                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4690                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4691                 0
4692         },
4693 };
4694
4695 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4696         .ops = &snd_hda_bind_sw,
4697         .values = {
4698                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4699                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4700                 0
4701         },
4702 };
4703
4704 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4705         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4706         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4707         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4708         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4709         { } /* end */
4710 };
4711
4712 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4713         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4714         {},
4715 };
4716
4717 static void alc260_hp_3013_automute(struct hda_codec *codec)
4718 {
4719         struct alc_spec *spec = codec->spec;
4720         unsigned int present;
4721
4722         present = snd_hda_codec_read(codec, 0x15, 0,
4723                                      AC_VERB_GET_PIN_SENSE, 0);
4724         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4725         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4726 }
4727
4728 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4729                                        unsigned int res)
4730 {
4731         if ((res >> 26) == ALC880_HP_EVENT)
4732                 alc260_hp_3013_automute(codec);
4733 }
4734
4735 static void alc260_hp_3012_automute(struct hda_codec *codec)
4736 {
4737         unsigned int present, bits;
4738
4739         present = snd_hda_codec_read(codec, 0x10, 0,
4740                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4741
4742         bits = present ? 0 : PIN_OUT;
4743         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4744                             bits);
4745         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4746                             bits);
4747         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4748                             bits);
4749 }
4750
4751 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4752                                        unsigned int res)
4753 {
4754         if ((res >> 26) == ALC880_HP_EVENT)
4755                 alc260_hp_3012_automute(codec);
4756 }
4757
4758 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4759  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4760  */
4761 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4762         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4763         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4764         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4765         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4766         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4767         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4768         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4769         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4770         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4771         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4772         { } /* end */
4773 };
4774
4775 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4776  * versions of the ALC260 don't act on requests to enable mic bias from NID
4777  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4778  * datasheet doesn't mention this restriction.  At this stage it's not clear
4779  * whether this behaviour is intentional or is a hardware bug in chip
4780  * revisions available in early 2006.  Therefore for now allow the
4781  * "Headphone Jack Mode" control to span all choices, but if it turns out
4782  * that the lack of mic bias for this NID is intentional we could change the
4783  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4784  *
4785  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4786  * don't appear to make the mic bias available from the "line" jack, even
4787  * though the NID used for this jack (0x14) can supply it.  The theory is
4788  * that perhaps Acer have included blocking capacitors between the ALC260
4789  * and the output jack.  If this turns out to be the case for all such
4790  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4791  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4792  *
4793  * The C20x Tablet series have a mono internal speaker which is controlled
4794  * via the chip's Mono sum widget and pin complex, so include the necessary
4795  * controls for such models.  On models without a "mono speaker" the control
4796  * won't do anything.
4797  */
4798 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4799         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4800         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4801         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4802         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4803                               HDA_OUTPUT),
4804         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4805                            HDA_INPUT),
4806         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4807         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4808         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4809         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4810         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4811         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4812         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4813         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4814         { } /* end */
4815 };
4816
4817 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4818  */
4819 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4820         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4821         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4822         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4823         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4824         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4825         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4826         { } /* end */
4827 };
4828
4829 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4830  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4831  */
4832 static struct snd_kcontrol_new alc260_will_mixer[] = {
4833         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4834         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4835         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4836         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4837         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4838         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4839         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4840         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4841         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4842         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4843         { } /* end */
4844 };
4845
4846 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4847  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4848  */
4849 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4850         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4851         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4852         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4853         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4854         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4855         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4856         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4857         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4858         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4859         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4860         { } /* end */
4861 };
4862
4863 /*
4864  * initialization verbs
4865  */
4866 static struct hda_verb alc260_init_verbs[] = {
4867         /* Line In pin widget for input */
4868         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4869         /* CD pin widget for input */
4870         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4871         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4872         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4873         /* Mic2 (front panel) pin widget for input and vref at 80% */
4874         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4875         /* LINE-2 is used for line-out in rear */
4876         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4877         /* select line-out */
4878         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4879         /* LINE-OUT pin */
4880         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4881         /* enable HP */
4882         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4883         /* enable Mono */
4884         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4885         /* mute capture amp left and right */
4886         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4887         /* set connection select to line in (default select for this ADC) */
4888         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4889         /* mute capture amp left and right */
4890         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4891         /* set connection select to line in (default select for this ADC) */
4892         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4893         /* set vol=0 Line-Out mixer amp left and right */
4894         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4895         /* unmute pin widget amp left and right (no gain on this amp) */
4896         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4897         /* set vol=0 HP mixer amp left and right */
4898         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4899         /* unmute pin widget amp left and right (no gain on this amp) */
4900         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4901         /* set vol=0 Mono mixer amp left and right */
4902         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4903         /* unmute pin widget amp left and right (no gain on this amp) */
4904         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4905         /* unmute LINE-2 out pin */
4906         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4907         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4908          * Line In 2 = 0x03
4909          */
4910         /* mute analog inputs */
4911         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4912         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4913         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4914         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4915         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4916         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4917         /* mute Front out path */
4918         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4919         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4920         /* mute Headphone out path */
4921         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4922         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4923         /* mute Mono out path */
4924         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4925         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4926         { }
4927 };
4928
4929 #if 0 /* should be identical with alc260_init_verbs? */
4930 static struct hda_verb alc260_hp_init_verbs[] = {
4931         /* Headphone and output */
4932         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4933         /* mono output */
4934         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4935         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4936         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4937         /* Mic2 (front panel) pin widget for input and vref at 80% */
4938         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4939         /* Line In pin widget for input */
4940         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4941         /* Line-2 pin widget for output */
4942         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4943         /* CD pin widget for input */
4944         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4945         /* unmute amp left and right */
4946         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4947         /* set connection select to line in (default select for this ADC) */
4948         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4949         /* unmute Line-Out mixer amp left and right (volume = 0) */
4950         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4951         /* mute pin widget amp left and right (no gain on this amp) */
4952         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4953         /* unmute HP mixer amp left and right (volume = 0) */
4954         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4955         /* mute pin widget amp left and right (no gain on this amp) */
4956         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4957         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4958          * Line In 2 = 0x03
4959          */
4960         /* mute analog inputs */
4961         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4962         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4963         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4964         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4965         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4966         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4967         /* Unmute Front out path */
4968         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4969         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4970         /* Unmute Headphone out path */
4971         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4972         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4973         /* Unmute Mono out path */
4974         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4975         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4976         { }
4977 };
4978 #endif
4979
4980 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4981         /* Line out and output */
4982         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4983         /* mono output */
4984         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4985         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4986         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4987         /* Mic2 (front panel) pin widget for input and vref at 80% */
4988         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4989         /* Line In pin widget for input */
4990         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4991         /* Headphone pin widget for output */
4992         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4993         /* CD pin widget for input */
4994         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4995         /* unmute amp left and right */
4996         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4997         /* set connection select to line in (default select for this ADC) */
4998         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4999         /* unmute Line-Out mixer amp left and right (volume = 0) */
5000         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5001         /* mute pin widget amp left and right (no gain on this amp) */
5002         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5003         /* unmute HP mixer amp left and right (volume = 0) */
5004         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5005         /* mute pin widget amp left and right (no gain on this amp) */
5006         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5007         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5008          * Line In 2 = 0x03
5009          */
5010         /* mute analog inputs */
5011         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5012         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5013         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5014         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5015         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5016         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5017         /* Unmute Front out path */
5018         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5019         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5020         /* Unmute Headphone out path */
5021         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5022         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5023         /* Unmute Mono out path */
5024         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5025         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5026         { }
5027 };
5028
5029 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5030  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5031  * audio = 0x16, internal speaker = 0x10.
5032  */
5033 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5034         /* Disable all GPIOs */
5035         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5036         /* Internal speaker is connected to headphone pin */
5037         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5038         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5039         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5040         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5041         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5042         /* Ensure all other unused pins are disabled and muted. */
5043         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5044         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5045         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5046         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5047         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5048         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5049         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5050         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5051
5052         /* Disable digital (SPDIF) pins */
5053         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5054         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5055
5056         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5057          * when acting as an output.
5058          */
5059         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5060
5061         /* Start with output sum widgets muted and their output gains at min */
5062         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5063         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5064         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5065         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5066         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5067         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5068         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5069         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5070         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5071
5072         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5073         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5074         /* Unmute Line1 pin widget output buffer since it starts as an output.
5075          * If the pin mode is changed by the user the pin mode control will
5076          * take care of enabling the pin's input/output buffers as needed.
5077          * Therefore there's no need to enable the input buffer at this
5078          * stage.
5079          */
5080         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5081         /* Unmute input buffer of pin widget used for Line-in (no equiv
5082          * mixer ctrl)
5083          */
5084         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5085
5086         /* Mute capture amp left and right */
5087         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5088         /* Set ADC connection select to match default mixer setting - line
5089          * in (on mic1 pin)
5090          */
5091         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5092
5093         /* Do the same for the second ADC: mute capture input amp and
5094          * set ADC connection to line in (on mic1 pin)
5095          */
5096         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5097         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5098
5099         /* Mute all inputs to mixer widget (even unconnected ones) */
5100         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5101         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5102         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5103         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5104         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5105         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5106         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5107         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5108
5109         { }
5110 };
5111
5112 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5113  * similar laptops (adapted from Fujitsu init verbs).
5114  */
5115 static struct hda_verb alc260_acer_init_verbs[] = {
5116         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5117          * the headphone jack.  Turn this on and rely on the standard mute
5118          * methods whenever the user wants to turn these outputs off.
5119          */
5120         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5121         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5122         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5123         /* Internal speaker/Headphone jack is connected to Line-out pin */
5124         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5125         /* Internal microphone/Mic jack is connected to Mic1 pin */
5126         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5127         /* Line In jack is connected to Line1 pin */
5128         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5129         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5130         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5131         /* Ensure all other unused pins are disabled and muted. */
5132         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5133         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5134         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5135         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5136         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5137         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5138         /* Disable digital (SPDIF) pins */
5139         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5140         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5141
5142         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5143          * bus when acting as outputs.
5144          */
5145         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5146         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5147
5148         /* Start with output sum widgets muted and their output gains at min */
5149         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5150         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5151         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5152         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5153         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5154         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5155         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5156         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5157         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5158
5159         /* Unmute Line-out pin widget amp left and right
5160          * (no equiv mixer ctrl)
5161          */
5162         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5163         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5164         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5165         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5166          * inputs. If the pin mode is changed by the user the pin mode control
5167          * will take care of enabling the pin's input/output buffers as needed.
5168          * Therefore there's no need to enable the input buffer at this
5169          * stage.
5170          */
5171         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5172         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5173
5174         /* Mute capture amp left and right */
5175         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5176         /* Set ADC connection select to match default mixer setting - mic
5177          * (on mic1 pin)
5178          */
5179         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5180
5181         /* Do similar with the second ADC: mute capture input amp and
5182          * set ADC connection to mic to match ALSA's default state.
5183          */
5184         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5185         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5186
5187         /* Mute all inputs to mixer widget (even unconnected ones) */
5188         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5189         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5190         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5191         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5192         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5193         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5194         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5195         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5196
5197         { }
5198 };
5199
5200 /* Initialisation sequence for Maxdata Favorit 100XS
5201  * (adapted from Acer init verbs).
5202  */
5203 static struct hda_verb alc260_favorit100_init_verbs[] = {
5204         /* GPIO 0 enables the output jack.
5205          * Turn this on and rely on the standard mute
5206          * methods whenever the user wants to turn these outputs off.
5207          */
5208         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5209         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5210         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5211         /* Line/Mic input jack is connected to Mic1 pin */
5212         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5213         /* Ensure all other unused pins are disabled and muted. */
5214         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5215         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5216         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5217         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5218         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5219         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5220         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5221         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5222         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5223         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5224         /* Disable digital (SPDIF) pins */
5225         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5226         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5227
5228         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5229          * bus when acting as outputs.
5230          */
5231         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5232         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5233
5234         /* Start with output sum widgets muted and their output gains at min */
5235         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5236         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5237         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5238         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5239         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5240         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5241         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5242         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5243         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5244
5245         /* Unmute Line-out pin widget amp left and right
5246          * (no equiv mixer ctrl)
5247          */
5248         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5249         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5250          * inputs. If the pin mode is changed by the user the pin mode control
5251          * will take care of enabling the pin's input/output buffers as needed.
5252          * Therefore there's no need to enable the input buffer at this
5253          * stage.
5254          */
5255         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5256
5257         /* Mute capture amp left and right */
5258         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5259         /* Set ADC connection select to match default mixer setting - mic
5260          * (on mic1 pin)
5261          */
5262         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5263
5264         /* Do similar with the second ADC: mute capture input amp and
5265          * set ADC connection to mic to match ALSA's default state.
5266          */
5267         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5268         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5269
5270         /* Mute all inputs to mixer widget (even unconnected ones) */
5271         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5272         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5273         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5274         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5275         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5276         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5277         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5278         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5279
5280         { }
5281 };
5282
5283 static struct hda_verb alc260_will_verbs[] = {
5284         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5285         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5286         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5287         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5288         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5289         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5290         {}
5291 };
5292
5293 static struct hda_verb alc260_replacer_672v_verbs[] = {
5294         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5295         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5296         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5297
5298         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5299         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5300         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5301
5302         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5303         {}
5304 };
5305
5306 /* toggle speaker-output according to the hp-jack state */
5307 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5308 {
5309         unsigned int present;
5310
5311         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5312         present = snd_hda_codec_read(codec, 0x0f, 0,
5313                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5314         if (present) {
5315                 snd_hda_codec_write_cache(codec, 0x01, 0,
5316                                           AC_VERB_SET_GPIO_DATA, 1);
5317                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5318                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5319                                           PIN_HP);
5320         } else {
5321                 snd_hda_codec_write_cache(codec, 0x01, 0,
5322                                           AC_VERB_SET_GPIO_DATA, 0);
5323                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5324                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5325                                           PIN_OUT);
5326         }
5327 }
5328
5329 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5330                                        unsigned int res)
5331 {
5332         if ((res >> 26) == ALC880_HP_EVENT)
5333                 alc260_replacer_672v_automute(codec);
5334 }
5335
5336 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5337         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5338         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5339         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5340         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5341         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5342         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5343         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5344         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5345         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5346         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5347         {}
5348 };
5349
5350 /* Test configuration for debugging, modelled after the ALC880 test
5351  * configuration.
5352  */
5353 #ifdef CONFIG_SND_DEBUG
5354 static hda_nid_t alc260_test_dac_nids[1] = {
5355         0x02,
5356 };
5357 static hda_nid_t alc260_test_adc_nids[2] = {
5358         0x04, 0x05,
5359 };
5360 /* For testing the ALC260, each input MUX needs its own definition since
5361  * the signal assignments are different.  This assumes that the first ADC
5362  * is NID 0x04.
5363  */
5364 static struct hda_input_mux alc260_test_capture_sources[2] = {
5365         {
5366                 .num_items = 7,
5367                 .items = {
5368                         { "MIC1 pin", 0x0 },
5369                         { "MIC2 pin", 0x1 },
5370                         { "LINE1 pin", 0x2 },
5371                         { "LINE2 pin", 0x3 },
5372                         { "CD pin", 0x4 },
5373                         { "LINE-OUT pin", 0x5 },
5374                         { "HP-OUT pin", 0x6 },
5375                 },
5376         },
5377         {
5378                 .num_items = 8,
5379                 .items = {
5380                         { "MIC1 pin", 0x0 },
5381                         { "MIC2 pin", 0x1 },
5382                         { "LINE1 pin", 0x2 },
5383                         { "LINE2 pin", 0x3 },
5384                         { "CD pin", 0x4 },
5385                         { "Mixer", 0x5 },
5386                         { "LINE-OUT pin", 0x6 },
5387                         { "HP-OUT pin", 0x7 },
5388                 },
5389         },
5390 };
5391 static struct snd_kcontrol_new alc260_test_mixer[] = {
5392         /* Output driver widgets */
5393         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5394         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5395         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5396         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5397         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5398         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5399
5400         /* Modes for retasking pin widgets
5401          * Note: the ALC260 doesn't seem to act on requests to enable mic
5402          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5403          * mention this restriction.  At this stage it's not clear whether
5404          * this behaviour is intentional or is a hardware bug in chip
5405          * revisions available at least up until early 2006.  Therefore for
5406          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5407          * choices, but if it turns out that the lack of mic bias for these
5408          * NIDs is intentional we could change their modes from
5409          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5410          */
5411         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5412         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5413         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5414         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5415         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5416         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5417
5418         /* Loopback mixer controls */
5419         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5420         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5421         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5422         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5423         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5424         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5425         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5426         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5427         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5428         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5429         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5430         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5431         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5432         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5433
5434         /* Controls for GPIO pins, assuming they are configured as outputs */
5435         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5436         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5437         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5438         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5439
5440         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5441          * is ambigious as to which NID is which; testing on laptops which
5442          * make this output available should provide clarification.
5443          */
5444         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5445         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5446
5447         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5448          * this output to turn on an external amplifier.
5449          */
5450         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5451         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5452
5453         { } /* end */
5454 };
5455 static struct hda_verb alc260_test_init_verbs[] = {
5456         /* Enable all GPIOs as outputs with an initial value of 0 */
5457         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5458         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5459         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5460
5461         /* Enable retasking pins as output, initially without power amp */
5462         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5463         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5464         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5465         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5466         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5467         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5468
5469         /* Disable digital (SPDIF) pins initially, but users can enable
5470          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5471          * payload also sets the generation to 0, output to be in "consumer"
5472          * PCM format, copyright asserted, no pre-emphasis and no validity
5473          * control.
5474          */
5475         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5476         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5477
5478         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5479          * OUT1 sum bus when acting as an output.
5480          */
5481         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5482         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5483         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5484         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5485
5486         /* Start with output sum widgets muted and their output gains at min */
5487         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5488         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5489         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5490         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5491         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5492         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5493         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5494         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5495         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5496
5497         /* Unmute retasking pin widget output buffers since the default
5498          * state appears to be output.  As the pin mode is changed by the
5499          * user the pin mode control will take care of enabling the pin's
5500          * input/output buffers as needed.
5501          */
5502         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5503         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5504         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5505         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5506         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5507         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5508         /* Also unmute the mono-out pin widget */
5509         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5510
5511         /* Mute capture amp left and right */
5512         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5513         /* Set ADC connection select to match default mixer setting (mic1
5514          * pin)
5515          */
5516         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5517
5518         /* Do the same for the second ADC: mute capture input amp and
5519          * set ADC connection to mic1 pin
5520          */
5521         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5522         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5523
5524         /* Mute all inputs to mixer widget (even unconnected ones) */
5525         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5526         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5527         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5528         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5529         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5530         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5531         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5532         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5533
5534         { }
5535 };
5536 #endif
5537
5538 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5539 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5540
5541 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5542 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5543
5544 /*
5545  * for BIOS auto-configuration
5546  */
5547
5548 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5549                                         const char *pfx, int *vol_bits)
5550 {
5551         hda_nid_t nid_vol;
5552         unsigned long vol_val, sw_val;
5553         char name[32];
5554         int err;
5555
5556         if (nid >= 0x0f && nid < 0x11) {
5557                 nid_vol = nid - 0x7;
5558                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5559                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5560         } else if (nid == 0x11) {
5561                 nid_vol = nid - 0x7;
5562                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5563                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5564         } else if (nid >= 0x12 && nid <= 0x15) {
5565                 nid_vol = 0x08;
5566                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5567                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5568         } else
5569                 return 0; /* N/A */
5570
5571         if (!(*vol_bits & (1 << nid_vol))) {
5572                 /* first control for the volume widget */
5573                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5574                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5575                 if (err < 0)
5576                         return err;
5577                 *vol_bits |= (1 << nid_vol);
5578         }
5579         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5580         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5581         if (err < 0)
5582                 return err;
5583         return 1;
5584 }
5585
5586 /* add playback controls from the parsed DAC table */
5587 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5588                                              const struct auto_pin_cfg *cfg)
5589 {
5590         hda_nid_t nid;
5591         int err;
5592         int vols = 0;
5593
5594         spec->multiout.num_dacs = 1;
5595         spec->multiout.dac_nids = spec->private_dac_nids;
5596         spec->multiout.dac_nids[0] = 0x02;
5597
5598         nid = cfg->line_out_pins[0];
5599         if (nid) {
5600                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5601                 if (err < 0)
5602                         return err;
5603         }
5604
5605         nid = cfg->speaker_pins[0];
5606         if (nid) {
5607                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5608                 if (err < 0)
5609                         return err;
5610         }
5611
5612         nid = cfg->hp_pins[0];
5613         if (nid) {
5614                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5615                                                    &vols);
5616                 if (err < 0)
5617                         return err;
5618         }
5619         return 0;
5620 }
5621
5622 /* create playback/capture controls for input pins */
5623 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5624                                                 const struct auto_pin_cfg *cfg)
5625 {
5626         struct hda_input_mux *imux = &spec->private_imux[0];
5627         int i, err, idx;
5628
5629         for (i = 0; i < AUTO_PIN_LAST; i++) {
5630                 if (cfg->input_pins[i] >= 0x12) {
5631                         idx = cfg->input_pins[i] - 0x12;
5632                         err = new_analog_input(spec, cfg->input_pins[i],
5633                                                auto_pin_cfg_labels[i], idx,
5634                                                0x07);
5635                         if (err < 0)
5636                                 return err;
5637                         imux->items[imux->num_items].label =
5638                                 auto_pin_cfg_labels[i];
5639                         imux->items[imux->num_items].index = idx;
5640                         imux->num_items++;
5641                 }
5642                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5643                         idx = cfg->input_pins[i] - 0x09;
5644                         err = new_analog_input(spec, cfg->input_pins[i],
5645                                                auto_pin_cfg_labels[i], idx,
5646                                                0x07);
5647                         if (err < 0)
5648                                 return err;
5649                         imux->items[imux->num_items].label =
5650                                 auto_pin_cfg_labels[i];
5651                         imux->items[imux->num_items].index = idx;
5652                         imux->num_items++;
5653                 }
5654         }
5655         return 0;
5656 }
5657
5658 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5659                                               hda_nid_t nid, int pin_type,
5660                                               int sel_idx)
5661 {
5662         alc_set_pin_output(codec, nid, pin_type);
5663         /* need the manual connection? */
5664         if (nid >= 0x12) {
5665                 int idx = nid - 0x12;
5666                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5667                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5668         }
5669 }
5670
5671 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5672 {
5673         struct alc_spec *spec = codec->spec;
5674         hda_nid_t nid;
5675
5676         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5677         nid = spec->autocfg.line_out_pins[0];
5678         if (nid) {
5679                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5680                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5681         }
5682
5683         nid = spec->autocfg.speaker_pins[0];
5684         if (nid)
5685                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5686
5687         nid = spec->autocfg.hp_pins[0];
5688         if (nid)
5689                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5690 }
5691
5692 #define ALC260_PIN_CD_NID               0x16
5693 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5694 {
5695         struct alc_spec *spec = codec->spec;
5696         int i;
5697
5698         for (i = 0; i < AUTO_PIN_LAST; i++) {
5699                 hda_nid_t nid = spec->autocfg.input_pins[i];
5700                 if (nid >= 0x12) {
5701                         alc_set_input_pin(codec, nid, i);
5702                         if (nid != ALC260_PIN_CD_NID &&
5703                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5704                                 snd_hda_codec_write(codec, nid, 0,
5705                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5706                                                     AMP_OUT_MUTE);
5707                 }
5708         }
5709 }
5710
5711 /*
5712  * generic initialization of ADC, input mixers and output mixers
5713  */
5714 static struct hda_verb alc260_volume_init_verbs[] = {
5715         /*
5716          * Unmute ADC0-1 and set the default input to mic-in
5717          */
5718         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5719         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5720         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5721         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5722
5723         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5724          * mixer widget
5725          * Note: PASD motherboards uses the Line In 2 as the input for
5726          * front panel mic (mic 2)
5727          */
5728         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5729         /* mute analog inputs */
5730         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5731         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5732         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5733         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5734         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5735
5736         /*
5737          * Set up output mixers (0x08 - 0x0a)
5738          */
5739         /* set vol=0 to output mixers */
5740         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5741         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5742         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5743         /* set up input amps for analog loopback */
5744         /* Amp Indices: DAC = 0, mixer = 1 */
5745         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5746         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5747         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5748         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5749         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5750         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5751
5752         { }
5753 };
5754
5755 static int alc260_parse_auto_config(struct hda_codec *codec)
5756 {
5757         struct alc_spec *spec = codec->spec;
5758         int err;
5759         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5760
5761         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5762                                            alc260_ignore);
5763         if (err < 0)
5764                 return err;
5765         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5766         if (err < 0)
5767                 return err;
5768         if (!spec->kctls.list)
5769                 return 0; /* can't find valid BIOS pin config */
5770         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5771         if (err < 0)
5772                 return err;
5773
5774         spec->multiout.max_channels = 2;
5775
5776         if (spec->autocfg.dig_outs)
5777                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5778         if (spec->kctls.list)
5779                 add_mixer(spec, spec->kctls.list);
5780
5781         add_verb(spec, alc260_volume_init_verbs);
5782
5783         spec->num_mux_defs = 1;
5784         spec->input_mux = &spec->private_imux[0];
5785
5786         return 1;
5787 }
5788
5789 /* additional initialization for auto-configuration model */
5790 static void alc260_auto_init(struct hda_codec *codec)
5791 {
5792         struct alc_spec *spec = codec->spec;
5793         alc260_auto_init_multi_out(codec);
5794         alc260_auto_init_analog_input(codec);
5795         if (spec->unsol_event)
5796                 alc_inithook(codec);
5797 }
5798
5799 #ifdef CONFIG_SND_HDA_POWER_SAVE
5800 static struct hda_amp_list alc260_loopbacks[] = {
5801         { 0x07, HDA_INPUT, 0 },
5802         { 0x07, HDA_INPUT, 1 },
5803         { 0x07, HDA_INPUT, 2 },
5804         { 0x07, HDA_INPUT, 3 },
5805         { 0x07, HDA_INPUT, 4 },
5806         { } /* end */
5807 };
5808 #endif
5809
5810 /*
5811  * ALC260 configurations
5812  */
5813 static const char *alc260_models[ALC260_MODEL_LAST] = {
5814         [ALC260_BASIC]          = "basic",
5815         [ALC260_HP]             = "hp",
5816         [ALC260_HP_3013]        = "hp-3013",
5817         [ALC260_HP_DC7600]      = "hp-dc7600",
5818         [ALC260_FUJITSU_S702X]  = "fujitsu",
5819         [ALC260_ACER]           = "acer",
5820         [ALC260_WILL]           = "will",
5821         [ALC260_REPLACER_672V]  = "replacer",
5822         [ALC260_FAVORIT100]     = "favorit100",
5823 #ifdef CONFIG_SND_DEBUG
5824         [ALC260_TEST]           = "test",
5825 #endif
5826         [ALC260_AUTO]           = "auto",
5827 };
5828
5829 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5830         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5831         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5832         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5833         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5834         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5835         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5836         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5837         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5838         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5839         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5840         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5841         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5842         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5843         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5844         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5845         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5846         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5847         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5848         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5849         {}
5850 };
5851
5852 static struct alc_config_preset alc260_presets[] = {
5853         [ALC260_BASIC] = {
5854                 .mixers = { alc260_base_output_mixer,
5855                             alc260_input_mixer },
5856                 .init_verbs = { alc260_init_verbs },
5857                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5858                 .dac_nids = alc260_dac_nids,
5859                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5860                 .adc_nids = alc260_adc_nids,
5861                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5862                 .channel_mode = alc260_modes,
5863                 .input_mux = &alc260_capture_source,
5864         },
5865         [ALC260_HP] = {
5866                 .mixers = { alc260_hp_output_mixer,
5867                             alc260_input_mixer },
5868                 .init_verbs = { alc260_init_verbs,
5869                                 alc260_hp_unsol_verbs },
5870                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5871                 .dac_nids = alc260_dac_nids,
5872                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5873                 .adc_nids = alc260_adc_nids_alt,
5874                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5875                 .channel_mode = alc260_modes,
5876                 .input_mux = &alc260_capture_source,
5877                 .unsol_event = alc260_hp_unsol_event,
5878                 .init_hook = alc260_hp_automute,
5879         },
5880         [ALC260_HP_DC7600] = {
5881                 .mixers = { alc260_hp_dc7600_mixer,
5882                             alc260_input_mixer },
5883                 .init_verbs = { alc260_init_verbs,
5884                                 alc260_hp_dc7600_verbs },
5885                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5886                 .dac_nids = alc260_dac_nids,
5887                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5888                 .adc_nids = alc260_adc_nids_alt,
5889                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5890                 .channel_mode = alc260_modes,
5891                 .input_mux = &alc260_capture_source,
5892                 .unsol_event = alc260_hp_3012_unsol_event,
5893                 .init_hook = alc260_hp_3012_automute,
5894         },
5895         [ALC260_HP_3013] = {
5896                 .mixers = { alc260_hp_3013_mixer,
5897                             alc260_input_mixer },
5898                 .init_verbs = { alc260_hp_3013_init_verbs,
5899                                 alc260_hp_3013_unsol_verbs },
5900                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5901                 .dac_nids = alc260_dac_nids,
5902                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5903                 .adc_nids = alc260_adc_nids_alt,
5904                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5905                 .channel_mode = alc260_modes,
5906                 .input_mux = &alc260_capture_source,
5907                 .unsol_event = alc260_hp_3013_unsol_event,
5908                 .init_hook = alc260_hp_3013_automute,
5909         },
5910         [ALC260_FUJITSU_S702X] = {
5911                 .mixers = { alc260_fujitsu_mixer },
5912                 .init_verbs = { alc260_fujitsu_init_verbs },
5913                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5914                 .dac_nids = alc260_dac_nids,
5915                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5916                 .adc_nids = alc260_dual_adc_nids,
5917                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5918                 .channel_mode = alc260_modes,
5919                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5920                 .input_mux = alc260_fujitsu_capture_sources,
5921         },
5922         [ALC260_ACER] = {
5923                 .mixers = { alc260_acer_mixer },
5924                 .init_verbs = { alc260_acer_init_verbs },
5925                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5926                 .dac_nids = alc260_dac_nids,
5927                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5928                 .adc_nids = alc260_dual_adc_nids,
5929                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5930                 .channel_mode = alc260_modes,
5931                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5932                 .input_mux = alc260_acer_capture_sources,
5933         },
5934         [ALC260_FAVORIT100] = {
5935                 .mixers = { alc260_favorit100_mixer },
5936                 .init_verbs = { alc260_favorit100_init_verbs },
5937                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5938                 .dac_nids = alc260_dac_nids,
5939                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5940                 .adc_nids = alc260_dual_adc_nids,
5941                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5942                 .channel_mode = alc260_modes,
5943                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
5944                 .input_mux = alc260_favorit100_capture_sources,
5945         },
5946         [ALC260_WILL] = {
5947                 .mixers = { alc260_will_mixer },
5948                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5949                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5950                 .dac_nids = alc260_dac_nids,
5951                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5952                 .adc_nids = alc260_adc_nids,
5953                 .dig_out_nid = ALC260_DIGOUT_NID,
5954                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5955                 .channel_mode = alc260_modes,
5956                 .input_mux = &alc260_capture_source,
5957         },
5958         [ALC260_REPLACER_672V] = {
5959                 .mixers = { alc260_replacer_672v_mixer },
5960                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5961                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5962                 .dac_nids = alc260_dac_nids,
5963                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5964                 .adc_nids = alc260_adc_nids,
5965                 .dig_out_nid = ALC260_DIGOUT_NID,
5966                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5967                 .channel_mode = alc260_modes,
5968                 .input_mux = &alc260_capture_source,
5969                 .unsol_event = alc260_replacer_672v_unsol_event,
5970                 .init_hook = alc260_replacer_672v_automute,
5971         },
5972 #ifdef CONFIG_SND_DEBUG
5973         [ALC260_TEST] = {
5974                 .mixers = { alc260_test_mixer },
5975                 .init_verbs = { alc260_test_init_verbs },
5976                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5977                 .dac_nids = alc260_test_dac_nids,
5978                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5979                 .adc_nids = alc260_test_adc_nids,
5980                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5981                 .channel_mode = alc260_modes,
5982                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5983                 .input_mux = alc260_test_capture_sources,
5984         },
5985 #endif
5986 };
5987
5988 static int patch_alc260(struct hda_codec *codec)
5989 {
5990         struct alc_spec *spec;
5991         int err, board_config;
5992
5993         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5994         if (spec == NULL)
5995                 return -ENOMEM;
5996
5997         codec->spec = spec;
5998
5999         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6000                                                   alc260_models,
6001                                                   alc260_cfg_tbl);
6002         if (board_config < 0) {
6003                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
6004                            "trying auto-probe from BIOS...\n");
6005                 board_config = ALC260_AUTO;
6006         }
6007
6008         if (board_config == ALC260_AUTO) {
6009                 /* automatic parse from the BIOS config */
6010                 err = alc260_parse_auto_config(codec);
6011                 if (err < 0) {
6012                         alc_free(codec);
6013                         return err;
6014                 } else if (!err) {
6015                         printk(KERN_INFO
6016                                "hda_codec: Cannot set up configuration "
6017                                "from BIOS.  Using base mode...\n");
6018                         board_config = ALC260_BASIC;
6019                 }
6020         }
6021
6022         err = snd_hda_attach_beep_device(codec, 0x1);
6023         if (err < 0) {
6024                 alc_free(codec);
6025                 return err;
6026         }
6027
6028         if (board_config != ALC260_AUTO)
6029                 setup_preset(spec, &alc260_presets[board_config]);
6030
6031         spec->stream_name_analog = "ALC260 Analog";
6032         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6033         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6034
6035         spec->stream_name_digital = "ALC260 Digital";
6036         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6037         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6038
6039         if (!spec->adc_nids && spec->input_mux) {
6040                 /* check whether NID 0x04 is valid */
6041                 unsigned int wcap = get_wcaps(codec, 0x04);
6042                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6043                 /* get type */
6044                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6045                         spec->adc_nids = alc260_adc_nids_alt;
6046                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6047                 } else {
6048                         spec->adc_nids = alc260_adc_nids;
6049                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6050                 }
6051         }
6052         set_capture_mixer(spec);
6053         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6054
6055         spec->vmaster_nid = 0x08;
6056
6057         codec->patch_ops = alc_patch_ops;
6058         if (board_config == ALC260_AUTO)
6059                 spec->init_hook = alc260_auto_init;
6060 #ifdef CONFIG_SND_HDA_POWER_SAVE
6061         if (!spec->loopback.amplist)
6062                 spec->loopback.amplist = alc260_loopbacks;
6063 #endif
6064         codec->proc_widget_hook = print_realtek_coef;
6065
6066         return 0;
6067 }
6068
6069
6070 /*
6071  * ALC882 support
6072  *
6073  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6074  * configuration.  Each pin widget can choose any input DACs and a mixer.
6075  * Each ADC is connected from a mixer of all inputs.  This makes possible
6076  * 6-channel independent captures.
6077  *
6078  * In addition, an independent DAC for the multi-playback (not used in this
6079  * driver yet).
6080  */
6081 #define ALC882_DIGOUT_NID       0x06
6082 #define ALC882_DIGIN_NID        0x0a
6083
6084 static struct hda_channel_mode alc882_ch_modes[1] = {
6085         { 8, NULL }
6086 };
6087
6088 static hda_nid_t alc882_dac_nids[4] = {
6089         /* front, rear, clfe, rear_surr */
6090         0x02, 0x03, 0x04, 0x05
6091 };
6092
6093 /* identical with ALC880 */
6094 #define alc882_adc_nids         alc880_adc_nids
6095 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6096
6097 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6098 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6099
6100 /* input MUX */
6101 /* FIXME: should be a matrix-type input source selection */
6102
6103 static struct hda_input_mux alc882_capture_source = {
6104         .num_items = 4,
6105         .items = {
6106                 { "Mic", 0x0 },
6107                 { "Front Mic", 0x1 },
6108                 { "Line", 0x2 },
6109                 { "CD", 0x4 },
6110         },
6111 };
6112 /*
6113  * 2ch mode
6114  */
6115 static struct hda_verb alc882_3ST_ch2_init[] = {
6116         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6117         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6118         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6119         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6120         { } /* end */
6121 };
6122
6123 /*
6124  * 6ch mode
6125  */
6126 static struct hda_verb alc882_3ST_ch6_init[] = {
6127         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6128         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6129         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6130         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6131         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6132         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6133         { } /* end */
6134 };
6135
6136 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6137         { 2, alc882_3ST_ch2_init },
6138         { 6, alc882_3ST_ch6_init },
6139 };
6140
6141 /*
6142  * 6ch mode
6143  */
6144 static struct hda_verb alc882_sixstack_ch6_init[] = {
6145         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6146         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6147         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6148         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6149         { } /* end */
6150 };
6151
6152 /*
6153  * 8ch mode
6154  */
6155 static struct hda_verb alc882_sixstack_ch8_init[] = {
6156         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6157         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6158         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6159         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6160         { } /* end */
6161 };
6162
6163 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6164         { 6, alc882_sixstack_ch6_init },
6165         { 8, alc882_sixstack_ch8_init },
6166 };
6167
6168 /*
6169  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6170  */
6171
6172 /*
6173  * 2ch mode
6174  */
6175 static struct hda_verb alc885_mbp_ch2_init[] = {
6176         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6177         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6178         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6179         { } /* end */
6180 };
6181
6182 /*
6183  * 6ch mode
6184  */
6185 static struct hda_verb alc885_mbp_ch6_init[] = {
6186         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6187         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6188         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6189         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6190         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6191         { } /* end */
6192 };
6193
6194 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6195         { 2, alc885_mbp_ch2_init },
6196         { 6, alc885_mbp_ch6_init },
6197 };
6198
6199
6200 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6201  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6202  */
6203 static struct snd_kcontrol_new alc882_base_mixer[] = {
6204         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6205         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6206         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6207         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6208         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6209         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6210         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6211         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6212         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6213         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6214         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6215         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6216         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6217         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6218         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6219         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6220         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6221         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6222         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6223         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6224         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6225         { } /* end */
6226 };
6227
6228 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6229         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6230         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6231         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6232         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6233         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6234         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6235         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6236         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6237         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6238         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6239         { } /* end */
6240 };
6241 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6242         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6243         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6244         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6245         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6246         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6247         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6248         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6249         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6250         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6251         { } /* end */
6252 };
6253
6254 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6255         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6256         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6257         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6258         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6259         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
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, 0x0, HDA_INPUT),
6263         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6264         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6265         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6266         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6267         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6268         { } /* end */
6269 };
6270
6271 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6272  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6273  */
6274 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6275         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6276         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6277         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6278         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6279         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6280         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6281         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6282         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6283         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6284         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6285         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6286         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6287         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6288         { } /* end */
6289 };
6290
6291 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6292         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6293         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6294         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6295         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6296         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6297         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6298         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6299         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6300         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6301         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6302         { } /* end */
6303 };
6304
6305 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6306         {
6307                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6308                 .name = "Channel Mode",
6309                 .info = alc_ch_mode_info,
6310                 .get = alc_ch_mode_get,
6311                 .put = alc_ch_mode_put,
6312         },
6313         { } /* end */
6314 };
6315
6316 static struct hda_verb alc882_init_verbs[] = {
6317         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6318         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6319         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6320         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6321         /* Rear mixer */
6322         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6323         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6324         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6325         /* CLFE mixer */
6326         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6327         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6328         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6329         /* Side mixer */
6330         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6331         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6332         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6333
6334         /* Front Pin: output 0 (0x0c) */
6335         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6336         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6337         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6338         /* Rear Pin: output 1 (0x0d) */
6339         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6340         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6341         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6342         /* CLFE Pin: output 2 (0x0e) */
6343         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6344         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6345         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6346         /* Side Pin: output 3 (0x0f) */
6347         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6348         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6349         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6350         /* Mic (rear) pin: input vref at 80% */
6351         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6352         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6353         /* Front Mic pin: input vref at 80% */
6354         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6355         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6356         /* Line In pin: input */
6357         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6358         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6359         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6360         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6361         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6362         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6363         /* CD pin widget for input */
6364         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6365
6366         /* FIXME: use matrix-type input source selection */
6367         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6368         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6369         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6371         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6372         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6373         /* Input mixer2 */
6374         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6375         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6376         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6377         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6378         /* Input mixer3 */
6379         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6380         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6381         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6382         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6383         /* ADC1: mute amp left and right */
6384         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6385         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6386         /* ADC2: mute amp left and right */
6387         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6388         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6389         /* ADC3: mute amp left and right */
6390         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6391         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6392
6393         { }
6394 };
6395
6396 static struct hda_verb alc882_eapd_verbs[] = {
6397         /* change to EAPD mode */
6398         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6399         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6400         { }
6401 };
6402
6403 /* Mac Pro test */
6404 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6405         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6406         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6407         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6408         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6409         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6410         /* FIXME: this looks suspicious...
6411         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6412         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6413         */
6414         { } /* end */
6415 };
6416
6417 static struct hda_verb alc882_macpro_init_verbs[] = {
6418         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6419         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6420         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6421         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6422         /* Front Pin: output 0 (0x0c) */
6423         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6424         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6425         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6426         /* Front Mic pin: input vref at 80% */
6427         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6428         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6429         /* Speaker:  output */
6430         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6431         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6432         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6433         /* Headphone output (output 0 - 0x0c) */
6434         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6435         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6436         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6437
6438         /* FIXME: use matrix-type input source selection */
6439         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6440         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6441         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6442         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6443         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6444         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6445         /* Input mixer2 */
6446         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6447         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6448         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6449         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6450         /* Input mixer3 */
6451         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6452         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6453         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6455         /* ADC1: mute amp left and right */
6456         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6457         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6458         /* ADC2: mute amp left and right */
6459         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6460         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6461         /* ADC3: mute amp left and right */
6462         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6463         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6464
6465         { }
6466 };
6467
6468 /* Macbook Pro rev3 */
6469 static struct hda_verb alc885_mbp3_init_verbs[] = {
6470         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6471         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6472         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6473         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6474         /* Rear mixer */
6475         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6476         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6478         /* Front Pin: output 0 (0x0c) */
6479         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6480         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6481         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6482         /* HP Pin: output 0 (0x0d) */
6483         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6484         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6485         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6486         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6487         /* Mic (rear) pin: input vref at 80% */
6488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6489         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6490         /* Front Mic pin: input vref at 80% */
6491         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6492         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6493         /* Line In pin: use output 1 when in LineOut mode */
6494         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6495         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6496         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6497
6498         /* FIXME: use matrix-type input source selection */
6499         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6500         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6501         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6502         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6503         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6504         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6505         /* Input mixer2 */
6506         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6507         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6508         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6509         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6510         /* Input mixer3 */
6511         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6512         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6513         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6514         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6515         /* ADC1: mute amp left and right */
6516         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6517         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6518         /* ADC2: mute amp left and right */
6519         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6520         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6521         /* ADC3: mute amp left and right */
6522         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6523         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6524
6525         { }
6526 };
6527
6528 /* iMac 24 mixer. */
6529 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6530         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6531         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6532         { } /* end */
6533 };
6534
6535 /* iMac 24 init verbs. */
6536 static struct hda_verb alc885_imac24_init_verbs[] = {
6537         /* Internal speakers: output 0 (0x0c) */
6538         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6539         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6540         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6541         /* Internal speakers: output 0 (0x0c) */
6542         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6543         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6544         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6545         /* Headphone: output 0 (0x0c) */
6546         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6547         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6548         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6549         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6550         /* Front Mic: input vref at 80% */
6551         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6552         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6553         { }
6554 };
6555
6556 /* Toggle speaker-output according to the hp-jack state */
6557 static void alc885_imac24_automute(struct hda_codec *codec)
6558 {
6559         unsigned int present;
6560
6561         present = snd_hda_codec_read(codec, 0x14, 0,
6562                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6563         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6564                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6565         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6566                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6567 }
6568
6569 /* Processes unsolicited events. */
6570 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6571                                       unsigned int res)
6572 {
6573         /* Headphone insertion or removal. */
6574         if ((res >> 26) == ALC880_HP_EVENT)
6575                 alc885_imac24_automute(codec);
6576 }
6577
6578 static void alc885_mbp3_automute(struct hda_codec *codec)
6579 {
6580         unsigned int present;
6581
6582         present = snd_hda_codec_read(codec, 0x15, 0,
6583                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6584         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6585                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6586         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6587                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6588
6589 }
6590 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6591                                     unsigned int res)
6592 {
6593         /* Headphone insertion or removal. */
6594         if ((res >> 26) == ALC880_HP_EVENT)
6595                 alc885_mbp3_automute(codec);
6596 }
6597
6598
6599 static struct hda_verb alc882_targa_verbs[] = {
6600         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6601         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6602
6603         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6604         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6605
6606         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6607         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6608         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6609
6610         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6611         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6612         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6613         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6614         { } /* end */
6615 };
6616
6617 /* toggle speaker-output according to the hp-jack state */
6618 static void alc882_targa_automute(struct hda_codec *codec)
6619 {
6620         unsigned int present;
6621
6622         present = snd_hda_codec_read(codec, 0x14, 0,
6623                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6624         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6625                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6626         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6627                                   present ? 1 : 3);
6628 }
6629
6630 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6631 {
6632         /* Looks like the unsol event is incompatible with the standard
6633          * definition.  4bit tag is placed at 26 bit!
6634          */
6635         if (((res >> 26) == ALC880_HP_EVENT)) {
6636                 alc882_targa_automute(codec);
6637         }
6638 }
6639
6640 static struct hda_verb alc882_asus_a7j_verbs[] = {
6641         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6642         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6643
6644         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6645         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6646         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6647
6648         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6649         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6650         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6651
6652         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6653         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6654         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6655         { } /* end */
6656 };
6657
6658 static struct hda_verb alc882_asus_a7m_verbs[] = {
6659         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6660         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6661
6662         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6663         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6664         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6665
6666         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6667         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6668         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6669
6670         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6671         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6672         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6673         { } /* end */
6674 };
6675
6676 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6677 {
6678         unsigned int gpiostate, gpiomask, gpiodir;
6679
6680         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6681                                        AC_VERB_GET_GPIO_DATA, 0);
6682
6683         if (!muted)
6684                 gpiostate |= (1 << pin);
6685         else
6686                 gpiostate &= ~(1 << pin);
6687
6688         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6689                                       AC_VERB_GET_GPIO_MASK, 0);
6690         gpiomask |= (1 << pin);
6691
6692         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6693                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6694         gpiodir |= (1 << pin);
6695
6696
6697         snd_hda_codec_write(codec, codec->afg, 0,
6698                             AC_VERB_SET_GPIO_MASK, gpiomask);
6699         snd_hda_codec_write(codec, codec->afg, 0,
6700                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6701
6702         msleep(1);
6703
6704         snd_hda_codec_write(codec, codec->afg, 0,
6705                             AC_VERB_SET_GPIO_DATA, gpiostate);
6706 }
6707
6708 /* set up GPIO at initialization */
6709 static void alc885_macpro_init_hook(struct hda_codec *codec)
6710 {
6711         alc882_gpio_mute(codec, 0, 0);
6712         alc882_gpio_mute(codec, 1, 0);
6713 }
6714
6715 /* set up GPIO and update auto-muting at initialization */
6716 static void alc885_imac24_init_hook(struct hda_codec *codec)
6717 {
6718         alc885_macpro_init_hook(codec);
6719         alc885_imac24_automute(codec);
6720 }
6721
6722 /*
6723  * generic initialization of ADC, input mixers and output mixers
6724  */
6725 static struct hda_verb alc882_auto_init_verbs[] = {
6726         /*
6727          * Unmute ADC0-2 and set the default input to mic-in
6728          */
6729         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6730         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6731         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6732         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6733         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6734         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6735
6736         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6737          * mixer widget
6738          * Note: PASD motherboards uses the Line In 2 as the input for
6739          * front panel mic (mic 2)
6740          */
6741         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6742         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6743         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6744         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6745         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6746         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6747
6748         /*
6749          * Set up output mixers (0x0c - 0x0f)
6750          */
6751         /* set vol=0 to output mixers */
6752         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6753         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6754         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6755         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6756         /* set up input amps for analog loopback */
6757         /* Amp Indices: DAC = 0, mixer = 1 */
6758         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6759         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6760         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6761         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6762         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6763         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6764         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6765         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6766         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6767         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6768
6769         /* FIXME: use matrix-type input source selection */
6770         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6771         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6772         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6773         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6774         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6775         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6776         /* Input mixer2 */
6777         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6778         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6779         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6780         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6781         /* Input mixer3 */
6782         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6783         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6784         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6785         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6786
6787         { }
6788 };
6789
6790 #ifdef CONFIG_SND_HDA_POWER_SAVE
6791 #define alc882_loopbacks        alc880_loopbacks
6792 #endif
6793
6794 /* pcm configuration: identiacal with ALC880 */
6795 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6796 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6797 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6798 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6799
6800 /*
6801  * configuration and preset
6802  */
6803 static const char *alc882_models[ALC882_MODEL_LAST] = {
6804         [ALC882_3ST_DIG]        = "3stack-dig",
6805         [ALC882_6ST_DIG]        = "6stack-dig",
6806         [ALC882_ARIMA]          = "arima",
6807         [ALC882_W2JC]           = "w2jc",
6808         [ALC882_TARGA]          = "targa",
6809         [ALC882_ASUS_A7J]       = "asus-a7j",
6810         [ALC882_ASUS_A7M]       = "asus-a7m",
6811         [ALC885_MACPRO]         = "macpro",
6812         [ALC885_MBP3]           = "mbp3",
6813         [ALC885_IMAC24]         = "imac24",
6814         [ALC882_AUTO]           = "auto",
6815 };
6816
6817 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6818         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6819         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6820         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6821         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6822         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6823         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6824         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6825         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6826         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6827         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6828         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6829         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6830         {}
6831 };
6832
6833 static struct alc_config_preset alc882_presets[] = {
6834         [ALC882_3ST_DIG] = {
6835                 .mixers = { alc882_base_mixer },
6836                 .init_verbs = { alc882_init_verbs },
6837                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6838                 .dac_nids = alc882_dac_nids,
6839                 .dig_out_nid = ALC882_DIGOUT_NID,
6840                 .dig_in_nid = ALC882_DIGIN_NID,
6841                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6842                 .channel_mode = alc882_ch_modes,
6843                 .need_dac_fix = 1,
6844                 .input_mux = &alc882_capture_source,
6845         },
6846         [ALC882_6ST_DIG] = {
6847                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6848                 .init_verbs = { alc882_init_verbs },
6849                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6850                 .dac_nids = alc882_dac_nids,
6851                 .dig_out_nid = ALC882_DIGOUT_NID,
6852                 .dig_in_nid = ALC882_DIGIN_NID,
6853                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6854                 .channel_mode = alc882_sixstack_modes,
6855                 .input_mux = &alc882_capture_source,
6856         },
6857         [ALC882_ARIMA] = {
6858                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6859                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6860                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6861                 .dac_nids = alc882_dac_nids,
6862                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6863                 .channel_mode = alc882_sixstack_modes,
6864                 .input_mux = &alc882_capture_source,
6865         },
6866         [ALC882_W2JC] = {
6867                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6868                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6869                                 alc880_gpio1_init_verbs },
6870                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6871                 .dac_nids = alc882_dac_nids,
6872                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6873                 .channel_mode = alc880_threestack_modes,
6874                 .need_dac_fix = 1,
6875                 .input_mux = &alc882_capture_source,
6876                 .dig_out_nid = ALC882_DIGOUT_NID,
6877         },
6878         [ALC885_MBP3] = {
6879                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6880                 .init_verbs = { alc885_mbp3_init_verbs,
6881                                 alc880_gpio1_init_verbs },
6882                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6883                 .dac_nids = alc882_dac_nids,
6884                 .channel_mode = alc885_mbp_6ch_modes,
6885                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6886                 .input_mux = &alc882_capture_source,
6887                 .dig_out_nid = ALC882_DIGOUT_NID,
6888                 .dig_in_nid = ALC882_DIGIN_NID,
6889                 .unsol_event = alc885_mbp3_unsol_event,
6890                 .init_hook = alc885_mbp3_automute,
6891         },
6892         [ALC885_MACPRO] = {
6893                 .mixers = { alc882_macpro_mixer },
6894                 .init_verbs = { alc882_macpro_init_verbs },
6895                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6896                 .dac_nids = alc882_dac_nids,
6897                 .dig_out_nid = ALC882_DIGOUT_NID,
6898                 .dig_in_nid = ALC882_DIGIN_NID,
6899                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6900                 .channel_mode = alc882_ch_modes,
6901                 .input_mux = &alc882_capture_source,
6902                 .init_hook = alc885_macpro_init_hook,
6903         },
6904         [ALC885_IMAC24] = {
6905                 .mixers = { alc885_imac24_mixer },
6906                 .init_verbs = { alc885_imac24_init_verbs },
6907                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6908                 .dac_nids = alc882_dac_nids,
6909                 .dig_out_nid = ALC882_DIGOUT_NID,
6910                 .dig_in_nid = ALC882_DIGIN_NID,
6911                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6912                 .channel_mode = alc882_ch_modes,
6913                 .input_mux = &alc882_capture_source,
6914                 .unsol_event = alc885_imac24_unsol_event,
6915                 .init_hook = alc885_imac24_init_hook,
6916         },
6917         [ALC882_TARGA] = {
6918                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
6919                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6920                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6921                 .dac_nids = alc882_dac_nids,
6922                 .dig_out_nid = ALC882_DIGOUT_NID,
6923                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6924                 .adc_nids = alc882_adc_nids,
6925                 .capsrc_nids = alc882_capsrc_nids,
6926                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6927                 .channel_mode = alc882_3ST_6ch_modes,
6928                 .need_dac_fix = 1,
6929                 .input_mux = &alc882_capture_source,
6930                 .unsol_event = alc882_targa_unsol_event,
6931                 .init_hook = alc882_targa_automute,
6932         },
6933         [ALC882_ASUS_A7J] = {
6934                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
6935                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6936                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6937                 .dac_nids = alc882_dac_nids,
6938                 .dig_out_nid = ALC882_DIGOUT_NID,
6939                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6940                 .adc_nids = alc882_adc_nids,
6941                 .capsrc_nids = alc882_capsrc_nids,
6942                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6943                 .channel_mode = alc882_3ST_6ch_modes,
6944                 .need_dac_fix = 1,
6945                 .input_mux = &alc882_capture_source,
6946         },
6947         [ALC882_ASUS_A7M] = {
6948                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6949                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6950                                 alc880_gpio1_init_verbs,
6951                                 alc882_asus_a7m_verbs },
6952                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6953                 .dac_nids = alc882_dac_nids,
6954                 .dig_out_nid = ALC882_DIGOUT_NID,
6955                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6956                 .channel_mode = alc880_threestack_modes,
6957                 .need_dac_fix = 1,
6958                 .input_mux = &alc882_capture_source,
6959         },
6960 };
6961
6962
6963 /*
6964  * Pin config fixes
6965  */
6966 enum {
6967         PINFIX_ABIT_AW9D_MAX
6968 };
6969
6970 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6971         { 0x15, 0x01080104 }, /* side */
6972         { 0x16, 0x01011012 }, /* rear */
6973         { 0x17, 0x01016011 }, /* clfe */
6974         { }
6975 };
6976
6977 static const struct alc_pincfg *alc882_pin_fixes[] = {
6978         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6979 };
6980
6981 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6982         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6983         {}
6984 };
6985
6986 /*
6987  * BIOS auto configuration
6988  */
6989 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6990                                               hda_nid_t nid, int pin_type,
6991                                               int dac_idx)
6992 {
6993         /* set as output */
6994         struct alc_spec *spec = codec->spec;
6995         int idx;
6996
6997         alc_set_pin_output(codec, nid, pin_type);
6998         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6999                 idx = 4;
7000         else
7001                 idx = spec->multiout.dac_nids[dac_idx] - 2;
7002         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
7003
7004 }
7005
7006 static void alc882_auto_init_multi_out(struct hda_codec *codec)
7007 {
7008         struct alc_spec *spec = codec->spec;
7009         int i;
7010
7011         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
7012         for (i = 0; i <= HDA_SIDE; i++) {
7013                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
7014                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7015                 if (nid)
7016                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
7017                                                           i);
7018         }
7019 }
7020
7021 static void alc882_auto_init_hp_out(struct hda_codec *codec)
7022 {
7023         struct alc_spec *spec = codec->spec;
7024         hda_nid_t pin;
7025
7026         pin = spec->autocfg.hp_pins[0];
7027         if (pin) /* connect to front */
7028                 /* use dac 0 */
7029                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7030         pin = spec->autocfg.speaker_pins[0];
7031         if (pin)
7032                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7033 }
7034
7035 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
7036 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
7037
7038 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7039 {
7040         struct alc_spec *spec = codec->spec;
7041         int i;
7042
7043         for (i = 0; i < AUTO_PIN_LAST; i++) {
7044                 hda_nid_t nid = spec->autocfg.input_pins[i];
7045                 if (!nid)
7046                         continue;
7047                 alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
7048                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7049                         snd_hda_codec_write(codec, nid, 0,
7050                                             AC_VERB_SET_AMP_GAIN_MUTE,
7051                                             AMP_OUT_MUTE);
7052         }
7053 }
7054
7055 static void alc882_auto_init_input_src(struct hda_codec *codec)
7056 {
7057         struct alc_spec *spec = codec->spec;
7058         int c;
7059
7060         for (c = 0; c < spec->num_adc_nids; c++) {
7061                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7062                 hda_nid_t nid = spec->capsrc_nids[c];
7063                 unsigned int mux_idx;
7064                 const struct hda_input_mux *imux;
7065                 int conns, mute, idx, item;
7066
7067                 conns = snd_hda_get_connections(codec, nid, conn_list,
7068                                                 ARRAY_SIZE(conn_list));
7069                 if (conns < 0)
7070                         continue;
7071                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
7072                 imux = &spec->input_mux[mux_idx];
7073                 for (idx = 0; idx < conns; idx++) {
7074                         /* if the current connection is the selected one,
7075                          * unmute it as default - otherwise mute it
7076                          */
7077                         mute = AMP_IN_MUTE(idx);
7078                         for (item = 0; item < imux->num_items; item++) {
7079                                 if (imux->items[item].index == idx) {
7080                                         if (spec->cur_mux[c] == item)
7081                                                 mute = AMP_IN_UNMUTE(idx);
7082                                         break;
7083                                 }
7084                         }
7085                         /* check if we have a selector or mixer
7086                          * we could check for the widget type instead, but
7087                          * just check for Amp-In presence (in case of mixer
7088                          * without amp-in there is something wrong, this
7089                          * function shouldn't be used or capsrc nid is wrong)
7090                          */
7091                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7092                                 snd_hda_codec_write(codec, nid, 0,
7093                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7094                                                     mute);
7095                         else if (mute != AMP_IN_MUTE(idx))
7096                                 snd_hda_codec_write(codec, nid, 0,
7097                                                     AC_VERB_SET_CONNECT_SEL,
7098                                                     idx);
7099                 }
7100         }
7101 }
7102
7103 /* add mic boosts if needed */
7104 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7105 {
7106         struct alc_spec *spec = codec->spec;
7107         int err;
7108         hda_nid_t nid;
7109
7110         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7111         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7112                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7113                                   "Mic Boost",
7114                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7115                 if (err < 0)
7116                         return err;
7117         }
7118         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7119         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7120                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
7121                                   "Front Mic Boost",
7122                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7123                 if (err < 0)
7124                         return err;
7125         }
7126         return 0;
7127 }
7128
7129 /* almost identical with ALC880 parser... */
7130 static int alc882_parse_auto_config(struct hda_codec *codec)
7131 {
7132         struct alc_spec *spec = codec->spec;
7133         int err = alc880_parse_auto_config(codec);
7134
7135         if (err < 0)
7136                 return err;
7137         else if (!err)
7138                 return 0; /* no config found */
7139
7140         err = alc_auto_add_mic_boost(codec);
7141         if (err < 0)
7142                 return err;
7143
7144         /* hack - override the init verbs */
7145         spec->init_verbs[0] = alc882_auto_init_verbs;
7146
7147         return 1; /* config found */
7148 }
7149
7150 /* additional initialization for auto-configuration model */
7151 static void alc882_auto_init(struct hda_codec *codec)
7152 {
7153         struct alc_spec *spec = codec->spec;
7154         alc882_auto_init_multi_out(codec);
7155         alc882_auto_init_hp_out(codec);
7156         alc882_auto_init_analog_input(codec);
7157         alc882_auto_init_input_src(codec);
7158         if (spec->unsol_event)
7159                 alc_inithook(codec);
7160 }
7161
7162 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7163
7164 static int patch_alc882(struct hda_codec *codec)
7165 {
7166         struct alc_spec *spec;
7167         int err, board_config;
7168
7169         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7170         if (spec == NULL)
7171                 return -ENOMEM;
7172
7173         codec->spec = spec;
7174
7175         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7176                                                   alc882_models,
7177                                                   alc882_cfg_tbl);
7178
7179         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7180                 /* Pick up systems that don't supply PCI SSID */
7181                 switch (codec->subsystem_id) {
7182                 case 0x106b0c00: /* Mac Pro */
7183                         board_config = ALC885_MACPRO;
7184                         break;
7185                 case 0x106b1000: /* iMac 24 */
7186                 case 0x106b2800: /* AppleTV */
7187                 case 0x106b3e00: /* iMac 24 Aluminium */
7188                         board_config = ALC885_IMAC24;
7189                         break;
7190                 case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7191                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7192                 case 0x106b00a4: /* MacbookPro4,1 */
7193                 case 0x106b2c00: /* Macbook Pro rev3 */
7194                 case 0x106b3600: /* Macbook 3.1 */
7195                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7196                         board_config = ALC885_MBP3;
7197                         break;
7198                 default:
7199                         /* ALC889A is handled better as ALC888-compatible */
7200                         if (codec->revision_id == 0x100101 ||
7201                             codec->revision_id == 0x100103) {
7202                                 alc_free(codec);
7203                                 return patch_alc883(codec);
7204                         }
7205                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
7206                                          "trying auto-probe from BIOS...\n");
7207                         board_config = ALC882_AUTO;
7208                 }
7209         }
7210
7211         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7212
7213         if (board_config == ALC882_AUTO) {
7214                 /* automatic parse from the BIOS config */
7215                 err = alc882_parse_auto_config(codec);
7216                 if (err < 0) {
7217                         alc_free(codec);
7218                         return err;
7219                 } else if (!err) {
7220                         printk(KERN_INFO
7221                                "hda_codec: Cannot set up configuration "
7222                                "from BIOS.  Using base mode...\n");
7223                         board_config = ALC882_3ST_DIG;
7224                 }
7225         }
7226
7227         err = snd_hda_attach_beep_device(codec, 0x1);
7228         if (err < 0) {
7229                 alc_free(codec);
7230                 return err;
7231         }
7232
7233         if (board_config != ALC882_AUTO)
7234                 setup_preset(spec, &alc882_presets[board_config]);
7235
7236         if (codec->vendor_id == 0x10ec0885) {
7237                 spec->stream_name_analog = "ALC885 Analog";
7238                 spec->stream_name_digital = "ALC885 Digital";
7239         } else {
7240                 spec->stream_name_analog = "ALC882 Analog";
7241                 spec->stream_name_digital = "ALC882 Digital";
7242         }
7243
7244         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7245         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7246         /* FIXME: setup DAC5 */
7247         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7248         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7249
7250         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7251         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7252
7253         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7254         if (!spec->adc_nids && spec->input_mux) {
7255                 /* check whether NID 0x07 is valid */
7256                 unsigned int wcap = get_wcaps(codec, 0x07);
7257                 /* get type */
7258                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7259                 if (wcap != AC_WID_AUD_IN) {
7260                         spec->adc_nids = alc882_adc_nids_alt;
7261                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7262                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7263                 } else {
7264                         spec->adc_nids = alc882_adc_nids;
7265                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7266                         spec->capsrc_nids = alc882_capsrc_nids;
7267                 }
7268         }
7269         set_capture_mixer(spec);
7270         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7271
7272         spec->vmaster_nid = 0x0c;
7273
7274         codec->patch_ops = alc_patch_ops;
7275         if (board_config == ALC882_AUTO)
7276                 spec->init_hook = alc882_auto_init;
7277 #ifdef CONFIG_SND_HDA_POWER_SAVE
7278         if (!spec->loopback.amplist)
7279                 spec->loopback.amplist = alc882_loopbacks;
7280 #endif
7281         codec->proc_widget_hook = print_realtek_coef;
7282
7283         return 0;
7284 }
7285
7286 /*
7287  * ALC883 support
7288  *
7289  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7290  * configuration.  Each pin widget can choose any input DACs and a mixer.
7291  * Each ADC is connected from a mixer of all inputs.  This makes possible
7292  * 6-channel independent captures.
7293  *
7294  * In addition, an independent DAC for the multi-playback (not used in this
7295  * driver yet).
7296  */
7297 #define ALC883_DIGOUT_NID       0x06
7298 #define ALC883_DIGIN_NID        0x0a
7299
7300 #define ALC1200_DIGOUT_NID      0x10
7301
7302 static hda_nid_t alc883_dac_nids[4] = {
7303         /* front, rear, clfe, rear_surr */
7304         0x02, 0x03, 0x04, 0x05
7305 };
7306
7307 static hda_nid_t alc883_adc_nids[2] = {
7308         /* ADC1-2 */
7309         0x08, 0x09,
7310 };
7311
7312 static hda_nid_t alc883_adc_nids_alt[1] = {
7313         /* ADC1 */
7314         0x08,
7315 };
7316
7317 static hda_nid_t alc883_adc_nids_rev[2] = {
7318         /* ADC2-1 */
7319         0x09, 0x08
7320 };
7321
7322 #define alc889_adc_nids         alc880_adc_nids
7323
7324 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7325
7326 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7327
7328 #define alc889_capsrc_nids      alc882_capsrc_nids
7329
7330 /* input MUX */
7331 /* FIXME: should be a matrix-type input source selection */
7332
7333 static struct hda_input_mux alc883_capture_source = {
7334         .num_items = 4,
7335         .items = {
7336                 { "Mic", 0x0 },
7337                 { "Front Mic", 0x1 },
7338                 { "Line", 0x2 },
7339                 { "CD", 0x4 },
7340         },
7341 };
7342
7343 static struct hda_input_mux alc883_3stack_6ch_intel = {
7344         .num_items = 4,
7345         .items = {
7346                 { "Mic", 0x1 },
7347                 { "Front Mic", 0x0 },
7348                 { "Line", 0x2 },
7349                 { "CD", 0x4 },
7350         },
7351 };
7352
7353 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7354         .num_items = 2,
7355         .items = {
7356                 { "Mic", 0x1 },
7357                 { "Line", 0x2 },
7358         },
7359 };
7360
7361 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7362         .num_items = 4,
7363         .items = {
7364                 { "Mic", 0x0 },
7365                 { "iMic", 0x1 },
7366                 { "Line", 0x2 },
7367                 { "CD", 0x4 },
7368         },
7369 };
7370
7371 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7372         .num_items = 2,
7373         .items = {
7374                 { "Mic", 0x0 },
7375                 { "Int Mic", 0x1 },
7376         },
7377 };
7378
7379 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7380         .num_items = 3,
7381         .items = {
7382                 { "Mic", 0x0 },
7383                 { "Front Mic", 0x1 },
7384                 { "Line", 0x4 },
7385         },
7386 };
7387
7388 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7389         .num_items = 2,
7390         .items = {
7391                 { "Mic", 0x0 },
7392                 { "Line", 0x2 },
7393         },
7394 };
7395
7396 /*
7397  * 2ch mode
7398  */
7399 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7400         { 2, NULL }
7401 };
7402
7403 /*
7404  * 2ch mode
7405  */
7406 static struct hda_verb alc883_3ST_ch2_init[] = {
7407         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7408         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7409         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7410         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7411         { } /* end */
7412 };
7413
7414 /*
7415  * 4ch mode
7416  */
7417 static struct hda_verb alc883_3ST_ch4_init[] = {
7418         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7419         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7420         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7421         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7422         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7423         { } /* end */
7424 };
7425
7426 /*
7427  * 6ch mode
7428  */
7429 static struct hda_verb alc883_3ST_ch6_init[] = {
7430         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7431         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7432         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7433         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7434         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7435         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7436         { } /* end */
7437 };
7438
7439 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7440         { 2, alc883_3ST_ch2_init },
7441         { 4, alc883_3ST_ch4_init },
7442         { 6, alc883_3ST_ch6_init },
7443 };
7444
7445 /*
7446  * 2ch mode
7447  */
7448 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7449         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7450         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7451         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7452         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7453         { } /* end */
7454 };
7455
7456 /*
7457  * 4ch mode
7458  */
7459 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7460         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7461         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7462         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7463         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7464         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7465         { } /* end */
7466 };
7467
7468 /*
7469  * 6ch mode
7470  */
7471 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7472         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7473         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7474         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7475         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7476         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7477         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7478         { } /* end */
7479 };
7480
7481 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7482         { 2, alc883_3ST_ch2_intel_init },
7483         { 4, alc883_3ST_ch4_intel_init },
7484         { 6, alc883_3ST_ch6_intel_init },
7485 };
7486
7487 /*
7488  * 6ch mode
7489  */
7490 static struct hda_verb alc883_sixstack_ch6_init[] = {
7491         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7492         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7493         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7494         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7495         { } /* end */
7496 };
7497
7498 /*
7499  * 8ch mode
7500  */
7501 static struct hda_verb alc883_sixstack_ch8_init[] = {
7502         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7503         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7504         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7505         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7506         { } /* end */
7507 };
7508
7509 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7510         { 6, alc883_sixstack_ch6_init },
7511         { 8, alc883_sixstack_ch8_init },
7512 };
7513
7514 static struct hda_verb alc883_medion_eapd_verbs[] = {
7515         /* eanable EAPD on medion laptop */
7516         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7517         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7518         { }
7519 };
7520
7521 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7522  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7523  */
7524
7525 static struct snd_kcontrol_new alc883_base_mixer[] = {
7526         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7527         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7528         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7529         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7530         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7531         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7532         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7533         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7534         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7535         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7536         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7537         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7538         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7539         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7540         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7541         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7542         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7543         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7544         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7545         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7546         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7547         { } /* end */
7548 };
7549
7550 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7551         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7552         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7553         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7554         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7555         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7556         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7557         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7558         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7559         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7560         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7561         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7562         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7563         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7564         { } /* end */
7565 };
7566
7567 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7568         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7569         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7570         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7571         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7572         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7573         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7574         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7575         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7576         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7577         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7578         { } /* end */
7579 };
7580
7581 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7582         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7583         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7584         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7585         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7586         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7587         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7588         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7589         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7590         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7591         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7592         { } /* end */
7593 };
7594
7595 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7596         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7597         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7598         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7599         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7600         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7601         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7602         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7603         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7604         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7605         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7606         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7607         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7608         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7609         { } /* end */
7610 };
7611
7612 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7613         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7614         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7615         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7616         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7617         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7618         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7619         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7620         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7621         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7622         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7623         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7624         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7625         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7626         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7627         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7628         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7629         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7630         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7631         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7632         { } /* end */
7633 };
7634
7635 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7636         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7637         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7638         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7639         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7640         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7641                               HDA_OUTPUT),
7642         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7643         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7644         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7645         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7646         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7647         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7648         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7649         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7650         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7651         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7652         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7653         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7654         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7655         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7656         { } /* end */
7657 };
7658
7659 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7660         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7661         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7662         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7663         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7664         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7665         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7666         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7667         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7668         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7669         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7670         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7671         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7672         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7673         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7674         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7675         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7676         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7677         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7678         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7679         { } /* end */
7680 };
7681
7682 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7683         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7684         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7685         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7686         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7687         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7688         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7689         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7690         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7691         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7692         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7693         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7694         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7695         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7696         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7697         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7698         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7699         { } /* end */
7700 };
7701
7702 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7703         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7704         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7705         HDA_CODEC_MUTE("Front 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("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7709         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7710         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7711         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7712         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7713         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7714         { } /* end */
7715 };
7716
7717 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7718         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7719         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7720         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7721         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7722         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7723         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7724         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7725         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7726         { } /* end */
7727 };
7728
7729 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7730         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7731         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7732         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7733         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7734         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7735         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7736         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7737         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7738         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7739         { } /* end */
7740 };
7741
7742 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7743         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7744         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7745         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7746         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7747         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7748         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7749         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7750         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7751         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7752         { } /* end */
7753 };
7754
7755 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7756         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7757         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7758         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7759         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7760         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7761         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7762         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7763         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7764         { } /* end */
7765 };
7766
7767 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7768         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7769         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7770         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7771         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7772         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7773                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7774         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7775         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7776         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7777         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7778         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7779         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7780         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7781         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7782         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7783         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7784         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7785         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7786         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7787         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7788         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7789         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7790         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7791         { } /* end */
7792 };
7793
7794 static struct hda_bind_ctls alc883_bind_cap_vol = {
7795         .ops = &snd_hda_bind_vol,
7796         .values = {
7797                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7798                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7799                 0
7800         },
7801 };
7802
7803 static struct hda_bind_ctls alc883_bind_cap_switch = {
7804         .ops = &snd_hda_bind_sw,
7805         .values = {
7806                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7807                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7808                 0
7809         },
7810 };
7811
7812 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7813         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7814         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7815         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7816         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7817         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7818         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7819         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7820         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7821         { } /* end */
7822 };
7823
7824 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7825         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7826         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7827         {
7828                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7829                 /* .name = "Capture Source", */
7830                 .name = "Input Source",
7831                 .count = 1,
7832                 .info = alc_mux_enum_info,
7833                 .get = alc_mux_enum_get,
7834                 .put = alc_mux_enum_put,
7835         },
7836         { } /* end */
7837 };
7838
7839 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7840         {
7841                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7842                 .name = "Channel Mode",
7843                 .info = alc_ch_mode_info,
7844                 .get = alc_ch_mode_get,
7845                 .put = alc_ch_mode_put,
7846         },
7847         { } /* end */
7848 };
7849
7850 static struct hda_verb alc883_init_verbs[] = {
7851         /* ADC1: mute amp left and right */
7852         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7853         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7854         /* ADC2: mute amp left and right */
7855         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7856         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7857         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7858         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7859         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7860         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7861         /* Rear mixer */
7862         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7863         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7864         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7865         /* CLFE mixer */
7866         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7867         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7868         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7869         /* Side mixer */
7870         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7871         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7872         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7873
7874         /* mute analog input loopbacks */
7875         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7876         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7877         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7878         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7879         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7880
7881         /* Front Pin: output 0 (0x0c) */
7882         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7883         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7884         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7885         /* Rear Pin: output 1 (0x0d) */
7886         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7887         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7888         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7889         /* CLFE Pin: output 2 (0x0e) */
7890         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7891         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7892         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7893         /* Side Pin: output 3 (0x0f) */
7894         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7895         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7896         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7897         /* Mic (rear) pin: input vref at 80% */
7898         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7899         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7900         /* Front Mic pin: input vref at 80% */
7901         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7902         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7903         /* Line In pin: input */
7904         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7905         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7906         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7907         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7908         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7909         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7910         /* CD pin widget for input */
7911         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7912
7913         /* FIXME: use matrix-type input source selection */
7914         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7915         /* Input mixer2 */
7916         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7917         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7918         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7919         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7920         /* Input mixer3 */
7921         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7922         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7923         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7924         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7925         { }
7926 };
7927
7928 /* toggle speaker-output according to the hp-jack state */
7929 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7930 {
7931         unsigned int present;
7932
7933         present = snd_hda_codec_read(codec, 0x15, 0,
7934                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7935         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7936                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7937         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7938                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7939 }
7940
7941 /* auto-toggle front mic */
7942 /*
7943 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7944 {
7945         unsigned int present;
7946         unsigned char bits;
7947
7948         present = snd_hda_codec_read(codec, 0x18, 0,
7949                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7950         bits = present ? HDA_AMP_MUTE : 0;
7951         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7952 }
7953 */
7954
7955 static void alc883_mitac_automute(struct hda_codec *codec)
7956 {
7957         alc883_mitac_hp_automute(codec);
7958         /* alc883_mitac_mic_automute(codec); */
7959 }
7960
7961 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7962                                            unsigned int res)
7963 {
7964         switch (res >> 26) {
7965         case ALC880_HP_EVENT:
7966                 alc883_mitac_hp_automute(codec);
7967                 break;
7968         case ALC880_MIC_EVENT:
7969                 /* alc883_mitac_mic_automute(codec); */
7970                 break;
7971         }
7972 }
7973
7974 static struct hda_verb alc883_mitac_verbs[] = {
7975         /* HP */
7976         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7977         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7978         /* Subwoofer */
7979         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7980         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7981
7982         /* enable unsolicited event */
7983         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7984         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7985
7986         { } /* end */
7987 };
7988
7989 static struct hda_verb alc883_clevo_m720_verbs[] = {
7990         /* HP */
7991         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7992         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7993         /* Int speaker */
7994         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7995         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7996
7997         /* enable unsolicited event */
7998         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7999         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8000
8001         { } /* end */
8002 };
8003
8004 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8005         /* HP */
8006         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8007         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8008         /* Subwoofer */
8009         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8010         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8011
8012         /* enable unsolicited event */
8013         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8014
8015         { } /* end */
8016 };
8017
8018 static struct hda_verb alc883_tagra_verbs[] = {
8019         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8020         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8021
8022         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8023         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8024
8025         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8026         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8027         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8028
8029         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8030         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8031         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8032         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8033
8034         { } /* end */
8035 };
8036
8037 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8038         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8039         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8040         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8041         { } /* end */
8042 };
8043
8044 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8045         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8046         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8047         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8048         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8049         { } /* end */
8050 };
8051
8052 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8053         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8054         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8055         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8056         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8057         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8058         { } /* end */
8059 };
8060
8061 static struct hda_verb alc883_haier_w66_verbs[] = {
8062         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8063         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8064
8065         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8066
8067         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8068         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8069         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8070         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8071         { } /* end */
8072 };
8073
8074 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8075         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8076         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8077         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8078         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8079         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8080         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8081         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8082         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8083         { } /* end */
8084 };
8085
8086 static struct hda_verb alc888_6st_dell_verbs[] = {
8087         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8088         { }
8089 };
8090
8091 static void alc888_3st_hp_front_automute(struct hda_codec *codec)
8092 {
8093         unsigned int present, bits;
8094
8095         present = snd_hda_codec_read(codec, 0x1b, 0,
8096                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8097         bits = present ? HDA_AMP_MUTE : 0;
8098         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8099                                  HDA_AMP_MUTE, bits);
8100         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8101                                  HDA_AMP_MUTE, bits);
8102         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
8103                                  HDA_AMP_MUTE, bits);
8104 }
8105
8106 static void alc888_3st_hp_unsol_event(struct hda_codec *codec,
8107                                       unsigned int res)
8108 {
8109         switch (res >> 26) {
8110         case ALC880_HP_EVENT:
8111                 alc888_3st_hp_front_automute(codec);
8112                 break;
8113         }
8114 }
8115
8116 static struct hda_verb alc888_3st_hp_verbs[] = {
8117         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8118         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8119         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8120         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8121         { } /* end */
8122 };
8123
8124 /*
8125  * 2ch mode
8126  */
8127 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8128         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8129         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8130         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8131         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8132         { } /* end */
8133 };
8134
8135 /*
8136  * 4ch mode
8137  */
8138 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8139         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8140         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8141         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8142         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8143         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8144         { } /* end */
8145 };
8146
8147 /*
8148  * 6ch mode
8149  */
8150 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8151         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8152         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8153         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8154         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8155         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8156         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8157         { } /* end */
8158 };
8159
8160 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8161         { 2, alc888_3st_hp_2ch_init },
8162         { 4, alc888_3st_hp_4ch_init },
8163         { 6, alc888_3st_hp_6ch_init },
8164 };
8165
8166 /* toggle front-jack and RCA according to the hp-jack state */
8167 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8168 {
8169         unsigned int present;
8170
8171         present = snd_hda_codec_read(codec, 0x1b, 0,
8172                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8173         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8174                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8175         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8176                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8177 }
8178
8179 /* toggle RCA according to the front-jack state */
8180 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8181 {
8182         unsigned int present;
8183
8184         present = snd_hda_codec_read(codec, 0x14, 0,
8185                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8186         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8187                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8188 }
8189
8190 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8191                                              unsigned int res)
8192 {
8193         if ((res >> 26) == ALC880_HP_EVENT)
8194                 alc888_lenovo_ms7195_front_automute(codec);
8195         if ((res >> 26) == ALC880_FRONT_EVENT)
8196                 alc888_lenovo_ms7195_rca_automute(codec);
8197 }
8198
8199 static struct hda_verb alc883_medion_md2_verbs[] = {
8200         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8201         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8202
8203         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8204
8205         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8206         { } /* end */
8207 };
8208
8209 /* toggle speaker-output according to the hp-jack state */
8210 static void alc883_medion_md2_automute(struct hda_codec *codec)
8211 {
8212         unsigned int present;
8213
8214         present = snd_hda_codec_read(codec, 0x14, 0,
8215                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8216         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8217                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8218 }
8219
8220 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
8221                                           unsigned int res)
8222 {
8223         if ((res >> 26) == ALC880_HP_EVENT)
8224                 alc883_medion_md2_automute(codec);
8225 }
8226
8227 /* toggle speaker-output according to the hp-jack state */
8228 static void alc883_tagra_automute(struct hda_codec *codec)
8229 {
8230         unsigned int present;
8231         unsigned char bits;
8232
8233         present = snd_hda_codec_read(codec, 0x14, 0,
8234                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8235         bits = present ? HDA_AMP_MUTE : 0;
8236         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
8237                                  HDA_AMP_MUTE, bits);
8238         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8239                                   present ? 1 : 3);
8240 }
8241
8242 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
8243 {
8244         if ((res >> 26) == ALC880_HP_EVENT)
8245                 alc883_tagra_automute(codec);
8246 }
8247
8248 /* toggle speaker-output according to the hp-jack state */
8249 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
8250 {
8251         unsigned int present;
8252         unsigned char bits;
8253
8254         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
8255                 & AC_PINSENSE_PRESENCE;
8256         bits = present ? HDA_AMP_MUTE : 0;
8257         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8258                                  HDA_AMP_MUTE, bits);
8259 }
8260
8261 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8262 {
8263         unsigned int present;
8264
8265         present = snd_hda_codec_read(codec, 0x18, 0,
8266                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8267         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8268                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8269 }
8270
8271 static void alc883_clevo_m720_automute(struct hda_codec *codec)
8272 {
8273         alc883_clevo_m720_hp_automute(codec);
8274         alc883_clevo_m720_mic_automute(codec);
8275 }
8276
8277 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8278                                            unsigned int res)
8279 {
8280         switch (res >> 26) {
8281         case ALC880_HP_EVENT:
8282                 alc883_clevo_m720_hp_automute(codec);
8283                 break;
8284         case ALC880_MIC_EVENT:
8285                 alc883_clevo_m720_mic_automute(codec);
8286                 break;
8287         }
8288 }
8289
8290 /* toggle speaker-output according to the hp-jack state */
8291 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8292 {
8293         unsigned int present;
8294         unsigned char bits;
8295
8296         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8297                 & AC_PINSENSE_PRESENCE;
8298         bits = present ? HDA_AMP_MUTE : 0;
8299         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8300                                  HDA_AMP_MUTE, bits);
8301 }
8302
8303 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8304                                                   unsigned int res)
8305 {
8306         if ((res >> 26) == ALC880_HP_EVENT)
8307                 alc883_2ch_fujitsu_pi2515_automute(codec);
8308 }
8309
8310 static void alc883_haier_w66_automute(struct hda_codec *codec)
8311 {
8312         unsigned int present;
8313         unsigned char bits;
8314
8315         present = snd_hda_codec_read(codec, 0x1b, 0,
8316                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8317         bits = present ? 0x80 : 0;
8318         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8319                                  0x80, bits);
8320 }
8321
8322 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8323                                          unsigned int res)
8324 {
8325         if ((res >> 26) == ALC880_HP_EVENT)
8326                 alc883_haier_w66_automute(codec);
8327 }
8328
8329 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8330 {
8331         unsigned int present;
8332         unsigned char bits;
8333
8334         present = snd_hda_codec_read(codec, 0x14, 0,
8335                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8336         bits = present ? HDA_AMP_MUTE : 0;
8337         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8338                                  HDA_AMP_MUTE, bits);
8339 }
8340
8341 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8342 {
8343         unsigned int present;
8344         unsigned char bits;
8345
8346         present = snd_hda_codec_read(codec, 0x1b, 0,
8347                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8348         bits = present ? HDA_AMP_MUTE : 0;
8349         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8350                                  HDA_AMP_MUTE, bits);
8351         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8352                                  HDA_AMP_MUTE, bits);
8353 }
8354
8355 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8356                                            unsigned int res)
8357 {
8358         if ((res >> 26) == ALC880_HP_EVENT)
8359                 alc883_lenovo_101e_all_automute(codec);
8360         if ((res >> 26) == ALC880_FRONT_EVENT)
8361                 alc883_lenovo_101e_ispeaker_automute(codec);
8362 }
8363
8364 /* toggle speaker-output according to the hp-jack state */
8365 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8366 {
8367         unsigned int present;
8368
8369         present = snd_hda_codec_read(codec, 0x14, 0,
8370                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8371         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8372                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8373         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8374                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8375 }
8376
8377 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8378                                            unsigned int res)
8379 {
8380         if ((res >> 26) == ALC880_HP_EVENT)
8381                 alc883_acer_aspire_automute(codec);
8382 }
8383
8384 static struct hda_verb alc883_acer_eapd_verbs[] = {
8385         /* HP Pin: output 0 (0x0c) */
8386         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8387         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8388         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8389         /* Front Pin: output 0 (0x0c) */
8390         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8391         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8392         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8393         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8394         /* eanable EAPD on medion laptop */
8395         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8396         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8397         /* enable unsolicited event */
8398         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8399         { }
8400 };
8401
8402 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8403 {
8404         unsigned int present;
8405
8406         present = snd_hda_codec_read(codec, 0x1b, 0,
8407                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8408         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8409                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8410         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8411                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8412         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8413                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8414         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8415                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8416 }
8417
8418 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8419                                              unsigned int res)
8420 {
8421         switch (res >> 26) {
8422         case ALC880_HP_EVENT:
8423                 /* printk(KERN_DEBUG "hp_event\n"); */
8424                 alc888_6st_dell_front_automute(codec);
8425                 break;
8426         }
8427 }
8428
8429 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8430 {
8431         unsigned int mute;
8432         unsigned int present;
8433
8434         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8435         present = snd_hda_codec_read(codec, 0x1b, 0,
8436                                      AC_VERB_GET_PIN_SENSE, 0);
8437         present = (present & 0x80000000) != 0;
8438         if (present) {
8439                 /* mute internal speaker */
8440                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8441                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8442                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8443                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8444                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8445                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8446                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8447                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8448                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8449                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8450         } else {
8451                 /* unmute internal speaker if necessary */
8452                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8453                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8454                                          HDA_AMP_MUTE, mute);
8455                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8456                                          HDA_AMP_MUTE, mute);
8457                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8458                                          HDA_AMP_MUTE, mute);
8459                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8460                                          HDA_AMP_MUTE, mute);
8461                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8462                                          HDA_AMP_MUTE, mute);
8463         }
8464 }
8465
8466 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8467                                              unsigned int res)
8468 {
8469         if ((res >> 26) == ALC880_HP_EVENT)
8470                 alc888_lenovo_sky_front_automute(codec);
8471 }
8472
8473 /*
8474  * generic initialization of ADC, input mixers and output mixers
8475  */
8476 static struct hda_verb alc883_auto_init_verbs[] = {
8477         /*
8478          * Unmute ADC0-2 and set the default input to mic-in
8479          */
8480         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8481         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8482         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8483         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8484
8485         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8486          * mixer widget
8487          * Note: PASD motherboards uses the Line In 2 as the input for
8488          * front panel mic (mic 2)
8489          */
8490         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8491         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8492         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8493         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8494         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8495         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8496
8497         /*
8498          * Set up output mixers (0x0c - 0x0f)
8499          */
8500         /* set vol=0 to output mixers */
8501         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8502         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8503         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8504         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8505         /* set up input amps for analog loopback */
8506         /* Amp Indices: DAC = 0, mixer = 1 */
8507         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8510         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8511         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8512         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8513         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8514         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8515         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8516         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8517
8518         /* FIXME: use matrix-type input source selection */
8519         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8520         /* Input mixer1 */
8521         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8522         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8523         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8524         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8525         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8526         /* Input mixer2 */
8527         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8528         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8529         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8530         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8531         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8532
8533         { }
8534 };
8535
8536 static struct hda_verb alc888_asus_m90v_verbs[] = {
8537         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8538         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8539         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8540         /* enable unsolicited event */
8541         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8542         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8543         { } /* end */
8544 };
8545
8546 static void alc883_nb_mic_automute(struct hda_codec *codec)
8547 {
8548         unsigned int present;
8549
8550         present = snd_hda_codec_read(codec, 0x18, 0,
8551                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8552         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8553                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8554         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8555                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8556 }
8557
8558 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8559 {
8560         unsigned int present;
8561         unsigned char bits;
8562
8563         present = snd_hda_codec_read(codec, 0x1b, 0,
8564                                      AC_VERB_GET_PIN_SENSE, 0)
8565                 & AC_PINSENSE_PRESENCE;
8566         bits = present ? 0 : PIN_OUT;
8567         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8568                             bits);
8569         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8570                             bits);
8571         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8572                             bits);
8573 }
8574
8575 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8576                                            unsigned int res)
8577 {
8578         switch (res >> 26) {
8579         case ALC880_HP_EVENT:
8580                 alc883_M90V_speaker_automute(codec);
8581                 break;
8582         case ALC880_MIC_EVENT:
8583                 alc883_nb_mic_automute(codec);
8584                 break;
8585         }
8586 }
8587
8588 static void alc883_mode2_inithook(struct hda_codec *codec)
8589 {
8590         alc883_M90V_speaker_automute(codec);
8591         alc883_nb_mic_automute(codec);
8592 }
8593
8594 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8595         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8596         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8597         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8598         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8599         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8600         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8601         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8602         /* enable unsolicited event */
8603         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8604         { } /* end */
8605 };
8606
8607 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8608 {
8609         unsigned int present;
8610         unsigned char bits;
8611
8612         present = snd_hda_codec_read(codec, 0x14, 0,
8613                                      AC_VERB_GET_PIN_SENSE, 0)
8614                 & AC_PINSENSE_PRESENCE;
8615         bits = present ? 0 : PIN_OUT;
8616         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8617                             bits);
8618 }
8619
8620 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8621                                            unsigned int res)
8622 {
8623         switch (res >> 26) {
8624         case ALC880_HP_EVENT:
8625                 alc883_eee1601_speaker_automute(codec);
8626                 break;
8627         }
8628 }
8629
8630 static void alc883_eee1601_inithook(struct hda_codec *codec)
8631 {
8632         alc883_eee1601_speaker_automute(codec);
8633 }
8634
8635 #ifdef CONFIG_SND_HDA_POWER_SAVE
8636 #define alc883_loopbacks        alc880_loopbacks
8637 #endif
8638
8639 /* pcm configuration: identiacal with ALC880 */
8640 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8641 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8642 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8643 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8644 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8645
8646 /*
8647  * configuration and preset
8648  */
8649 static const char *alc883_models[ALC883_MODEL_LAST] = {
8650         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8651         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8652         [ALC883_3ST_6ch]        = "3stack-6ch",
8653         [ALC883_6ST_DIG]        = "6stack-dig",
8654         [ALC883_TARGA_DIG]      = "targa-dig",
8655         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8656         [ALC883_ACER]           = "acer",
8657         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8658         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8659         [ALC883_MEDION]         = "medion",
8660         [ALC883_MEDION_MD2]     = "medion-md2",
8661         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8662         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8663         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8664         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8665         [ALC888_LENOVO_SKY] = "lenovo-sky",
8666         [ALC883_HAIER_W66]      = "haier-w66",
8667         [ALC888_3ST_HP]         = "3stack-hp",
8668         [ALC888_6ST_DELL]       = "6stack-dell",
8669         [ALC883_MITAC]          = "mitac",
8670         [ALC883_CLEVO_M720]     = "clevo-m720",
8671         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8672         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8673         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8674         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8675         [ALC883_AUTO]           = "auto",
8676 };
8677
8678 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8679         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8680         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8681         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8682         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8683         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8684         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8685         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8686         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8687                 ALC888_ACER_ASPIRE_4930G),
8688         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8689                 ALC888_ACER_ASPIRE_4930G),
8690         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8691         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8692         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8693                 ALC888_ACER_ASPIRE_4930G),
8694         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8695                 ALC888_ACER_ASPIRE_4930G),
8696         /* default Acer */
8697         SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
8698         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8699         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8700         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8701         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8702         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8703         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8704         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8705         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8706         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8707         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8708         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8709         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8710         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8711         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8712         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8713         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8714         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8715         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8716         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8717         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8718         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8719         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8720         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8721         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8722         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8723         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8724         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8725         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8726         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8727         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8728         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8729         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8730         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8731         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8732         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8733         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8734         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8735         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8736         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8737         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8738         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8739         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8740         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8741         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8742         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8743         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8744         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8745         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8746         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8747         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8748                       ALC883_FUJITSU_PI2515),
8749         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8750                 ALC888_FUJITSU_XA3530),
8751         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8752         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8753         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8754         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8755         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8756         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8757         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8758         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8759         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8760         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8761         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8762         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8763         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8764         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8765         {}
8766 };
8767
8768 static hda_nid_t alc883_slave_dig_outs[] = {
8769         ALC1200_DIGOUT_NID, 0,
8770 };
8771
8772 static hda_nid_t alc1200_slave_dig_outs[] = {
8773         ALC883_DIGOUT_NID, 0,
8774 };
8775
8776 static struct alc_config_preset alc883_presets[] = {
8777         [ALC883_3ST_2ch_DIG] = {
8778                 .mixers = { alc883_3ST_2ch_mixer },
8779                 .init_verbs = { alc883_init_verbs },
8780                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8781                 .dac_nids = alc883_dac_nids,
8782                 .dig_out_nid = ALC883_DIGOUT_NID,
8783                 .dig_in_nid = ALC883_DIGIN_NID,
8784                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8785                 .channel_mode = alc883_3ST_2ch_modes,
8786                 .input_mux = &alc883_capture_source,
8787         },
8788         [ALC883_3ST_6ch_DIG] = {
8789                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8790                 .init_verbs = { alc883_init_verbs },
8791                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8792                 .dac_nids = alc883_dac_nids,
8793                 .dig_out_nid = ALC883_DIGOUT_NID,
8794                 .dig_in_nid = ALC883_DIGIN_NID,
8795                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8796                 .channel_mode = alc883_3ST_6ch_modes,
8797                 .need_dac_fix = 1,
8798                 .input_mux = &alc883_capture_source,
8799         },
8800         [ALC883_3ST_6ch] = {
8801                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8802                 .init_verbs = { alc883_init_verbs },
8803                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8804                 .dac_nids = alc883_dac_nids,
8805                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8806                 .channel_mode = alc883_3ST_6ch_modes,
8807                 .need_dac_fix = 1,
8808                 .input_mux = &alc883_capture_source,
8809         },
8810         [ALC883_3ST_6ch_INTEL] = {
8811                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8812                 .init_verbs = { alc883_init_verbs },
8813                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8814                 .dac_nids = alc883_dac_nids,
8815                 .dig_out_nid = ALC883_DIGOUT_NID,
8816                 .dig_in_nid = ALC883_DIGIN_NID,
8817                 .slave_dig_outs = alc883_slave_dig_outs,
8818                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8819                 .channel_mode = alc883_3ST_6ch_intel_modes,
8820                 .need_dac_fix = 1,
8821                 .input_mux = &alc883_3stack_6ch_intel,
8822         },
8823         [ALC883_6ST_DIG] = {
8824                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8825                 .init_verbs = { alc883_init_verbs },
8826                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8827                 .dac_nids = alc883_dac_nids,
8828                 .dig_out_nid = ALC883_DIGOUT_NID,
8829                 .dig_in_nid = ALC883_DIGIN_NID,
8830                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8831                 .channel_mode = alc883_sixstack_modes,
8832                 .input_mux = &alc883_capture_source,
8833         },
8834         [ALC883_TARGA_DIG] = {
8835                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8836                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8837                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8838                 .dac_nids = alc883_dac_nids,
8839                 .dig_out_nid = ALC883_DIGOUT_NID,
8840                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8841                 .channel_mode = alc883_3ST_6ch_modes,
8842                 .need_dac_fix = 1,
8843                 .input_mux = &alc883_capture_source,
8844                 .unsol_event = alc883_tagra_unsol_event,
8845                 .init_hook = alc883_tagra_automute,
8846         },
8847         [ALC883_TARGA_2ch_DIG] = {
8848                 .mixers = { alc883_tagra_2ch_mixer},
8849                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8850                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8851                 .dac_nids = alc883_dac_nids,
8852                 .adc_nids = alc883_adc_nids_alt,
8853                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8854                 .dig_out_nid = ALC883_DIGOUT_NID,
8855                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8856                 .channel_mode = alc883_3ST_2ch_modes,
8857                 .input_mux = &alc883_capture_source,
8858                 .unsol_event = alc883_tagra_unsol_event,
8859                 .init_hook = alc883_tagra_automute,
8860         },
8861         [ALC883_ACER] = {
8862                 .mixers = { alc883_base_mixer },
8863                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8864                  * and the headphone jack.  Turn this on and rely on the
8865                  * standard mute methods whenever the user wants to turn
8866                  * these outputs off.
8867                  */
8868                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8869                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8870                 .dac_nids = alc883_dac_nids,
8871                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8872                 .channel_mode = alc883_3ST_2ch_modes,
8873                 .input_mux = &alc883_capture_source,
8874         },
8875         [ALC883_ACER_ASPIRE] = {
8876                 .mixers = { alc883_acer_aspire_mixer },
8877                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8878                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8879                 .dac_nids = alc883_dac_nids,
8880                 .dig_out_nid = ALC883_DIGOUT_NID,
8881                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8882                 .channel_mode = alc883_3ST_2ch_modes,
8883                 .input_mux = &alc883_capture_source,
8884                 .unsol_event = alc883_acer_aspire_unsol_event,
8885                 .init_hook = alc883_acer_aspire_automute,
8886         },
8887         [ALC888_ACER_ASPIRE_4930G] = {
8888                 .mixers = { alc888_base_mixer,
8889                                 alc883_chmode_mixer },
8890                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8891                                 alc888_acer_aspire_4930g_verbs },
8892                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8893                 .dac_nids = alc883_dac_nids,
8894                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8895                 .adc_nids = alc883_adc_nids_rev,
8896                 .capsrc_nids = alc883_capsrc_nids_rev,
8897                 .dig_out_nid = ALC883_DIGOUT_NID,
8898                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8899                 .channel_mode = alc883_3ST_6ch_modes,
8900                 .need_dac_fix = 1,
8901                 .num_mux_defs =
8902                         ARRAY_SIZE(alc888_2_capture_sources),
8903                 .input_mux = alc888_2_capture_sources,
8904                 .unsol_event = alc888_acer_aspire_4930g_unsol_event,
8905                 .init_hook = alc888_acer_aspire_4930g_automute,
8906         },
8907         [ALC883_MEDION] = {
8908                 .mixers = { alc883_fivestack_mixer,
8909                             alc883_chmode_mixer },
8910                 .init_verbs = { alc883_init_verbs,
8911                                 alc883_medion_eapd_verbs },
8912                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8913                 .dac_nids = alc883_dac_nids,
8914                 .adc_nids = alc883_adc_nids_alt,
8915                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8916                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8917                 .channel_mode = alc883_sixstack_modes,
8918                 .input_mux = &alc883_capture_source,
8919         },
8920         [ALC883_MEDION_MD2] = {
8921                 .mixers = { alc883_medion_md2_mixer},
8922                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8923                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8924                 .dac_nids = alc883_dac_nids,
8925                 .dig_out_nid = ALC883_DIGOUT_NID,
8926                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8927                 .channel_mode = alc883_3ST_2ch_modes,
8928                 .input_mux = &alc883_capture_source,
8929                 .unsol_event = alc883_medion_md2_unsol_event,
8930                 .init_hook = alc883_medion_md2_automute,
8931         },
8932         [ALC883_LAPTOP_EAPD] = {
8933                 .mixers = { alc883_base_mixer },
8934                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8935                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8936                 .dac_nids = alc883_dac_nids,
8937                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8938                 .channel_mode = alc883_3ST_2ch_modes,
8939                 .input_mux = &alc883_capture_source,
8940         },
8941         [ALC883_CLEVO_M720] = {
8942                 .mixers = { alc883_clevo_m720_mixer },
8943                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8944                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8945                 .dac_nids = alc883_dac_nids,
8946                 .dig_out_nid = ALC883_DIGOUT_NID,
8947                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8948                 .channel_mode = alc883_3ST_2ch_modes,
8949                 .input_mux = &alc883_capture_source,
8950                 .unsol_event = alc883_clevo_m720_unsol_event,
8951                 .init_hook = alc883_clevo_m720_automute,
8952         },
8953         [ALC883_LENOVO_101E_2ch] = {
8954                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8955                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8956                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8957                 .dac_nids = alc883_dac_nids,
8958                 .adc_nids = alc883_adc_nids_alt,
8959                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8960                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8961                 .channel_mode = alc883_3ST_2ch_modes,
8962                 .input_mux = &alc883_lenovo_101e_capture_source,
8963                 .unsol_event = alc883_lenovo_101e_unsol_event,
8964                 .init_hook = alc883_lenovo_101e_all_automute,
8965         },
8966         [ALC883_LENOVO_NB0763] = {
8967                 .mixers = { alc883_lenovo_nb0763_mixer },
8968                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8969                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8970                 .dac_nids = alc883_dac_nids,
8971                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8972                 .channel_mode = alc883_3ST_2ch_modes,
8973                 .need_dac_fix = 1,
8974                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8975                 .unsol_event = alc883_medion_md2_unsol_event,
8976                 .init_hook = alc883_medion_md2_automute,
8977         },
8978         [ALC888_LENOVO_MS7195_DIG] = {
8979                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8980                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8981                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8982                 .dac_nids = alc883_dac_nids,
8983                 .dig_out_nid = ALC883_DIGOUT_NID,
8984                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8985                 .channel_mode = alc883_3ST_6ch_modes,
8986                 .need_dac_fix = 1,
8987                 .input_mux = &alc883_capture_source,
8988                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8989                 .init_hook = alc888_lenovo_ms7195_front_automute,
8990         },
8991         [ALC883_HAIER_W66] = {
8992                 .mixers = { alc883_tagra_2ch_mixer},
8993                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8994                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8995                 .dac_nids = alc883_dac_nids,
8996                 .dig_out_nid = ALC883_DIGOUT_NID,
8997                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8998                 .channel_mode = alc883_3ST_2ch_modes,
8999                 .input_mux = &alc883_capture_source,
9000                 .unsol_event = alc883_haier_w66_unsol_event,
9001                 .init_hook = alc883_haier_w66_automute,
9002         },
9003         [ALC888_3ST_HP] = {
9004                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9005                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9006                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9007                 .dac_nids = alc883_dac_nids,
9008                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9009                 .channel_mode = alc888_3st_hp_modes,
9010                 .need_dac_fix = 1,
9011                 .input_mux = &alc883_capture_source,
9012                 .unsol_event = alc888_3st_hp_unsol_event,
9013                 .init_hook = alc888_3st_hp_front_automute,
9014         },
9015         [ALC888_6ST_DELL] = {
9016                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9017                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9018                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9019                 .dac_nids = alc883_dac_nids,
9020                 .dig_out_nid = ALC883_DIGOUT_NID,
9021                 .dig_in_nid = ALC883_DIGIN_NID,
9022                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9023                 .channel_mode = alc883_sixstack_modes,
9024                 .input_mux = &alc883_capture_source,
9025                 .unsol_event = alc888_6st_dell_unsol_event,
9026                 .init_hook = alc888_6st_dell_front_automute,
9027         },
9028         [ALC883_MITAC] = {
9029                 .mixers = { alc883_mitac_mixer },
9030                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9031                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9032                 .dac_nids = alc883_dac_nids,
9033                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9034                 .channel_mode = alc883_3ST_2ch_modes,
9035                 .input_mux = &alc883_capture_source,
9036                 .unsol_event = alc883_mitac_unsol_event,
9037                 .init_hook = alc883_mitac_automute,
9038         },
9039         [ALC883_FUJITSU_PI2515] = {
9040                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9041                 .init_verbs = { alc883_init_verbs,
9042                                 alc883_2ch_fujitsu_pi2515_verbs},
9043                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9044                 .dac_nids = alc883_dac_nids,
9045                 .dig_out_nid = ALC883_DIGOUT_NID,
9046                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9047                 .channel_mode = alc883_3ST_2ch_modes,
9048                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9049                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
9050                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
9051         },
9052         [ALC888_FUJITSU_XA3530] = {
9053                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9054                 .init_verbs = { alc883_init_verbs,
9055                         alc888_fujitsu_xa3530_verbs },
9056                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9057                 .dac_nids = alc883_dac_nids,
9058                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9059                 .adc_nids = alc883_adc_nids_rev,
9060                 .capsrc_nids = alc883_capsrc_nids_rev,
9061                 .dig_out_nid = ALC883_DIGOUT_NID,
9062                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9063                 .channel_mode = alc888_4ST_8ch_intel_modes,
9064                 .num_mux_defs =
9065                         ARRAY_SIZE(alc888_2_capture_sources),
9066                 .input_mux = alc888_2_capture_sources,
9067                 .unsol_event = alc888_fujitsu_xa3530_unsol_event,
9068                 .init_hook = alc888_fujitsu_xa3530_automute,
9069         },
9070         [ALC888_LENOVO_SKY] = {
9071                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9072                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9073                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9074                 .dac_nids = alc883_dac_nids,
9075                 .dig_out_nid = ALC883_DIGOUT_NID,
9076                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9077                 .channel_mode = alc883_sixstack_modes,
9078                 .need_dac_fix = 1,
9079                 .input_mux = &alc883_lenovo_sky_capture_source,
9080                 .unsol_event = alc883_lenovo_sky_unsol_event,
9081                 .init_hook = alc888_lenovo_sky_front_automute,
9082         },
9083         [ALC888_ASUS_M90V] = {
9084                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9085                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9086                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9087                 .dac_nids = alc883_dac_nids,
9088                 .dig_out_nid = ALC883_DIGOUT_NID,
9089                 .dig_in_nid = ALC883_DIGIN_NID,
9090                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9091                 .channel_mode = alc883_3ST_6ch_modes,
9092                 .need_dac_fix = 1,
9093                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9094                 .unsol_event = alc883_mode2_unsol_event,
9095                 .init_hook = alc883_mode2_inithook,
9096         },
9097         [ALC888_ASUS_EEE1601] = {
9098                 .mixers = { alc883_asus_eee1601_mixer },
9099                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9100                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9101                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9102                 .dac_nids = alc883_dac_nids,
9103                 .dig_out_nid = ALC883_DIGOUT_NID,
9104                 .dig_in_nid = ALC883_DIGIN_NID,
9105                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9106                 .channel_mode = alc883_3ST_2ch_modes,
9107                 .need_dac_fix = 1,
9108                 .input_mux = &alc883_asus_eee1601_capture_source,
9109                 .unsol_event = alc883_eee1601_unsol_event,
9110                 .init_hook = alc883_eee1601_inithook,
9111         },
9112         [ALC1200_ASUS_P5Q] = {
9113                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9114                 .init_verbs = { alc883_init_verbs },
9115                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9116                 .dac_nids = alc883_dac_nids,
9117                 .dig_out_nid = ALC1200_DIGOUT_NID,
9118                 .dig_in_nid = ALC883_DIGIN_NID,
9119                 .slave_dig_outs = alc1200_slave_dig_outs,
9120                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9121                 .channel_mode = alc883_sixstack_modes,
9122                 .input_mux = &alc883_capture_source,
9123         },
9124 };
9125
9126
9127 /*
9128  * BIOS auto configuration
9129  */
9130 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9131                                               hda_nid_t nid, int pin_type,
9132                                               int dac_idx)
9133 {
9134         /* set as output */
9135         struct alc_spec *spec = codec->spec;
9136         int idx;
9137
9138         alc_set_pin_output(codec, nid, pin_type);
9139         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9140                 idx = 4;
9141         else
9142                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9143         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9144
9145 }
9146
9147 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9148 {
9149         struct alc_spec *spec = codec->spec;
9150         int i;
9151
9152         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
9153         for (i = 0; i <= HDA_SIDE; i++) {
9154                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9155                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9156                 if (nid)
9157                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9158                                                           i);
9159         }
9160 }
9161
9162 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9163 {
9164         struct alc_spec *spec = codec->spec;
9165         hda_nid_t pin;
9166
9167         pin = spec->autocfg.hp_pins[0];
9168         if (pin) /* connect to front */
9169                 /* use dac 0 */
9170                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9171         pin = spec->autocfg.speaker_pins[0];
9172         if (pin)
9173                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9174 }
9175
9176 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
9177 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
9178
9179 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9180 {
9181         struct alc_spec *spec = codec->spec;
9182         int i;
9183
9184         for (i = 0; i < AUTO_PIN_LAST; i++) {
9185                 hda_nid_t nid = spec->autocfg.input_pins[i];
9186                 if (alc883_is_input_pin(nid)) {
9187                         alc_set_input_pin(codec, nid, i);
9188                         if (nid != ALC883_PIN_CD_NID &&
9189                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
9190                                 snd_hda_codec_write(codec, nid, 0,
9191                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9192                                                     AMP_OUT_MUTE);
9193                 }
9194         }
9195 }
9196
9197 #define alc883_auto_init_input_src      alc882_auto_init_input_src
9198
9199 /* almost identical with ALC880 parser... */
9200 static int alc883_parse_auto_config(struct hda_codec *codec)
9201 {
9202         struct alc_spec *spec = codec->spec;
9203         int err = alc880_parse_auto_config(codec);
9204         struct auto_pin_cfg *cfg = &spec->autocfg;
9205         int i;
9206
9207         if (err < 0)
9208                 return err;
9209         else if (!err)
9210                 return 0; /* no config found */
9211
9212         err = alc_auto_add_mic_boost(codec);
9213         if (err < 0)
9214                 return err;
9215
9216         /* hack - override the init verbs */
9217         spec->init_verbs[0] = alc883_auto_init_verbs;
9218
9219         /* setup input_mux for ALC889 */
9220         if (codec->vendor_id == 0x10ec0889) {
9221                 /* digital-mic input pin is excluded in alc880_auto_create..()
9222                  * because it's under 0x18
9223                  */
9224                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9225                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9226                         struct hda_input_mux *imux = &spec->private_imux[0];
9227                         for (i = 1; i < 3; i++)
9228                                 memcpy(&spec->private_imux[i],
9229                                        &spec->private_imux[0],
9230                                        sizeof(spec->private_imux[0]));
9231                         imux->items[imux->num_items].label = "Int DMic";
9232                         imux->items[imux->num_items].index = 0x0b;
9233                         imux->num_items++;
9234                         spec->num_mux_defs = 3;
9235                         spec->input_mux = spec->private_imux;
9236                 }
9237         }
9238
9239         return 1; /* config found */
9240 }
9241
9242 /* additional initialization for auto-configuration model */
9243 static void alc883_auto_init(struct hda_codec *codec)
9244 {
9245         struct alc_spec *spec = codec->spec;
9246         alc883_auto_init_multi_out(codec);
9247         alc883_auto_init_hp_out(codec);
9248         alc883_auto_init_analog_input(codec);
9249         alc883_auto_init_input_src(codec);
9250         if (spec->unsol_event)
9251                 alc_inithook(codec);
9252 }
9253
9254 static int patch_alc883(struct hda_codec *codec)
9255 {
9256         struct alc_spec *spec;
9257         int err, board_config;
9258
9259         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9260         if (spec == NULL)
9261                 return -ENOMEM;
9262
9263         codec->spec = spec;
9264
9265         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9266
9267         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9268                                                   alc883_models,
9269                                                   alc883_cfg_tbl);
9270         if (board_config < 0) {
9271                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9272                        "trying auto-probe from BIOS...\n");
9273                 board_config = ALC883_AUTO;
9274         }
9275
9276         if (board_config == ALC883_AUTO) {
9277                 /* automatic parse from the BIOS config */
9278                 err = alc883_parse_auto_config(codec);
9279                 if (err < 0) {
9280                         alc_free(codec);
9281                         return err;
9282                 } else if (!err) {
9283                         printk(KERN_INFO
9284                                "hda_codec: Cannot set up configuration "
9285                                "from BIOS.  Using base mode...\n");
9286                         board_config = ALC883_3ST_2ch_DIG;
9287                 }
9288         }
9289
9290         err = snd_hda_attach_beep_device(codec, 0x1);
9291         if (err < 0) {
9292                 alc_free(codec);
9293                 return err;
9294         }
9295
9296         if (board_config != ALC883_AUTO)
9297                 setup_preset(spec, &alc883_presets[board_config]);
9298
9299         switch (codec->vendor_id) {
9300         case 0x10ec0888:
9301                 if (codec->revision_id == 0x100101) {
9302                         spec->stream_name_analog = "ALC1200 Analog";
9303                         spec->stream_name_digital = "ALC1200 Digital";
9304                 } else {
9305                         spec->stream_name_analog = "ALC888 Analog";
9306                         spec->stream_name_digital = "ALC888 Digital";
9307                 }
9308                 if (!spec->num_adc_nids) {
9309                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9310                         spec->adc_nids = alc883_adc_nids;
9311                 }
9312                 if (!spec->capsrc_nids)
9313                         spec->capsrc_nids = alc883_capsrc_nids;
9314                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9315                 break;
9316         case 0x10ec0889:
9317                 spec->stream_name_analog = "ALC889 Analog";
9318                 spec->stream_name_digital = "ALC889 Digital";
9319                 if (!spec->num_adc_nids) {
9320                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9321                         spec->adc_nids = alc889_adc_nids;
9322                 }
9323                 if (!spec->capsrc_nids)
9324                         spec->capsrc_nids = alc889_capsrc_nids;
9325                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9326                                                         capture */
9327                 break;
9328         default:
9329                 spec->stream_name_analog = "ALC883 Analog";
9330                 spec->stream_name_digital = "ALC883 Digital";
9331                 if (!spec->num_adc_nids) {
9332                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9333                         spec->adc_nids = alc883_adc_nids;
9334                 }
9335                 if (!spec->capsrc_nids)
9336                         spec->capsrc_nids = alc883_capsrc_nids;
9337                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9338                 break;
9339         }
9340
9341         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9342         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9343         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9344
9345         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9346         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9347
9348         if (!spec->cap_mixer)
9349                 set_capture_mixer(spec);
9350         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9351
9352         spec->vmaster_nid = 0x0c;
9353
9354         codec->patch_ops = alc_patch_ops;
9355         if (board_config == ALC883_AUTO)
9356                 spec->init_hook = alc883_auto_init;
9357
9358 #ifdef CONFIG_SND_HDA_POWER_SAVE
9359         if (!spec->loopback.amplist)
9360                 spec->loopback.amplist = alc883_loopbacks;
9361 #endif
9362         codec->proc_widget_hook = print_realtek_coef;
9363
9364         return 0;
9365 }
9366
9367 /*
9368  * ALC262 support
9369  */
9370
9371 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9372 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9373
9374 #define alc262_dac_nids         alc260_dac_nids
9375 #define alc262_adc_nids         alc882_adc_nids
9376 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9377 #define alc262_capsrc_nids      alc882_capsrc_nids
9378 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9379
9380 #define alc262_modes            alc260_modes
9381 #define alc262_capture_source   alc882_capture_source
9382
9383 static hda_nid_t alc262_dmic_adc_nids[1] = {
9384         /* ADC0 */
9385         0x09
9386 };
9387
9388 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9389
9390 static struct snd_kcontrol_new alc262_base_mixer[] = {
9391         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9392         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9393         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9394         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9395         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9396         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9397         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9398         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9399         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9400         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9401         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9402         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9403         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9404         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9405         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9406         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9407         { } /* end */
9408 };
9409
9410 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9411         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9412         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9413         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9414         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9415         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9416         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9417         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9418         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9419         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9420         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9421         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9422         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9423         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9424         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9425         { } /* end */
9426 };
9427
9428 /* update HP, line and mono-out pins according to the master switch */
9429 static void alc262_hp_master_update(struct hda_codec *codec)
9430 {
9431         struct alc_spec *spec = codec->spec;
9432         int val = spec->master_sw;
9433
9434         /* HP & line-out */
9435         snd_hda_codec_write_cache(codec, 0x1b, 0,
9436                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9437                                   val ? PIN_HP : 0);
9438         snd_hda_codec_write_cache(codec, 0x15, 0,
9439                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9440                                   val ? PIN_HP : 0);
9441         /* mono (speaker) depending on the HP jack sense */
9442         val = val && !spec->jack_present;
9443         snd_hda_codec_write_cache(codec, 0x16, 0,
9444                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9445                                   val ? PIN_OUT : 0);
9446 }
9447
9448 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9449 {
9450         struct alc_spec *spec = codec->spec;
9451         unsigned int presence;
9452         presence = snd_hda_codec_read(codec, 0x1b, 0,
9453                                       AC_VERB_GET_PIN_SENSE, 0);
9454         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9455         alc262_hp_master_update(codec);
9456 }
9457
9458 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9459 {
9460         if ((res >> 26) != ALC880_HP_EVENT)
9461                 return;
9462         alc262_hp_bpc_automute(codec);
9463 }
9464
9465 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9466 {
9467         struct alc_spec *spec = codec->spec;
9468         unsigned int presence;
9469         presence = snd_hda_codec_read(codec, 0x15, 0,
9470                                       AC_VERB_GET_PIN_SENSE, 0);
9471         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9472         alc262_hp_master_update(codec);
9473 }
9474
9475 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9476                                            unsigned int res)
9477 {
9478         if ((res >> 26) != ALC880_HP_EVENT)
9479                 return;
9480         alc262_hp_wildwest_automute(codec);
9481 }
9482
9483 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9484                                    struct snd_ctl_elem_value *ucontrol)
9485 {
9486         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9487         struct alc_spec *spec = codec->spec;
9488         *ucontrol->value.integer.value = spec->master_sw;
9489         return 0;
9490 }
9491
9492 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9493                                    struct snd_ctl_elem_value *ucontrol)
9494 {
9495         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9496         struct alc_spec *spec = codec->spec;
9497         int val = !!*ucontrol->value.integer.value;
9498
9499         if (val == spec->master_sw)
9500                 return 0;
9501         spec->master_sw = val;
9502         alc262_hp_master_update(codec);
9503         return 1;
9504 }
9505
9506 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9507         {
9508                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9509                 .name = "Master Playback Switch",
9510                 .info = snd_ctl_boolean_mono_info,
9511                 .get = alc262_hp_master_sw_get,
9512                 .put = alc262_hp_master_sw_put,
9513         },
9514         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9515         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9516         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9517         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9518                               HDA_OUTPUT),
9519         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9520                             HDA_OUTPUT),
9521         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9522         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9523         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9524         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9525         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9526         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9527         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9528         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9529         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9530         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9531         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9532         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9533         { } /* end */
9534 };
9535
9536 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9537         {
9538                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9539                 .name = "Master Playback Switch",
9540                 .info = snd_ctl_boolean_mono_info,
9541                 .get = alc262_hp_master_sw_get,
9542                 .put = alc262_hp_master_sw_put,
9543         },
9544         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9545         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9546         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9547         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9548         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9549                               HDA_OUTPUT),
9550         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9551                             HDA_OUTPUT),
9552         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9553         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9554         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9555         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9556         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9557         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9558         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9559         { } /* end */
9560 };
9561
9562 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9563         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9564         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9565         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9566         { } /* end */
9567 };
9568
9569 /* mute/unmute internal speaker according to the hp jack and mute state */
9570 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9571 {
9572         struct alc_spec *spec = codec->spec;
9573
9574         if (force || !spec->sense_updated) {
9575                 unsigned int present;
9576                 present = snd_hda_codec_read(codec, 0x15, 0,
9577                                              AC_VERB_GET_PIN_SENSE, 0);
9578                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9579                 spec->sense_updated = 1;
9580         }
9581         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9582                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9583 }
9584
9585 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9586                                         unsigned int res)
9587 {
9588         if ((res >> 26) != ALC880_HP_EVENT)
9589                 return;
9590         alc262_hp_t5735_automute(codec, 1);
9591 }
9592
9593 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9594 {
9595         alc262_hp_t5735_automute(codec, 1);
9596 }
9597
9598 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9599         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9600         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9601         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9602         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9603         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9604         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9605         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9606         { } /* end */
9607 };
9608
9609 static struct hda_verb alc262_hp_t5735_verbs[] = {
9610         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9611         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9612
9613         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9614         { }
9615 };
9616
9617 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9618         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9619         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9620         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9621         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9622         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9623         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9624         { } /* end */
9625 };
9626
9627 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9628         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9629         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9630         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9631         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9632         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9633         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9634         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9635         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9636         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9637         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9638         {}
9639 };
9640
9641 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9642         .num_items = 1,
9643         .items = {
9644                 { "Line", 0x1 },
9645         },
9646 };
9647
9648 /* bind hp and internal speaker mute (with plug check) */
9649 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9650                                      struct snd_ctl_elem_value *ucontrol)
9651 {
9652         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9653         long *valp = ucontrol->value.integer.value;
9654         int change;
9655
9656         /* change hp mute */
9657         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9658                                           HDA_AMP_MUTE,
9659                                           valp[0] ? 0 : HDA_AMP_MUTE);
9660         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9661                                            HDA_AMP_MUTE,
9662                                            valp[1] ? 0 : HDA_AMP_MUTE);
9663         if (change) {
9664                 /* change speaker according to HP jack state */
9665                 struct alc_spec *spec = codec->spec;
9666                 unsigned int mute;
9667                 if (spec->jack_present)
9668                         mute = HDA_AMP_MUTE;
9669                 else
9670                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9671                                                       HDA_OUTPUT, 0);
9672                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9673                                          HDA_AMP_MUTE, mute);
9674         }
9675         return change;
9676 }
9677
9678 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9679         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9680         {
9681                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9682                 .name = "Master Playback Switch",
9683                 .info = snd_hda_mixer_amp_switch_info,
9684                 .get = snd_hda_mixer_amp_switch_get,
9685                 .put = alc262_sony_master_sw_put,
9686                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9687         },
9688         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9689         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9690         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9691         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9692         { } /* end */
9693 };
9694
9695 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9696         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9697         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9698         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9699         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9700         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9701         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9702         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9703         { } /* end */
9704 };
9705
9706 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9707         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9708         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9709         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9710         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9711         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9712         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9713         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9714         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9715         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9716         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9717         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9718         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9719         { } /* end */
9720 };
9721
9722 static struct hda_verb alc262_tyan_verbs[] = {
9723         /* Headphone automute */
9724         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9725         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9726         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9727
9728         /* P11 AUX_IN, white 4-pin connector */
9729         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9730         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9731         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9732         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9733
9734         {}
9735 };
9736
9737 /* unsolicited event for HP jack sensing */
9738 static void alc262_tyan_automute(struct hda_codec *codec)
9739 {
9740         unsigned int mute;
9741         unsigned int present;
9742
9743         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9744         present = snd_hda_codec_read(codec, 0x1b, 0,
9745                                      AC_VERB_GET_PIN_SENSE, 0);
9746         present = (present & 0x80000000) != 0;
9747         if (present) {
9748                 /* mute line output on ATX panel */
9749                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9750                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9751         } else {
9752                 /* unmute line output if necessary */
9753                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9754                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9755                                          HDA_AMP_MUTE, mute);
9756         }
9757 }
9758
9759 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9760                                        unsigned int res)
9761 {
9762         if ((res >> 26) != ALC880_HP_EVENT)
9763                 return;
9764         alc262_tyan_automute(codec);
9765 }
9766
9767 #define alc262_capture_mixer            alc882_capture_mixer
9768 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9769
9770 /*
9771  * generic initialization of ADC, input mixers and output mixers
9772  */
9773 static struct hda_verb alc262_init_verbs[] = {
9774         /*
9775          * Unmute ADC0-2 and set the default input to mic-in
9776          */
9777         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9778         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9779         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9780         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9781         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9782         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9783
9784         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9785          * mixer widget
9786          * Note: PASD motherboards uses the Line In 2 as the input for
9787          * front panel mic (mic 2)
9788          */
9789         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9790         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9791         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9792         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9793         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9794         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9795
9796         /*
9797          * Set up output mixers (0x0c - 0x0e)
9798          */
9799         /* set vol=0 to output mixers */
9800         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9801         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9802         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9803         /* set up input amps for analog loopback */
9804         /* Amp Indices: DAC = 0, mixer = 1 */
9805         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9806         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9807         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9808         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9809         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9810         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9811
9812         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9813         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9814         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9815         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9816         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9817         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9818
9819         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9820         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9821         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9822         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9823         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9824
9825         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9826         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9827
9828         /* FIXME: use matrix-type input source selection */
9829         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9830         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9831         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9832         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9833         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9834         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9835         /* Input mixer2 */
9836         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9837         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9838         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9839         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9840         /* Input mixer3 */
9841         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9842         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9843         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9844         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9845
9846         { }
9847 };
9848
9849 static struct hda_verb alc262_eapd_verbs[] = {
9850         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9851         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9852         { }
9853 };
9854
9855 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9856         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9857         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9858         {}
9859 };
9860
9861 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9862         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9863         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9864         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9865
9866         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9867         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9868         {}
9869 };
9870
9871 static struct hda_verb alc262_sony_unsol_verbs[] = {
9872         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9873         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9874         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9875
9876         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9877         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9878         {}
9879 };
9880
9881 static struct hda_input_mux alc262_dmic_capture_source = {
9882         .num_items = 2,
9883         .items = {
9884                 { "Int DMic", 0x9 },
9885                 { "Mic", 0x0 },
9886         },
9887 };
9888
9889 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9890         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9891         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9892         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9893         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9894         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9895         { } /* end */
9896 };
9897
9898 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9899         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9900         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9901         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9902         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9903         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9904         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9905         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9906         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9907         {}
9908 };
9909
9910 static void alc262_dmic_automute(struct hda_codec *codec)
9911 {
9912         unsigned int present;
9913
9914         present = snd_hda_codec_read(codec, 0x18, 0,
9915                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9916         snd_hda_codec_write(codec, 0x22, 0,
9917                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9918 }
9919
9920 /* toggle speaker-output according to the hp-jack state */
9921 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9922 {
9923         unsigned int present;
9924         unsigned char bits;
9925
9926         present = snd_hda_codec_read(codec, 0x15, 0,
9927                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9928         bits = present ? 0 : PIN_OUT;
9929         snd_hda_codec_write(codec, 0x14, 0,
9930                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9931 }
9932
9933
9934
9935 /* unsolicited event for HP jack sensing */
9936 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9937                                        unsigned int res)
9938 {
9939         if ((res >> 26) == ALC880_HP_EVENT)
9940                 alc262_toshiba_s06_speaker_automute(codec);
9941         if ((res >> 26) == ALC880_MIC_EVENT)
9942                 alc262_dmic_automute(codec);
9943
9944 }
9945
9946 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9947 {
9948         alc262_toshiba_s06_speaker_automute(codec);
9949         alc262_dmic_automute(codec);
9950 }
9951
9952 /* mute/unmute internal speaker according to the hp jack and mute state */
9953 static void alc262_hippo_automute(struct hda_codec *codec)
9954 {
9955         struct alc_spec *spec = codec->spec;
9956         unsigned int mute;
9957         unsigned int present;
9958
9959         /* need to execute and sync at first */
9960         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9961         present = snd_hda_codec_read(codec, 0x15, 0,
9962                                      AC_VERB_GET_PIN_SENSE, 0);
9963         spec->jack_present = (present & 0x80000000) != 0;
9964         if (spec->jack_present) {
9965                 /* mute internal speaker */
9966                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9967                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9968         } else {
9969                 /* unmute internal speaker if necessary */
9970                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9971                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9972                                          HDA_AMP_MUTE, mute);
9973         }
9974 }
9975
9976 /* unsolicited event for HP jack sensing */
9977 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9978                                        unsigned int res)
9979 {
9980         if ((res >> 26) != ALC880_HP_EVENT)
9981                 return;
9982         alc262_hippo_automute(codec);
9983 }
9984
9985 static void alc262_hippo1_automute(struct hda_codec *codec)
9986 {
9987         unsigned int mute;
9988         unsigned int present;
9989
9990         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9991         present = snd_hda_codec_read(codec, 0x1b, 0,
9992                                      AC_VERB_GET_PIN_SENSE, 0);
9993         present = (present & 0x80000000) != 0;
9994         if (present) {
9995                 /* mute internal speaker */
9996                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9997                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9998         } else {
9999                 /* unmute internal speaker if necessary */
10000                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10001                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10002                                          HDA_AMP_MUTE, mute);
10003         }
10004 }
10005
10006 /* unsolicited event for HP jack sensing */
10007 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
10008                                        unsigned int res)
10009 {
10010         if ((res >> 26) != ALC880_HP_EVENT)
10011                 return;
10012         alc262_hippo1_automute(codec);
10013 }
10014
10015 /*
10016  * nec model
10017  *  0x15 = headphone
10018  *  0x16 = internal speaker
10019  *  0x18 = external mic
10020  */
10021
10022 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10023         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10024         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10025
10026         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10027         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10028         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10029
10030         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10031         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10032         { } /* end */
10033 };
10034
10035 static struct hda_verb alc262_nec_verbs[] = {
10036         /* Unmute Speaker */
10037         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10038
10039         /* Headphone */
10040         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10041         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10042
10043         /* External mic to headphone */
10044         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10045         /* External mic to speaker */
10046         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10047         {}
10048 };
10049
10050 /*
10051  * fujitsu model
10052  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10053  *  0x1b = port replicator headphone out
10054  */
10055
10056 #define ALC_HP_EVENT    0x37
10057
10058 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10059         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10060         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10061         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10062         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10063         {}
10064 };
10065
10066 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10067         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10068         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10069         {}
10070 };
10071
10072 static struct hda_input_mux alc262_fujitsu_capture_source = {
10073         .num_items = 3,
10074         .items = {
10075                 { "Mic", 0x0 },
10076                 { "Int Mic", 0x1 },
10077                 { "CD", 0x4 },
10078         },
10079 };
10080
10081 static struct hda_input_mux alc262_HP_capture_source = {
10082         .num_items = 5,
10083         .items = {
10084                 { "Mic", 0x0 },
10085                 { "Front Mic", 0x1 },
10086                 { "Line", 0x2 },
10087                 { "CD", 0x4 },
10088                 { "AUX IN", 0x6 },
10089         },
10090 };
10091
10092 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10093         .num_items = 4,
10094         .items = {
10095                 { "Mic", 0x0 },
10096                 { "Front Mic", 0x2 },
10097                 { "Line", 0x1 },
10098                 { "CD", 0x4 },
10099         },
10100 };
10101
10102 /* mute/unmute internal speaker according to the hp jacks and mute state */
10103 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10104 {
10105         struct alc_spec *spec = codec->spec;
10106         unsigned int mute;
10107
10108         if (force || !spec->sense_updated) {
10109                 unsigned int present;
10110                 /* need to execute and sync at first */
10111                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10112                 /* check laptop HP jack */
10113                 present = snd_hda_codec_read(codec, 0x14, 0,
10114                                              AC_VERB_GET_PIN_SENSE, 0);
10115                 /* need to execute and sync at first */
10116                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10117                 /* check docking HP jack */
10118                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10119                                               AC_VERB_GET_PIN_SENSE, 0);
10120                 if (present & AC_PINSENSE_PRESENCE)
10121                         spec->jack_present = 1;
10122                 else
10123                         spec->jack_present = 0;
10124                 spec->sense_updated = 1;
10125         }
10126         /* unmute internal speaker only if both HPs are unplugged and
10127          * master switch is on
10128          */
10129         if (spec->jack_present)
10130                 mute = HDA_AMP_MUTE;
10131         else
10132                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10133         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10134                                  HDA_AMP_MUTE, mute);
10135 }
10136
10137 /* unsolicited event for HP jack sensing */
10138 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10139                                        unsigned int res)
10140 {
10141         if ((res >> 26) != ALC_HP_EVENT)
10142                 return;
10143         alc262_fujitsu_automute(codec, 1);
10144 }
10145
10146 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10147 {
10148         alc262_fujitsu_automute(codec, 1);
10149 }
10150
10151 /* bind volumes of both NID 0x0c and 0x0d */
10152 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10153         .ops = &snd_hda_bind_vol,
10154         .values = {
10155                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10156                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10157                 0
10158         },
10159 };
10160
10161 /* mute/unmute internal speaker according to the hp jack and mute state */
10162 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10163 {
10164         struct alc_spec *spec = codec->spec;
10165         unsigned int mute;
10166
10167         if (force || !spec->sense_updated) {
10168                 unsigned int present_int_hp;
10169                 /* need to execute and sync at first */
10170                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10171                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10172                                         AC_VERB_GET_PIN_SENSE, 0);
10173                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10174                 spec->sense_updated = 1;
10175         }
10176         if (spec->jack_present) {
10177                 /* mute internal speaker */
10178                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10179                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10180                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10181                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10182         } else {
10183                 /* unmute internal speaker if necessary */
10184                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10185                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10186                                          HDA_AMP_MUTE, mute);
10187                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10188                                          HDA_AMP_MUTE, mute);
10189         }
10190 }
10191
10192 /* unsolicited event for HP jack sensing */
10193 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10194                                        unsigned int res)
10195 {
10196         if ((res >> 26) != ALC_HP_EVENT)
10197                 return;
10198         alc262_lenovo_3000_automute(codec, 1);
10199 }
10200
10201 /* bind hp and internal speaker mute (with plug check) */
10202 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10203                                          struct snd_ctl_elem_value *ucontrol)
10204 {
10205         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10206         long *valp = ucontrol->value.integer.value;
10207         int change;
10208
10209         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10210                                                  HDA_AMP_MUTE,
10211                                                  valp ? 0 : HDA_AMP_MUTE);
10212         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10213                                                  HDA_AMP_MUTE,
10214                                                  valp ? 0 : HDA_AMP_MUTE);
10215
10216         if (change)
10217                 alc262_fujitsu_automute(codec, 0);
10218         return change;
10219 }
10220
10221 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10222         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10223         {
10224                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10225                 .name = "Master Playback Switch",
10226                 .info = snd_hda_mixer_amp_switch_info,
10227                 .get = snd_hda_mixer_amp_switch_get,
10228                 .put = alc262_fujitsu_master_sw_put,
10229                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10230         },
10231         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10232         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10233         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10234         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10235         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10236         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10237         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10238         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10239         { } /* end */
10240 };
10241
10242 /* bind hp and internal speaker mute (with plug check) */
10243 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10244                                          struct snd_ctl_elem_value *ucontrol)
10245 {
10246         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10247         long *valp = ucontrol->value.integer.value;
10248         int change;
10249
10250         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10251                                                  HDA_AMP_MUTE,
10252                                                  valp ? 0 : HDA_AMP_MUTE);
10253
10254         if (change)
10255                 alc262_lenovo_3000_automute(codec, 0);
10256         return change;
10257 }
10258
10259 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10260         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10261         {
10262                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10263                 .name = "Master Playback Switch",
10264                 .info = snd_hda_mixer_amp_switch_info,
10265                 .get = snd_hda_mixer_amp_switch_get,
10266                 .put = alc262_lenovo_3000_master_sw_put,
10267                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10268         },
10269         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10270         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10271         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10273         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10274         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10275         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10276         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10277         { } /* end */
10278 };
10279
10280 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10281         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10282         {
10283                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10284                 .name = "Master Playback Switch",
10285                 .info = snd_hda_mixer_amp_switch_info,
10286                 .get = snd_hda_mixer_amp_switch_get,
10287                 .put = alc262_sony_master_sw_put,
10288                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10289         },
10290         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10291         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10292         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10293         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10294         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10295         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10296         { } /* end */
10297 };
10298
10299 /* additional init verbs for Benq laptops */
10300 static struct hda_verb alc262_EAPD_verbs[] = {
10301         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10302         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10303         {}
10304 };
10305
10306 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10307         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10308         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10309
10310         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10311         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10312         {}
10313 };
10314
10315 /* Samsung Q1 Ultra Vista model setup */
10316 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10317         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10318         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10319         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10320         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10321         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10322         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10323         { } /* end */
10324 };
10325
10326 static struct hda_verb alc262_ultra_verbs[] = {
10327         /* output mixer */
10328         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10329         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10330         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10331         /* speaker */
10332         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10333         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10334         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10335         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10336         /* HP */
10337         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10338         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10339         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10340         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10341         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10342         /* internal mic */
10343         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10344         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10345         /* ADC, choose mic */
10346         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10347         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10348         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10349         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10350         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10351         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10352         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10353         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10354         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10355         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10356         {}
10357 };
10358
10359 /* mute/unmute internal speaker according to the hp jack and mute state */
10360 static void alc262_ultra_automute(struct hda_codec *codec)
10361 {
10362         struct alc_spec *spec = codec->spec;
10363         unsigned int mute;
10364
10365         mute = 0;
10366         /* auto-mute only when HP is used as HP */
10367         if (!spec->cur_mux[0]) {
10368                 unsigned int present;
10369                 /* need to execute and sync at first */
10370                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10371                 present = snd_hda_codec_read(codec, 0x15, 0,
10372                                              AC_VERB_GET_PIN_SENSE, 0);
10373                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10374                 if (spec->jack_present)
10375                         mute = HDA_AMP_MUTE;
10376         }
10377         /* mute/unmute internal speaker */
10378         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10379                                  HDA_AMP_MUTE, mute);
10380         /* mute/unmute HP */
10381         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10382                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10383 }
10384
10385 /* unsolicited event for HP jack sensing */
10386 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10387                                        unsigned int res)
10388 {
10389         if ((res >> 26) != ALC880_HP_EVENT)
10390                 return;
10391         alc262_ultra_automute(codec);
10392 }
10393
10394 static struct hda_input_mux alc262_ultra_capture_source = {
10395         .num_items = 2,
10396         .items = {
10397                 { "Mic", 0x1 },
10398                 { "Headphone", 0x7 },
10399         },
10400 };
10401
10402 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10403                                      struct snd_ctl_elem_value *ucontrol)
10404 {
10405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10406         struct alc_spec *spec = codec->spec;
10407         int ret;
10408
10409         ret = alc_mux_enum_put(kcontrol, ucontrol);
10410         if (!ret)
10411                 return 0;
10412         /* reprogram the HP pin as mic or HP according to the input source */
10413         snd_hda_codec_write_cache(codec, 0x15, 0,
10414                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10415                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10416         alc262_ultra_automute(codec); /* mute/unmute HP */
10417         return ret;
10418 }
10419
10420 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10421         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10422         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10423         {
10424                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10425                 .name = "Capture Source",
10426                 .info = alc_mux_enum_info,
10427                 .get = alc_mux_enum_get,
10428                 .put = alc262_ultra_mux_enum_put,
10429         },
10430         { } /* end */
10431 };
10432
10433 /* add playback controls from the parsed DAC table */
10434 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10435                                              const struct auto_pin_cfg *cfg)
10436 {
10437         hda_nid_t nid;
10438         int err;
10439
10440         spec->multiout.num_dacs = 1;    /* only use one dac */
10441         spec->multiout.dac_nids = spec->private_dac_nids;
10442         spec->multiout.dac_nids[0] = 2;
10443
10444         nid = cfg->line_out_pins[0];
10445         if (nid) {
10446                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10447                                   "Front Playback Volume",
10448                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10449                 if (err < 0)
10450                         return err;
10451                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10452                                   "Front Playback Switch",
10453                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10454                 if (err < 0)
10455                         return err;
10456         }
10457
10458         nid = cfg->speaker_pins[0];
10459         if (nid) {
10460                 if (nid == 0x16) {
10461                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10462                                           "Speaker Playback Volume",
10463                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10464                                                               HDA_OUTPUT));
10465                         if (err < 0)
10466                                 return err;
10467                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10468                                           "Speaker Playback Switch",
10469                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10470                                                               HDA_OUTPUT));
10471                         if (err < 0)
10472                                 return err;
10473                 } else {
10474                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10475                                           "Speaker Playback Switch",
10476                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10477                                                               HDA_OUTPUT));
10478                         if (err < 0)
10479                                 return err;
10480                 }
10481         }
10482         nid = cfg->hp_pins[0];
10483         if (nid) {
10484                 /* spec->multiout.hp_nid = 2; */
10485                 if (nid == 0x16) {
10486                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10487                                           "Headphone Playback Volume",
10488                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10489                                                               HDA_OUTPUT));
10490                         if (err < 0)
10491                                 return err;
10492                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10493                                           "Headphone Playback Switch",
10494                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10495                                                               HDA_OUTPUT));
10496                         if (err < 0)
10497                                 return err;
10498                 } else {
10499                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10500                                           "Headphone Playback Switch",
10501                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10502                                                               HDA_OUTPUT));
10503                         if (err < 0)
10504                                 return err;
10505                 }
10506         }
10507         return 0;
10508 }
10509
10510 /* identical with ALC880 */
10511 #define alc262_auto_create_analog_input_ctls \
10512         alc880_auto_create_analog_input_ctls
10513
10514 /*
10515  * generic initialization of ADC, input mixers and output mixers
10516  */
10517 static struct hda_verb alc262_volume_init_verbs[] = {
10518         /*
10519          * Unmute ADC0-2 and set the default input to mic-in
10520          */
10521         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10522         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10523         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10524         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10525         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10526         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10527
10528         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10529          * mixer widget
10530          * Note: PASD motherboards uses the Line In 2 as the input for
10531          * front panel mic (mic 2)
10532          */
10533         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10534         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10535         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10536         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10537         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10538         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10539
10540         /*
10541          * Set up output mixers (0x0c - 0x0f)
10542          */
10543         /* set vol=0 to output mixers */
10544         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10545         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10546         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10547
10548         /* set up input amps for analog loopback */
10549         /* Amp Indices: DAC = 0, mixer = 1 */
10550         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10551         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10552         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10553         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10554         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10555         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10556
10557         /* FIXME: use matrix-type input source selection */
10558         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10559         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10560         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10561         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10562         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10563         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10564         /* Input mixer2 */
10565         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10566         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10567         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10568         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10569         /* Input mixer3 */
10570         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10571         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10572         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10573         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10574
10575         { }
10576 };
10577
10578 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10579         /*
10580          * Unmute ADC0-2 and set the default input to mic-in
10581          */
10582         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10583         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10584         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10585         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10586         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10587         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10588
10589         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10590          * mixer widget
10591          * Note: PASD motherboards uses the Line In 2 as the input for
10592          * front panel mic (mic 2)
10593          */
10594         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10595         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10596         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10597         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10598         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10599         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10600         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10601         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10602
10603         /*
10604          * Set up output mixers (0x0c - 0x0e)
10605          */
10606         /* set vol=0 to output mixers */
10607         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10608         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10609         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10610
10611         /* set up input amps for analog loopback */
10612         /* Amp Indices: DAC = 0, mixer = 1 */
10613         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10614         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10615         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10616         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10617         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10618         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10619
10620         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10621         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10622         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10623
10624         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10625         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10626
10627         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10628         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10629
10630         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10631         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10632         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10633         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10634         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10635
10636         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10637         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10638         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10639         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10640         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10641         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10642
10643
10644         /* FIXME: use matrix-type input source selection */
10645         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10646         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10647         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10648         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10649         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10650         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10651         /* Input mixer2 */
10652         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10653         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10654         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10655         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10656         /* Input mixer3 */
10657         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10658         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10659         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10660         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10661
10662         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10663
10664         { }
10665 };
10666
10667 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10668         /*
10669          * Unmute ADC0-2 and set the default input to mic-in
10670          */
10671         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10672         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10673         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10674         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10675         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10676         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10677
10678         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10679          * mixer widget
10680          * Note: PASD motherboards uses the Line In 2 as the input for front
10681          * panel mic (mic 2)
10682          */
10683         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10684         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10685         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10686         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10687         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10688         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10689         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10690         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10691         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10692         /*
10693          * Set up output mixers (0x0c - 0x0e)
10694          */
10695         /* set vol=0 to output mixers */
10696         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10697         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10698         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10699
10700         /* set up input amps for analog loopback */
10701         /* Amp Indices: DAC = 0, mixer = 1 */
10702         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10703         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10704         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10705         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10706         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10707         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10708
10709
10710         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10711         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10712         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10713         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10714         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10715         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10716         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10717
10718         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10719         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10720
10721         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10722         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10723
10724         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10725         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10726         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10727         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10728         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10729         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10730
10731         /* FIXME: use matrix-type input source selection */
10732         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10733         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10734         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10735         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10736         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10737         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10738         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10739         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10740         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10741         /* Input mixer2 */
10742         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10743         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10744         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10745         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10746         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10747         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10748         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10749         /* Input mixer3 */
10750         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10751         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10752         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10753         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10754         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10755         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10756         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10757
10758         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10759
10760         { }
10761 };
10762
10763 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10764
10765         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10766         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10767         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10768
10769         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10770         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10771         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10772         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10773
10774         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10775         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10776         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10777         {}
10778 };
10779
10780
10781 #ifdef CONFIG_SND_HDA_POWER_SAVE
10782 #define alc262_loopbacks        alc880_loopbacks
10783 #endif
10784
10785 /* pcm configuration: identiacal with ALC880 */
10786 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10787 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10788 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10789 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10790
10791 /*
10792  * BIOS auto configuration
10793  */
10794 static int alc262_parse_auto_config(struct hda_codec *codec)
10795 {
10796         struct alc_spec *spec = codec->spec;
10797         int err;
10798         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10799
10800         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10801                                            alc262_ignore);
10802         if (err < 0)
10803                 return err;
10804         if (!spec->autocfg.line_outs) {
10805                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10806                         spec->multiout.max_channels = 2;
10807                         spec->no_analog = 1;
10808                         goto dig_only;
10809                 }
10810                 return 0; /* can't find valid BIOS pin config */
10811         }
10812         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10813         if (err < 0)
10814                 return err;
10815         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10816         if (err < 0)
10817                 return err;
10818
10819         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10820
10821  dig_only:
10822         if (spec->autocfg.dig_outs) {
10823                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10824                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10825         }
10826         if (spec->autocfg.dig_in_pin)
10827                 spec->dig_in_nid = ALC262_DIGIN_NID;
10828
10829         if (spec->kctls.list)
10830                 add_mixer(spec, spec->kctls.list);
10831
10832         add_verb(spec, alc262_volume_init_verbs);
10833         spec->num_mux_defs = 1;
10834         spec->input_mux = &spec->private_imux[0];
10835
10836         err = alc_auto_add_mic_boost(codec);
10837         if (err < 0)
10838                 return err;
10839
10840         return 1;
10841 }
10842
10843 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10844 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10845 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10846 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10847
10848
10849 /* init callback for auto-configuration model -- overriding the default init */
10850 static void alc262_auto_init(struct hda_codec *codec)
10851 {
10852         struct alc_spec *spec = codec->spec;
10853         alc262_auto_init_multi_out(codec);
10854         alc262_auto_init_hp_out(codec);
10855         alc262_auto_init_analog_input(codec);
10856         alc262_auto_init_input_src(codec);
10857         if (spec->unsol_event)
10858                 alc_inithook(codec);
10859 }
10860
10861 /*
10862  * configuration and preset
10863  */
10864 static const char *alc262_models[ALC262_MODEL_LAST] = {
10865         [ALC262_BASIC]          = "basic",
10866         [ALC262_HIPPO]          = "hippo",
10867         [ALC262_HIPPO_1]        = "hippo_1",
10868         [ALC262_FUJITSU]        = "fujitsu",
10869         [ALC262_HP_BPC]         = "hp-bpc",
10870         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10871         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10872         [ALC262_HP_RP5700]      = "hp-rp5700",
10873         [ALC262_BENQ_ED8]       = "benq",
10874         [ALC262_BENQ_T31]       = "benq-t31",
10875         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10876         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10877         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10878         [ALC262_ULTRA]          = "ultra",
10879         [ALC262_LENOVO_3000]    = "lenovo-3000",
10880         [ALC262_NEC]            = "nec",
10881         [ALC262_TYAN]           = "tyan",
10882         [ALC262_AUTO]           = "auto",
10883 };
10884
10885 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10886         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10887         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10888         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10889                            ALC262_HP_BPC),
10890         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10891                            ALC262_HP_BPC),
10892         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10893                            ALC262_HP_BPC),
10894         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10895         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10896         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10897         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10898         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10899         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10900         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10901         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10902         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10903         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10904         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10905         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10906                       ALC262_HP_TC_T5735),
10907         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10908         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10909         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10910         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10911         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10912         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10913                            ALC262_SONY_ASSAMD),
10914         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10915                       ALC262_TOSHIBA_RX1),
10916         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10917         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10918         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10919         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10920         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10921                            ALC262_ULTRA),
10922         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10923         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10924         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10925         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10926         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10927         {}
10928 };
10929
10930 static struct alc_config_preset alc262_presets[] = {
10931         [ALC262_BASIC] = {
10932                 .mixers = { alc262_base_mixer },
10933                 .init_verbs = { alc262_init_verbs },
10934                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10935                 .dac_nids = alc262_dac_nids,
10936                 .hp_nid = 0x03,
10937                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10938                 .channel_mode = alc262_modes,
10939                 .input_mux = &alc262_capture_source,
10940         },
10941         [ALC262_HIPPO] = {
10942                 .mixers = { alc262_base_mixer },
10943                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10944                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10945                 .dac_nids = alc262_dac_nids,
10946                 .hp_nid = 0x03,
10947                 .dig_out_nid = ALC262_DIGOUT_NID,
10948                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10949                 .channel_mode = alc262_modes,
10950                 .input_mux = &alc262_capture_source,
10951                 .unsol_event = alc262_hippo_unsol_event,
10952                 .init_hook = alc262_hippo_automute,
10953         },
10954         [ALC262_HIPPO_1] = {
10955                 .mixers = { alc262_hippo1_mixer },
10956                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10957                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10958                 .dac_nids = alc262_dac_nids,
10959                 .hp_nid = 0x02,
10960                 .dig_out_nid = ALC262_DIGOUT_NID,
10961                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10962                 .channel_mode = alc262_modes,
10963                 .input_mux = &alc262_capture_source,
10964                 .unsol_event = alc262_hippo1_unsol_event,
10965                 .init_hook = alc262_hippo1_automute,
10966         },
10967         [ALC262_FUJITSU] = {
10968                 .mixers = { alc262_fujitsu_mixer },
10969                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10970                                 alc262_fujitsu_unsol_verbs },
10971                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10972                 .dac_nids = alc262_dac_nids,
10973                 .hp_nid = 0x03,
10974                 .dig_out_nid = ALC262_DIGOUT_NID,
10975                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10976                 .channel_mode = alc262_modes,
10977                 .input_mux = &alc262_fujitsu_capture_source,
10978                 .unsol_event = alc262_fujitsu_unsol_event,
10979                 .init_hook = alc262_fujitsu_init_hook,
10980         },
10981         [ALC262_HP_BPC] = {
10982                 .mixers = { alc262_HP_BPC_mixer },
10983                 .init_verbs = { alc262_HP_BPC_init_verbs },
10984                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10985                 .dac_nids = alc262_dac_nids,
10986                 .hp_nid = 0x03,
10987                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10988                 .channel_mode = alc262_modes,
10989                 .input_mux = &alc262_HP_capture_source,
10990                 .unsol_event = alc262_hp_bpc_unsol_event,
10991                 .init_hook = alc262_hp_bpc_automute,
10992         },
10993         [ALC262_HP_BPC_D7000_WF] = {
10994                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10995                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10996                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10997                 .dac_nids = alc262_dac_nids,
10998                 .hp_nid = 0x03,
10999                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11000                 .channel_mode = alc262_modes,
11001                 .input_mux = &alc262_HP_D7000_capture_source,
11002                 .unsol_event = alc262_hp_wildwest_unsol_event,
11003                 .init_hook = alc262_hp_wildwest_automute,
11004         },
11005         [ALC262_HP_BPC_D7000_WL] = {
11006                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11007                             alc262_HP_BPC_WildWest_option_mixer },
11008                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11009                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11010                 .dac_nids = alc262_dac_nids,
11011                 .hp_nid = 0x03,
11012                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11013                 .channel_mode = alc262_modes,
11014                 .input_mux = &alc262_HP_D7000_capture_source,
11015                 .unsol_event = alc262_hp_wildwest_unsol_event,
11016                 .init_hook = alc262_hp_wildwest_automute,
11017         },
11018         [ALC262_HP_TC_T5735] = {
11019                 .mixers = { alc262_hp_t5735_mixer },
11020                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11021                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11022                 .dac_nids = alc262_dac_nids,
11023                 .hp_nid = 0x03,
11024                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11025                 .channel_mode = alc262_modes,
11026                 .input_mux = &alc262_capture_source,
11027                 .unsol_event = alc262_hp_t5735_unsol_event,
11028                 .init_hook = alc262_hp_t5735_init_hook,
11029         },
11030         [ALC262_HP_RP5700] = {
11031                 .mixers = { alc262_hp_rp5700_mixer },
11032                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11033                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11034                 .dac_nids = alc262_dac_nids,
11035                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11036                 .channel_mode = alc262_modes,
11037                 .input_mux = &alc262_hp_rp5700_capture_source,
11038         },
11039         [ALC262_BENQ_ED8] = {
11040                 .mixers = { alc262_base_mixer },
11041                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11042                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11043                 .dac_nids = alc262_dac_nids,
11044                 .hp_nid = 0x03,
11045                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11046                 .channel_mode = alc262_modes,
11047                 .input_mux = &alc262_capture_source,
11048         },
11049         [ALC262_SONY_ASSAMD] = {
11050                 .mixers = { alc262_sony_mixer },
11051                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11052                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11053                 .dac_nids = alc262_dac_nids,
11054                 .hp_nid = 0x02,
11055                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11056                 .channel_mode = alc262_modes,
11057                 .input_mux = &alc262_capture_source,
11058                 .unsol_event = alc262_hippo_unsol_event,
11059                 .init_hook = alc262_hippo_automute,
11060         },
11061         [ALC262_BENQ_T31] = {
11062                 .mixers = { alc262_benq_t31_mixer },
11063                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11064                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11065                 .dac_nids = alc262_dac_nids,
11066                 .hp_nid = 0x03,
11067                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11068                 .channel_mode = alc262_modes,
11069                 .input_mux = &alc262_capture_source,
11070                 .unsol_event = alc262_hippo_unsol_event,
11071                 .init_hook = alc262_hippo_automute,
11072         },
11073         [ALC262_ULTRA] = {
11074                 .mixers = { alc262_ultra_mixer },
11075                 .cap_mixer = alc262_ultra_capture_mixer,
11076                 .init_verbs = { alc262_ultra_verbs },
11077                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11078                 .dac_nids = alc262_dac_nids,
11079                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11080                 .channel_mode = alc262_modes,
11081                 .input_mux = &alc262_ultra_capture_source,
11082                 .adc_nids = alc262_adc_nids, /* ADC0 */
11083                 .capsrc_nids = alc262_capsrc_nids,
11084                 .num_adc_nids = 1, /* single ADC */
11085                 .unsol_event = alc262_ultra_unsol_event,
11086                 .init_hook = alc262_ultra_automute,
11087         },
11088         [ALC262_LENOVO_3000] = {
11089                 .mixers = { alc262_lenovo_3000_mixer },
11090                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11091                                 alc262_lenovo_3000_unsol_verbs },
11092                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11093                 .dac_nids = alc262_dac_nids,
11094                 .hp_nid = 0x03,
11095                 .dig_out_nid = ALC262_DIGOUT_NID,
11096                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11097                 .channel_mode = alc262_modes,
11098                 .input_mux = &alc262_fujitsu_capture_source,
11099                 .unsol_event = alc262_lenovo_3000_unsol_event,
11100         },
11101         [ALC262_NEC] = {
11102                 .mixers = { alc262_nec_mixer },
11103                 .init_verbs = { alc262_nec_verbs },
11104                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11105                 .dac_nids = alc262_dac_nids,
11106                 .hp_nid = 0x03,
11107                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11108                 .channel_mode = alc262_modes,
11109                 .input_mux = &alc262_capture_source,
11110         },
11111         [ALC262_TOSHIBA_S06] = {
11112                 .mixers = { alc262_toshiba_s06_mixer },
11113                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11114                                                         alc262_eapd_verbs },
11115                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11116                 .capsrc_nids = alc262_dmic_capsrc_nids,
11117                 .dac_nids = alc262_dac_nids,
11118                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11119                 .dig_out_nid = ALC262_DIGOUT_NID,
11120                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11121                 .channel_mode = alc262_modes,
11122                 .input_mux = &alc262_dmic_capture_source,
11123                 .unsol_event = alc262_toshiba_s06_unsol_event,
11124                 .init_hook = alc262_toshiba_s06_init_hook,
11125         },
11126         [ALC262_TOSHIBA_RX1] = {
11127                 .mixers = { alc262_toshiba_rx1_mixer },
11128                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11129                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11130                 .dac_nids = alc262_dac_nids,
11131                 .hp_nid = 0x03,
11132                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11133                 .channel_mode = alc262_modes,
11134                 .input_mux = &alc262_capture_source,
11135                 .unsol_event = alc262_hippo_unsol_event,
11136                 .init_hook = alc262_hippo_automute,
11137         },
11138         [ALC262_TYAN] = {
11139                 .mixers = { alc262_tyan_mixer },
11140                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11141                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11142                 .dac_nids = alc262_dac_nids,
11143                 .hp_nid = 0x02,
11144                 .dig_out_nid = ALC262_DIGOUT_NID,
11145                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11146                 .channel_mode = alc262_modes,
11147                 .input_mux = &alc262_capture_source,
11148                 .unsol_event = alc262_tyan_unsol_event,
11149                 .init_hook = alc262_tyan_automute,
11150         },
11151 };
11152
11153 static int patch_alc262(struct hda_codec *codec)
11154 {
11155         struct alc_spec *spec;
11156         int board_config;
11157         int err;
11158
11159         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11160         if (spec == NULL)
11161                 return -ENOMEM;
11162
11163         codec->spec = spec;
11164 #if 0
11165         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11166          * under-run
11167          */
11168         {
11169         int tmp;
11170         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11171         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11172         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11173         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11174         }
11175 #endif
11176
11177         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11178
11179         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11180                                                   alc262_models,
11181                                                   alc262_cfg_tbl);
11182
11183         if (board_config < 0) {
11184                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
11185                        "trying auto-probe from BIOS...\n");
11186                 board_config = ALC262_AUTO;
11187         }
11188
11189         if (board_config == ALC262_AUTO) {
11190                 /* automatic parse from the BIOS config */
11191                 err = alc262_parse_auto_config(codec);
11192                 if (err < 0) {
11193                         alc_free(codec);
11194                         return err;
11195                 } else if (!err) {
11196                         printk(KERN_INFO
11197                                "hda_codec: Cannot set up configuration "
11198                                "from BIOS.  Using base mode...\n");
11199                         board_config = ALC262_BASIC;
11200                 }
11201         }
11202
11203         if (!spec->no_analog) {
11204                 err = snd_hda_attach_beep_device(codec, 0x1);
11205                 if (err < 0) {
11206                         alc_free(codec);
11207                         return err;
11208                 }
11209         }
11210
11211         if (board_config != ALC262_AUTO)
11212                 setup_preset(spec, &alc262_presets[board_config]);
11213
11214         spec->stream_name_analog = "ALC262 Analog";
11215         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11216         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11217
11218         spec->stream_name_digital = "ALC262 Digital";
11219         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11220         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11221
11222         spec->capture_style = CAPT_MIX;
11223         if (!spec->adc_nids && spec->input_mux) {
11224                 /* check whether NID 0x07 is valid */
11225                 unsigned int wcap = get_wcaps(codec, 0x07);
11226
11227                 /* get type */
11228                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11229                 if (wcap != AC_WID_AUD_IN) {
11230                         spec->adc_nids = alc262_adc_nids_alt;
11231                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11232                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11233                 } else {
11234                         spec->adc_nids = alc262_adc_nids;
11235                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11236                         spec->capsrc_nids = alc262_capsrc_nids;
11237                 }
11238         }
11239         if (!spec->cap_mixer && !spec->no_analog)
11240                 set_capture_mixer(spec);
11241         if (!spec->no_analog)
11242                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11243
11244         spec->vmaster_nid = 0x0c;
11245
11246         codec->patch_ops = alc_patch_ops;
11247         if (board_config == ALC262_AUTO)
11248                 spec->init_hook = alc262_auto_init;
11249 #ifdef CONFIG_SND_HDA_POWER_SAVE
11250         if (!spec->loopback.amplist)
11251                 spec->loopback.amplist = alc262_loopbacks;
11252 #endif
11253         codec->proc_widget_hook = print_realtek_coef;
11254
11255         return 0;
11256 }
11257
11258 /*
11259  *  ALC268 channel source setting (2 channel)
11260  */
11261 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11262 #define alc268_modes            alc260_modes
11263
11264 static hda_nid_t alc268_dac_nids[2] = {
11265         /* front, hp */
11266         0x02, 0x03
11267 };
11268
11269 static hda_nid_t alc268_adc_nids[2] = {
11270         /* ADC0-1 */
11271         0x08, 0x07
11272 };
11273
11274 static hda_nid_t alc268_adc_nids_alt[1] = {
11275         /* ADC0 */
11276         0x08
11277 };
11278
11279 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11280
11281 static struct snd_kcontrol_new alc268_base_mixer[] = {
11282         /* output mixer control */
11283         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11284         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11285         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11286         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11287         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11288         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11289         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11290         { }
11291 };
11292
11293 /* bind Beep switches of both NID 0x0f and 0x10 */
11294 static struct hda_bind_ctls alc268_bind_beep_sw = {
11295         .ops = &snd_hda_bind_sw,
11296         .values = {
11297                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11298                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11299                 0
11300         },
11301 };
11302
11303 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11304         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11305         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11306         { }
11307 };
11308
11309 static struct hda_verb alc268_eapd_verbs[] = {
11310         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11311         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11312         { }
11313 };
11314
11315 /* Toshiba specific */
11316 #define alc268_toshiba_automute alc262_hippo_automute
11317
11318 static struct hda_verb alc268_toshiba_verbs[] = {
11319         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11320         { } /* end */
11321 };
11322
11323 static struct hda_input_mux alc268_acer_lc_capture_source = {
11324         .num_items = 2,
11325         .items = {
11326                 { "i-Mic", 0x6 },
11327                 { "E-Mic", 0x0 },
11328         },
11329 };
11330
11331 /* Acer specific */
11332 /* bind volumes of both NID 0x02 and 0x03 */
11333 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11334         .ops = &snd_hda_bind_vol,
11335         .values = {
11336                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11337                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11338                 0
11339         },
11340 };
11341
11342 /* mute/unmute internal speaker according to the hp jack and mute state */
11343 static void alc268_acer_automute(struct hda_codec *codec, int force)
11344 {
11345         struct alc_spec *spec = codec->spec;
11346         unsigned int mute;
11347
11348         if (force || !spec->sense_updated) {
11349                 unsigned int present;
11350                 present = snd_hda_codec_read(codec, 0x14, 0,
11351                                          AC_VERB_GET_PIN_SENSE, 0);
11352                 spec->jack_present = (present & 0x80000000) != 0;
11353                 spec->sense_updated = 1;
11354         }
11355         if (spec->jack_present)
11356                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11357         else /* unmute internal speaker if necessary */
11358                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11359         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11360                                  HDA_AMP_MUTE, mute);
11361 }
11362
11363
11364 /* bind hp and internal speaker mute (with plug check) */
11365 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11366                                      struct snd_ctl_elem_value *ucontrol)
11367 {
11368         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11369         long *valp = ucontrol->value.integer.value;
11370         int change;
11371
11372         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11373                                           HDA_AMP_MUTE,
11374                                           valp[0] ? 0 : HDA_AMP_MUTE);
11375         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11376                                            HDA_AMP_MUTE,
11377                                            valp[1] ? 0 : HDA_AMP_MUTE);
11378         if (change)
11379                 alc268_acer_automute(codec, 0);
11380         return change;
11381 }
11382
11383 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11384         /* output mixer control */
11385         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11386         {
11387                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11388                 .name = "Master Playback Switch",
11389                 .info = snd_hda_mixer_amp_switch_info,
11390                 .get = snd_hda_mixer_amp_switch_get,
11391                 .put = alc268_acer_master_sw_put,
11392                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11393         },
11394         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11395         { }
11396 };
11397
11398 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11399         /* output mixer control */
11400         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11401         {
11402                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11403                 .name = "Master Playback Switch",
11404                 .info = snd_hda_mixer_amp_switch_info,
11405                 .get = snd_hda_mixer_amp_switch_get,
11406                 .put = alc268_acer_master_sw_put,
11407                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11408         },
11409         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11410         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11411         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11412         { }
11413 };
11414
11415 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11416         /* output mixer control */
11417         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11418         {
11419                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11420                 .name = "Master Playback Switch",
11421                 .info = snd_hda_mixer_amp_switch_info,
11422                 .get = snd_hda_mixer_amp_switch_get,
11423                 .put = alc268_acer_master_sw_put,
11424                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11425         },
11426         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11427         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11428         { }
11429 };
11430
11431 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11432         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11433         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11434         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11435         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11436         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11437         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11438         { }
11439 };
11440
11441 static struct hda_verb alc268_acer_verbs[] = {
11442         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11443         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11444         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11445         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11446         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11447         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11448         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11449         { }
11450 };
11451
11452 /* unsolicited event for HP jack sensing */
11453 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11454                                        unsigned int res)
11455 {
11456         if ((res >> 26) != ALC880_HP_EVENT)
11457                 return;
11458         alc268_toshiba_automute(codec);
11459 }
11460
11461 static void alc268_acer_unsol_event(struct hda_codec *codec,
11462                                        unsigned int res)
11463 {
11464         if ((res >> 26) != ALC880_HP_EVENT)
11465                 return;
11466         alc268_acer_automute(codec, 1);
11467 }
11468
11469 static void alc268_acer_init_hook(struct hda_codec *codec)
11470 {
11471         alc268_acer_automute(codec, 1);
11472 }
11473
11474 /* toggle speaker-output according to the hp-jack state */
11475 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11476 {
11477         unsigned int present;
11478         unsigned char bits;
11479
11480         present = snd_hda_codec_read(codec, 0x15, 0,
11481                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11482         bits = present ? AMP_IN_MUTE(0) : 0;
11483         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11484                                 AMP_IN_MUTE(0), bits);
11485         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11486                                 AMP_IN_MUTE(0), bits);
11487 }
11488
11489
11490 static void alc268_acer_mic_automute(struct hda_codec *codec)
11491 {
11492         unsigned int present;
11493
11494         present = snd_hda_codec_read(codec, 0x18, 0,
11495                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11496         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11497                             present ? 0x0 : 0x6);
11498 }
11499
11500 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11501                                     unsigned int res)
11502 {
11503         if ((res >> 26) == ALC880_HP_EVENT)
11504                 alc268_aspire_one_speaker_automute(codec);
11505         if ((res >> 26) == ALC880_MIC_EVENT)
11506                 alc268_acer_mic_automute(codec);
11507 }
11508
11509 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11510 {
11511         alc268_aspire_one_speaker_automute(codec);
11512         alc268_acer_mic_automute(codec);
11513 }
11514
11515 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11516         /* output mixer control */
11517         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11518         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11519         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11520         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11521         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11522         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11523         { }
11524 };
11525
11526 static struct hda_verb alc268_dell_verbs[] = {
11527         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11528         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11529         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11530         { }
11531 };
11532
11533 /* mute/unmute internal speaker according to the hp jack and mute state */
11534 static void alc268_dell_automute(struct hda_codec *codec)
11535 {
11536         unsigned int present;
11537         unsigned int mute;
11538
11539         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11540         if (present & 0x80000000)
11541                 mute = HDA_AMP_MUTE;
11542         else
11543                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11544         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11545                                  HDA_AMP_MUTE, mute);
11546 }
11547
11548 static void alc268_dell_unsol_event(struct hda_codec *codec,
11549                                     unsigned int res)
11550 {
11551         if ((res >> 26) != ALC880_HP_EVENT)
11552                 return;
11553         alc268_dell_automute(codec);
11554 }
11555
11556 #define alc268_dell_init_hook   alc268_dell_automute
11557
11558 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11559         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11560         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11561         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11562         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11563         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11564         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11565         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11566         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11567         { }
11568 };
11569
11570 static struct hda_verb alc267_quanta_il1_verbs[] = {
11571         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11572         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11573         { }
11574 };
11575
11576 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11577 {
11578         unsigned int present;
11579
11580         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11581                 & AC_PINSENSE_PRESENCE;
11582         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11583                             present ? 0 : PIN_OUT);
11584 }
11585
11586 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11587 {
11588         unsigned int present;
11589
11590         present = snd_hda_codec_read(codec, 0x18, 0,
11591                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11592         snd_hda_codec_write(codec, 0x23, 0,
11593                             AC_VERB_SET_CONNECT_SEL,
11594                             present ? 0x00 : 0x01);
11595 }
11596
11597 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11598 {
11599         alc267_quanta_il1_hp_automute(codec);
11600         alc267_quanta_il1_mic_automute(codec);
11601 }
11602
11603 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11604                                            unsigned int res)
11605 {
11606         switch (res >> 26) {
11607         case ALC880_HP_EVENT:
11608                 alc267_quanta_il1_hp_automute(codec);
11609                 break;
11610         case ALC880_MIC_EVENT:
11611                 alc267_quanta_il1_mic_automute(codec);
11612                 break;
11613         }
11614 }
11615
11616 /*
11617  * generic initialization of ADC, input mixers and output mixers
11618  */
11619 static struct hda_verb alc268_base_init_verbs[] = {
11620         /* Unmute DAC0-1 and set vol = 0 */
11621         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11622         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11623
11624         /*
11625          * Set up output mixers (0x0c - 0x0e)
11626          */
11627         /* set vol=0 to output mixers */
11628         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11629         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11630
11631         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11632         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11633
11634         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11635         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11636         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11637         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11638         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11639         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11640         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11641         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11642
11643         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11644         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11645         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11646         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11647         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11648
11649         /* set PCBEEP vol = 0, mute connections */
11650         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11651         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11652         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11653
11654         /* Unmute Selector 23h,24h and set the default input to mic-in */
11655
11656         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11657         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11658         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11659         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11660
11661         { }
11662 };
11663
11664 /*
11665  * generic initialization of ADC, input mixers and output mixers
11666  */
11667 static struct hda_verb alc268_volume_init_verbs[] = {
11668         /* set output DAC */
11669         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11670         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11671
11672         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11673         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11674         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11675         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11676         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11677
11678         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11679         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11680         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11681
11682         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11683         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11684
11685         /* set PCBEEP vol = 0, mute connections */
11686         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11687         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11688         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11689
11690         { }
11691 };
11692
11693 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11694         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11695         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11696         {
11697                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11698                 /* The multiple "Capture Source" controls confuse alsamixer
11699                  * So call somewhat different..
11700                  */
11701                 /* .name = "Capture Source", */
11702                 .name = "Input Source",
11703                 .count = 1,
11704                 .info = alc_mux_enum_info,
11705                 .get = alc_mux_enum_get,
11706                 .put = alc_mux_enum_put,
11707         },
11708         { } /* end */
11709 };
11710
11711 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11712         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11713         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11714         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11715         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11716         {
11717                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11718                 /* The multiple "Capture Source" controls confuse alsamixer
11719                  * So call somewhat different..
11720                  */
11721                 /* .name = "Capture Source", */
11722                 .name = "Input Source",
11723                 .count = 2,
11724                 .info = alc_mux_enum_info,
11725                 .get = alc_mux_enum_get,
11726                 .put = alc_mux_enum_put,
11727         },
11728         { } /* end */
11729 };
11730
11731 static struct hda_input_mux alc268_capture_source = {
11732         .num_items = 4,
11733         .items = {
11734                 { "Mic", 0x0 },
11735                 { "Front Mic", 0x1 },
11736                 { "Line", 0x2 },
11737                 { "CD", 0x3 },
11738         },
11739 };
11740
11741 static struct hda_input_mux alc268_acer_capture_source = {
11742         .num_items = 3,
11743         .items = {
11744                 { "Mic", 0x0 },
11745                 { "Internal Mic", 0x1 },
11746                 { "Line", 0x2 },
11747         },
11748 };
11749
11750 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11751         .num_items = 3,
11752         .items = {
11753                 { "Mic", 0x0 },
11754                 { "Internal Mic", 0x6 },
11755                 { "Line", 0x2 },
11756         },
11757 };
11758
11759 #ifdef CONFIG_SND_DEBUG
11760 static struct snd_kcontrol_new alc268_test_mixer[] = {
11761         /* Volume widgets */
11762         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11763         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11764         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11765         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11766         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11767         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11768         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11769         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11770         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11771         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11772         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11773         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11774         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11775         /* The below appears problematic on some hardwares */
11776         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11777         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11778         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11779         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11780         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11781
11782         /* Modes for retasking pin widgets */
11783         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11784         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11785         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11786         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11787
11788         /* Controls for GPIO pins, assuming they are configured as outputs */
11789         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11790         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11791         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11792         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11793
11794         /* Switches to allow the digital SPDIF output pin to be enabled.
11795          * The ALC268 does not have an SPDIF input.
11796          */
11797         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11798
11799         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11800          * this output to turn on an external amplifier.
11801          */
11802         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11803         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11804
11805         { } /* end */
11806 };
11807 #endif
11808
11809 /* create input playback/capture controls for the given pin */
11810 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11811                                     const char *ctlname, int idx)
11812 {
11813         char name[32];
11814         int err;
11815
11816         sprintf(name, "%s Playback Volume", ctlname);
11817         if (nid == 0x14) {
11818                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11819                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11820                                                       HDA_OUTPUT));
11821                 if (err < 0)
11822                         return err;
11823         } else if (nid == 0x15) {
11824                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11825                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11826                                                       HDA_OUTPUT));
11827                 if (err < 0)
11828                         return err;
11829         } else
11830                 return -1;
11831         sprintf(name, "%s Playback Switch", ctlname);
11832         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11833                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11834         if (err < 0)
11835                 return err;
11836         return 0;
11837 }
11838
11839 /* add playback controls from the parsed DAC table */
11840 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11841                                              const struct auto_pin_cfg *cfg)
11842 {
11843         hda_nid_t nid;
11844         int err;
11845
11846         spec->multiout.num_dacs = 2;    /* only use one dac */
11847         spec->multiout.dac_nids = spec->private_dac_nids;
11848         spec->multiout.dac_nids[0] = 2;
11849         spec->multiout.dac_nids[1] = 3;
11850
11851         nid = cfg->line_out_pins[0];
11852         if (nid)
11853                 alc268_new_analog_output(spec, nid, "Front", 0);
11854
11855         nid = cfg->speaker_pins[0];
11856         if (nid == 0x1d) {
11857                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11858                                   "Speaker Playback Volume",
11859                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11860                 if (err < 0)
11861                         return err;
11862         }
11863         nid = cfg->hp_pins[0];
11864         if (nid)
11865                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11866
11867         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11868         if (nid == 0x16) {
11869                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11870                                   "Mono Playback Switch",
11871                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11872                 if (err < 0)
11873                         return err;
11874         }
11875         return 0;
11876 }
11877
11878 /* create playback/capture controls for input pins */
11879 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11880                                                 const struct auto_pin_cfg *cfg)
11881 {
11882         struct hda_input_mux *imux = &spec->private_imux[0];
11883         int i, idx1;
11884
11885         for (i = 0; i < AUTO_PIN_LAST; i++) {
11886                 switch(cfg->input_pins[i]) {
11887                 case 0x18:
11888                         idx1 = 0;       /* Mic 1 */
11889                         break;
11890                 case 0x19:
11891                         idx1 = 1;       /* Mic 2 */
11892                         break;
11893                 case 0x1a:
11894                         idx1 = 2;       /* Line In */
11895                         break;
11896                 case 0x1c:
11897                         idx1 = 3;       /* CD */
11898                         break;
11899                 case 0x12:
11900                 case 0x13:
11901                         idx1 = 6;       /* digital mics */
11902                         break;
11903                 default:
11904                         continue;
11905                 }
11906                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11907                 imux->items[imux->num_items].index = idx1;
11908                 imux->num_items++;
11909         }
11910         return 0;
11911 }
11912
11913 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11914 {
11915         struct alc_spec *spec = codec->spec;
11916         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11917         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11918         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11919         unsigned int    dac_vol1, dac_vol2;
11920
11921         if (speaker_nid) {
11922                 snd_hda_codec_write(codec, speaker_nid, 0,
11923                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11924                 snd_hda_codec_write(codec, 0x0f, 0,
11925                                     AC_VERB_SET_AMP_GAIN_MUTE,
11926                                     AMP_IN_UNMUTE(1));
11927                 snd_hda_codec_write(codec, 0x10, 0,
11928                                     AC_VERB_SET_AMP_GAIN_MUTE,
11929                                     AMP_IN_UNMUTE(1));
11930         } else {
11931                 snd_hda_codec_write(codec, 0x0f, 0,
11932                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11933                 snd_hda_codec_write(codec, 0x10, 0,
11934                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11935         }
11936
11937         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11938         if (line_nid == 0x14)
11939                 dac_vol2 = AMP_OUT_ZERO;
11940         else if (line_nid == 0x15)
11941                 dac_vol1 = AMP_OUT_ZERO;
11942         if (hp_nid == 0x14)
11943                 dac_vol2 = AMP_OUT_ZERO;
11944         else if (hp_nid == 0x15)
11945                 dac_vol1 = AMP_OUT_ZERO;
11946         if (line_nid != 0x16 || hp_nid != 0x16 ||
11947             spec->autocfg.line_out_pins[1] != 0x16 ||
11948             spec->autocfg.line_out_pins[2] != 0x16)
11949                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11950
11951         snd_hda_codec_write(codec, 0x02, 0,
11952                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11953         snd_hda_codec_write(codec, 0x03, 0,
11954                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11955 }
11956
11957 /* pcm configuration: identiacal with ALC880 */
11958 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11959 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11960 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11961 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11962
11963 /*
11964  * BIOS auto configuration
11965  */
11966 static int alc268_parse_auto_config(struct hda_codec *codec)
11967 {
11968         struct alc_spec *spec = codec->spec;
11969         int err;
11970         static hda_nid_t alc268_ignore[] = { 0 };
11971
11972         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11973                                            alc268_ignore);
11974         if (err < 0)
11975                 return err;
11976         if (!spec->autocfg.line_outs) {
11977                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11978                         spec->multiout.max_channels = 2;
11979                         spec->no_analog = 1;
11980                         goto dig_only;
11981                 }
11982                 return 0; /* can't find valid BIOS pin config */
11983         }
11984         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11985         if (err < 0)
11986                 return err;
11987         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11988         if (err < 0)
11989                 return err;
11990
11991         spec->multiout.max_channels = 2;
11992
11993  dig_only:
11994         /* digital only support output */
11995         if (spec->autocfg.dig_outs) {
11996                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11997                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11998         }
11999         if (spec->kctls.list)
12000                 add_mixer(spec, spec->kctls.list);
12001
12002         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12003                 add_mixer(spec, alc268_beep_mixer);
12004
12005         add_verb(spec, alc268_volume_init_verbs);
12006         spec->num_mux_defs = 1;
12007         spec->input_mux = &spec->private_imux[0];
12008
12009         err = alc_auto_add_mic_boost(codec);
12010         if (err < 0)
12011                 return err;
12012
12013         return 1;
12014 }
12015
12016 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
12017 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
12018 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12019
12020 /* init callback for auto-configuration model -- overriding the default init */
12021 static void alc268_auto_init(struct hda_codec *codec)
12022 {
12023         struct alc_spec *spec = codec->spec;
12024         alc268_auto_init_multi_out(codec);
12025         alc268_auto_init_hp_out(codec);
12026         alc268_auto_init_mono_speaker_out(codec);
12027         alc268_auto_init_analog_input(codec);
12028         if (spec->unsol_event)
12029                 alc_inithook(codec);
12030 }
12031
12032 /*
12033  * configuration and preset
12034  */
12035 static const char *alc268_models[ALC268_MODEL_LAST] = {
12036         [ALC267_QUANTA_IL1]     = "quanta-il1",
12037         [ALC268_3ST]            = "3stack",
12038         [ALC268_TOSHIBA]        = "toshiba",
12039         [ALC268_ACER]           = "acer",
12040         [ALC268_ACER_DMIC]      = "acer-dmic",
12041         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12042         [ALC268_DELL]           = "dell",
12043         [ALC268_ZEPTO]          = "zepto",
12044 #ifdef CONFIG_SND_DEBUG
12045         [ALC268_TEST]           = "test",
12046 #endif
12047         [ALC268_AUTO]           = "auto",
12048 };
12049
12050 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12051         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12052         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12053         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12054         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12055         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12056         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12057                                                 ALC268_ACER_ASPIRE_ONE),
12058         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12059         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12060         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
12061         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12062         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
12063         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
12064         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
12065         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12066         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12067         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12068         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12069         {}
12070 };
12071
12072 static struct alc_config_preset alc268_presets[] = {
12073         [ALC267_QUANTA_IL1] = {
12074                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12075                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12076                                 alc267_quanta_il1_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                 .hp_nid = 0x03,
12082                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12083                 .channel_mode = alc268_modes,
12084                 .input_mux = &alc268_capture_source,
12085                 .unsol_event = alc267_quanta_il1_unsol_event,
12086                 .init_hook = alc267_quanta_il1_automute,
12087         },
12088         [ALC268_3ST] = {
12089                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12090                             alc268_beep_mixer },
12091                 .init_verbs = { alc268_base_init_verbs },
12092                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12093                 .dac_nids = alc268_dac_nids,
12094                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12095                 .adc_nids = alc268_adc_nids_alt,
12096                 .capsrc_nids = alc268_capsrc_nids,
12097                 .hp_nid = 0x03,
12098                 .dig_out_nid = ALC268_DIGOUT_NID,
12099                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12100                 .channel_mode = alc268_modes,
12101                 .input_mux = &alc268_capture_source,
12102         },
12103         [ALC268_TOSHIBA] = {
12104                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12105                             alc268_beep_mixer },
12106                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12107                                 alc268_toshiba_verbs },
12108                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12109                 .dac_nids = alc268_dac_nids,
12110                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12111                 .adc_nids = alc268_adc_nids_alt,
12112                 .capsrc_nids = alc268_capsrc_nids,
12113                 .hp_nid = 0x03,
12114                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12115                 .channel_mode = alc268_modes,
12116                 .input_mux = &alc268_capture_source,
12117                 .unsol_event = alc268_toshiba_unsol_event,
12118                 .init_hook = alc268_toshiba_automute,
12119         },
12120         [ALC268_ACER] = {
12121                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12122                             alc268_beep_mixer },
12123                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12124                                 alc268_acer_verbs },
12125                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12126                 .dac_nids = alc268_dac_nids,
12127                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12128                 .adc_nids = alc268_adc_nids_alt,
12129                 .capsrc_nids = alc268_capsrc_nids,
12130                 .hp_nid = 0x02,
12131                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12132                 .channel_mode = alc268_modes,
12133                 .input_mux = &alc268_acer_capture_source,
12134                 .unsol_event = alc268_acer_unsol_event,
12135                 .init_hook = alc268_acer_init_hook,
12136         },
12137         [ALC268_ACER_DMIC] = {
12138                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12139                             alc268_beep_mixer },
12140                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12141                                 alc268_acer_verbs },
12142                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12143                 .dac_nids = alc268_dac_nids,
12144                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12145                 .adc_nids = alc268_adc_nids_alt,
12146                 .capsrc_nids = alc268_capsrc_nids,
12147                 .hp_nid = 0x02,
12148                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12149                 .channel_mode = alc268_modes,
12150                 .input_mux = &alc268_acer_dmic_capture_source,
12151                 .unsol_event = alc268_acer_unsol_event,
12152                 .init_hook = alc268_acer_init_hook,
12153         },
12154         [ALC268_ACER_ASPIRE_ONE] = {
12155                 .mixers = { alc268_acer_aspire_one_mixer,
12156                             alc268_beep_mixer,
12157                             alc268_capture_alt_mixer },
12158                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12159                                 alc268_acer_aspire_one_verbs },
12160                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12161                 .dac_nids = alc268_dac_nids,
12162                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12163                 .adc_nids = alc268_adc_nids_alt,
12164                 .capsrc_nids = alc268_capsrc_nids,
12165                 .hp_nid = 0x03,
12166                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12167                 .channel_mode = alc268_modes,
12168                 .input_mux = &alc268_acer_lc_capture_source,
12169                 .unsol_event = alc268_acer_lc_unsol_event,
12170                 .init_hook = alc268_acer_lc_init_hook,
12171         },
12172         [ALC268_DELL] = {
12173                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12174                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12175                                 alc268_dell_verbs },
12176                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12177                 .dac_nids = alc268_dac_nids,
12178                 .hp_nid = 0x02,
12179                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12180                 .channel_mode = alc268_modes,
12181                 .unsol_event = alc268_dell_unsol_event,
12182                 .init_hook = alc268_dell_init_hook,
12183                 .input_mux = &alc268_capture_source,
12184         },
12185         [ALC268_ZEPTO] = {
12186                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12187                             alc268_beep_mixer },
12188                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12189                                 alc268_toshiba_verbs },
12190                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12191                 .dac_nids = alc268_dac_nids,
12192                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12193                 .adc_nids = alc268_adc_nids_alt,
12194                 .capsrc_nids = alc268_capsrc_nids,
12195                 .hp_nid = 0x03,
12196                 .dig_out_nid = ALC268_DIGOUT_NID,
12197                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12198                 .channel_mode = alc268_modes,
12199                 .input_mux = &alc268_capture_source,
12200                 .unsol_event = alc268_toshiba_unsol_event,
12201                 .init_hook = alc268_toshiba_automute
12202         },
12203 #ifdef CONFIG_SND_DEBUG
12204         [ALC268_TEST] = {
12205                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12206                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12207                                 alc268_volume_init_verbs },
12208                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12209                 .dac_nids = alc268_dac_nids,
12210                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12211                 .adc_nids = alc268_adc_nids_alt,
12212                 .capsrc_nids = alc268_capsrc_nids,
12213                 .hp_nid = 0x03,
12214                 .dig_out_nid = ALC268_DIGOUT_NID,
12215                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12216                 .channel_mode = alc268_modes,
12217                 .input_mux = &alc268_capture_source,
12218         },
12219 #endif
12220 };
12221
12222 static int patch_alc268(struct hda_codec *codec)
12223 {
12224         struct alc_spec *spec;
12225         int board_config;
12226         int i, has_beep, err;
12227
12228         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12229         if (spec == NULL)
12230                 return -ENOMEM;
12231
12232         codec->spec = spec;
12233
12234         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12235                                                   alc268_models,
12236                                                   alc268_cfg_tbl);
12237
12238         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12239                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12240                        "trying auto-probe from BIOS...\n");
12241                 board_config = ALC268_AUTO;
12242         }
12243
12244         if (board_config == ALC268_AUTO) {
12245                 /* automatic parse from the BIOS config */
12246                 err = alc268_parse_auto_config(codec);
12247                 if (err < 0) {
12248                         alc_free(codec);
12249                         return err;
12250                 } else if (!err) {
12251                         printk(KERN_INFO
12252                                "hda_codec: Cannot set up configuration "
12253                                "from BIOS.  Using base mode...\n");
12254                         board_config = ALC268_3ST;
12255                 }
12256         }
12257
12258         if (board_config != ALC268_AUTO)
12259                 setup_preset(spec, &alc268_presets[board_config]);
12260
12261         if (codec->vendor_id == 0x10ec0267) {
12262                 spec->stream_name_analog = "ALC267 Analog";
12263                 spec->stream_name_digital = "ALC267 Digital";
12264         } else {
12265                 spec->stream_name_analog = "ALC268 Analog";
12266                 spec->stream_name_digital = "ALC268 Digital";
12267         }
12268
12269         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12270         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12271         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12272
12273         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12274
12275         has_beep = 0;
12276         for (i = 0; i < spec->num_mixers; i++) {
12277                 if (spec->mixers[i] == alc268_beep_mixer) {
12278                         has_beep = 1;
12279                         break;
12280                 }
12281         }
12282
12283         if (has_beep) {
12284                 err = snd_hda_attach_beep_device(codec, 0x1);
12285                 if (err < 0) {
12286                         alc_free(codec);
12287                         return err;
12288                 }
12289                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12290                         /* override the amp caps for beep generator */
12291                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12292                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12293                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12294                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12295                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12296         }
12297
12298         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12299                 /* check whether NID 0x07 is valid */
12300                 unsigned int wcap = get_wcaps(codec, 0x07);
12301                 int i;
12302
12303                 /* get type */
12304                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12305                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12306                         spec->adc_nids = alc268_adc_nids_alt;
12307                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12308                         add_mixer(spec, alc268_capture_alt_mixer);
12309                 } else {
12310                         spec->adc_nids = alc268_adc_nids;
12311                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12312                         add_mixer(spec, alc268_capture_mixer);
12313                 }
12314                 spec->capsrc_nids = alc268_capsrc_nids;
12315                 /* set default input source */
12316                 for (i = 0; i < spec->num_adc_nids; i++)
12317                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12318                                 0, AC_VERB_SET_CONNECT_SEL,
12319                                 spec->input_mux->items[0].index);
12320         }
12321
12322         spec->vmaster_nid = 0x02;
12323
12324         codec->patch_ops = alc_patch_ops;
12325         if (board_config == ALC268_AUTO)
12326                 spec->init_hook = alc268_auto_init;
12327
12328         codec->proc_widget_hook = print_realtek_coef;
12329
12330         return 0;
12331 }
12332
12333 /*
12334  *  ALC269 channel source setting (2 channel)
12335  */
12336 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12337
12338 #define alc269_dac_nids         alc260_dac_nids
12339
12340 static hda_nid_t alc269_adc_nids[1] = {
12341         /* ADC1 */
12342         0x08,
12343 };
12344
12345 static hda_nid_t alc269_capsrc_nids[1] = {
12346         0x23,
12347 };
12348
12349 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12350  *       not a mux!
12351  */
12352
12353 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12354         .num_items = 2,
12355         .items = {
12356                 { "i-Mic", 0x5 },
12357                 { "e-Mic", 0x0 },
12358         },
12359 };
12360
12361 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12362         .num_items = 2,
12363         .items = {
12364                 { "i-Mic", 0x1 },
12365                 { "e-Mic", 0x0 },
12366         },
12367 };
12368
12369 #define alc269_modes            alc260_modes
12370 #define alc269_capture_source   alc880_lg_lw_capture_source
12371
12372 static struct snd_kcontrol_new alc269_base_mixer[] = {
12373         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12374         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12375         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12376         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12377         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12378         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12379         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12380         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12381         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12382         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12383         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12384         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12385         { } /* end */
12386 };
12387
12388 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12389         /* output mixer control */
12390         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12391         {
12392                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12393                 .name = "Master Playback Switch",
12394                 .info = snd_hda_mixer_amp_switch_info,
12395                 .get = snd_hda_mixer_amp_switch_get,
12396                 .put = alc268_acer_master_sw_put,
12397                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12398         },
12399         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12400         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12401         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12402         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12403         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12404         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12405         { }
12406 };
12407
12408 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12409         /* output mixer control */
12410         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12411         {
12412                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12413                 .name = "Master Playback Switch",
12414                 .info = snd_hda_mixer_amp_switch_info,
12415                 .get = snd_hda_mixer_amp_switch_get,
12416                 .put = alc268_acer_master_sw_put,
12417                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12418         },
12419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12420         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12421         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12422         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12423         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12424         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12425         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12426         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12427         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12428         { }
12429 };
12430
12431 /* bind volumes of both NID 0x0c and 0x0d */
12432 static struct hda_bind_ctls alc269_epc_bind_vol = {
12433         .ops = &snd_hda_bind_vol,
12434         .values = {
12435                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12436                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12437                 0
12438         },
12439 };
12440
12441 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12442         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12443         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12444         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12445         { } /* end */
12446 };
12447
12448 /* capture mixer elements */
12449 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12450         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12451         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12452         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12453         { } /* end */
12454 };
12455
12456 /* FSC amilo */
12457 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12458         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12459         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12460         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12461         { } /* end */
12462 };
12463
12464 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12465         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12466         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12467         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12468         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12469         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12470         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12471         { }
12472 };
12473
12474 static struct hda_verb alc269_lifebook_verbs[] = {
12475         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12476         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12477         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12478         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12479         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12480         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12481         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12482         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12483         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12484         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12485         { }
12486 };
12487
12488 /* toggle speaker-output according to the hp-jack state */
12489 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12490 {
12491         unsigned int present;
12492         unsigned char bits;
12493
12494         present = snd_hda_codec_read(codec, 0x15, 0,
12495                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12496         bits = present ? AMP_IN_MUTE(0) : 0;
12497         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12498                         AMP_IN_MUTE(0), bits);
12499         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12500                         AMP_IN_MUTE(0), bits);
12501
12502         snd_hda_codec_write(codec, 0x20, 0,
12503                         AC_VERB_SET_COEF_INDEX, 0x0c);
12504         snd_hda_codec_write(codec, 0x20, 0,
12505                         AC_VERB_SET_PROC_COEF, 0x680);
12506
12507         snd_hda_codec_write(codec, 0x20, 0,
12508                         AC_VERB_SET_COEF_INDEX, 0x0c);
12509         snd_hda_codec_write(codec, 0x20, 0,
12510                         AC_VERB_SET_PROC_COEF, 0x480);
12511 }
12512
12513 /* toggle speaker-output according to the hp-jacks state */
12514 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12515 {
12516         unsigned int present;
12517         unsigned char bits;
12518
12519         /* Check laptop headphone socket */
12520         present = snd_hda_codec_read(codec, 0x15, 0,
12521                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12522
12523         /* Check port replicator headphone socket */
12524         present |= snd_hda_codec_read(codec, 0x1a, 0,
12525                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12526
12527         bits = present ? AMP_IN_MUTE(0) : 0;
12528         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12529                         AMP_IN_MUTE(0), bits);
12530         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12531                         AMP_IN_MUTE(0), bits);
12532
12533         snd_hda_codec_write(codec, 0x20, 0,
12534                         AC_VERB_SET_COEF_INDEX, 0x0c);
12535         snd_hda_codec_write(codec, 0x20, 0,
12536                         AC_VERB_SET_PROC_COEF, 0x680);
12537
12538         snd_hda_codec_write(codec, 0x20, 0,
12539                         AC_VERB_SET_COEF_INDEX, 0x0c);
12540         snd_hda_codec_write(codec, 0x20, 0,
12541                         AC_VERB_SET_PROC_COEF, 0x480);
12542 }
12543
12544 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12545 {
12546         unsigned int present;
12547
12548         present = snd_hda_codec_read(codec, 0x18, 0,
12549                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12550         snd_hda_codec_write(codec, 0x23, 0,
12551                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12552 }
12553
12554 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12555 {
12556         unsigned int present_laptop;
12557         unsigned int present_dock;
12558
12559         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12560                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12561
12562         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12563                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12564
12565         /* Laptop mic port overrides dock mic port, design decision */
12566         if (present_dock)
12567                 snd_hda_codec_write(codec, 0x23, 0,
12568                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12569         if (present_laptop)
12570                 snd_hda_codec_write(codec, 0x23, 0,
12571                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12572         if (!present_dock && !present_laptop)
12573                 snd_hda_codec_write(codec, 0x23, 0,
12574                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12575 }
12576
12577 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12578                                     unsigned int res)
12579 {
12580         if ((res >> 26) == ALC880_HP_EVENT)
12581                 alc269_quanta_fl1_speaker_automute(codec);
12582         if ((res >> 26) == ALC880_MIC_EVENT)
12583                 alc269_quanta_fl1_mic_automute(codec);
12584 }
12585
12586 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12587                                         unsigned int res)
12588 {
12589         if ((res >> 26) == ALC880_HP_EVENT)
12590                 alc269_lifebook_speaker_automute(codec);
12591         if ((res >> 26) == ALC880_MIC_EVENT)
12592                 alc269_lifebook_mic_autoswitch(codec);
12593 }
12594
12595 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12596 {
12597         alc269_quanta_fl1_speaker_automute(codec);
12598         alc269_quanta_fl1_mic_automute(codec);
12599 }
12600
12601 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12602 {
12603         alc269_lifebook_speaker_automute(codec);
12604         alc269_lifebook_mic_autoswitch(codec);
12605 }
12606
12607 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12608         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12609         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12610         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12611         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12612         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12613         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12614         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12615         {}
12616 };
12617
12618 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12619         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12620         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12621         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12622         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12623         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12624         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12625         {}
12626 };
12627
12628 /* toggle speaker-output according to the hp-jack state */
12629 static void alc269_speaker_automute(struct hda_codec *codec)
12630 {
12631         unsigned int present;
12632         unsigned char bits;
12633
12634         present = snd_hda_codec_read(codec, 0x15, 0,
12635                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12636         bits = present ? AMP_IN_MUTE(0) : 0;
12637         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12638                                 AMP_IN_MUTE(0), bits);
12639         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12640                                 AMP_IN_MUTE(0), bits);
12641 }
12642
12643 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12644 {
12645         unsigned int present;
12646
12647         present = snd_hda_codec_read(codec, 0x18, 0,
12648                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12649         snd_hda_codec_write(codec, 0x23, 0,
12650                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12651 }
12652
12653 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12654 {
12655         unsigned int present;
12656
12657         present = snd_hda_codec_read(codec, 0x18, 0,
12658                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12659         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12660                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12661         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12662                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12663 }
12664
12665 /* unsolicited event for HP jack sensing */
12666 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12667                                      unsigned int res)
12668 {
12669         if ((res >> 26) == ALC880_HP_EVENT)
12670                 alc269_speaker_automute(codec);
12671
12672         if ((res >> 26) == ALC880_MIC_EVENT)
12673                 alc269_eeepc_dmic_automute(codec);
12674 }
12675
12676 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12677 {
12678         alc269_speaker_automute(codec);
12679         alc269_eeepc_dmic_automute(codec);
12680 }
12681
12682 /* unsolicited event for HP jack sensing */
12683 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12684                                      unsigned int res)
12685 {
12686         if ((res >> 26) == ALC880_HP_EVENT)
12687                 alc269_speaker_automute(codec);
12688
12689         if ((res >> 26) == ALC880_MIC_EVENT)
12690                 alc269_eeepc_amic_automute(codec);
12691 }
12692
12693 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12694 {
12695         alc269_speaker_automute(codec);
12696         alc269_eeepc_amic_automute(codec);
12697 }
12698
12699 /*
12700  * generic initialization of ADC, input mixers and output mixers
12701  */
12702 static struct hda_verb alc269_init_verbs[] = {
12703         /*
12704          * Unmute ADC0 and set the default input to mic-in
12705          */
12706         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12707
12708         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12709          * analog-loopback mixer widget
12710          * Note: PASD motherboards uses the Line In 2 as the input for
12711          * front panel mic (mic 2)
12712          */
12713         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12714         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12715         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12716         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12717         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12718         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12719
12720         /*
12721          * Set up output mixers (0x0c - 0x0e)
12722          */
12723         /* set vol=0 to output mixers */
12724         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12725         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12726
12727         /* set up input amps for analog loopback */
12728         /* Amp Indices: DAC = 0, mixer = 1 */
12729         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12730         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12731         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12732         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12733         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12734         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12735
12736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12737         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12738         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12739         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12740         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12741         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12742         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12743
12744         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12745         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12746         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12747         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12748         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12749         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12750         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12751
12752         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12753         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12754
12755         /* FIXME: use matrix-type input source selection */
12756         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12757         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12758         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12759         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12760         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12761         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12762
12763         /* set EAPD */
12764         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12765         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12766         { }
12767 };
12768
12769 /* add playback controls from the parsed DAC table */
12770 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12771                                              const struct auto_pin_cfg *cfg)
12772 {
12773         hda_nid_t nid;
12774         int err;
12775
12776         spec->multiout.num_dacs = 1;    /* only use one dac */
12777         spec->multiout.dac_nids = spec->private_dac_nids;
12778         spec->multiout.dac_nids[0] = 2;
12779
12780         nid = cfg->line_out_pins[0];
12781         if (nid) {
12782                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12783                                   "Front Playback Volume",
12784                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12785                 if (err < 0)
12786                         return err;
12787                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12788                                   "Front Playback Switch",
12789                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12790                 if (err < 0)
12791                         return err;
12792         }
12793
12794         nid = cfg->speaker_pins[0];
12795         if (nid) {
12796                 if (!cfg->line_out_pins[0]) {
12797                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12798                                           "Speaker Playback Volume",
12799                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12800                                                               HDA_OUTPUT));
12801                         if (err < 0)
12802                                 return err;
12803                 }
12804                 if (nid == 0x16) {
12805                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12806                                           "Speaker Playback Switch",
12807                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12808                                                               HDA_OUTPUT));
12809                         if (err < 0)
12810                                 return err;
12811                 } else {
12812                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12813                                           "Speaker Playback Switch",
12814                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12815                                                               HDA_OUTPUT));
12816                         if (err < 0)
12817                                 return err;
12818                 }
12819         }
12820         nid = cfg->hp_pins[0];
12821         if (nid) {
12822                 /* spec->multiout.hp_nid = 2; */
12823                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12824                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12825                                           "Headphone Playback Volume",
12826                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12827                                                               HDA_OUTPUT));
12828                         if (err < 0)
12829                                 return err;
12830                 }
12831                 if (nid == 0x16) {
12832                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12833                                           "Headphone Playback Switch",
12834                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12835                                                               HDA_OUTPUT));
12836                         if (err < 0)
12837                                 return err;
12838                 } else {
12839                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12840                                           "Headphone Playback Switch",
12841                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12842                                                               HDA_OUTPUT));
12843                         if (err < 0)
12844                                 return err;
12845                 }
12846         }
12847         return 0;
12848 }
12849
12850 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12851                                                 const struct auto_pin_cfg *cfg)
12852 {
12853         int err;
12854
12855         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12856         if (err < 0)
12857                 return err;
12858         /* digital-mic input pin is excluded in alc880_auto_create..()
12859          * because it's under 0x18
12860          */
12861         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12862             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12863                 struct hda_input_mux *imux = &spec->private_imux[0];
12864                 imux->items[imux->num_items].label = "Int Mic";
12865                 imux->items[imux->num_items].index = 0x05;
12866                 imux->num_items++;
12867         }
12868         return 0;
12869 }
12870
12871 #ifdef CONFIG_SND_HDA_POWER_SAVE
12872 #define alc269_loopbacks        alc880_loopbacks
12873 #endif
12874
12875 /* pcm configuration: identiacal with ALC880 */
12876 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12877 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12878 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12879 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12880
12881 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12882         .substreams = 1,
12883         .channels_min = 2,
12884         .channels_max = 8,
12885         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12886         /* NID is set in alc_build_pcms */
12887         .ops = {
12888                 .open = alc880_playback_pcm_open,
12889                 .prepare = alc880_playback_pcm_prepare,
12890                 .cleanup = alc880_playback_pcm_cleanup
12891         },
12892 };
12893
12894 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12895         .substreams = 1,
12896         .channels_min = 2,
12897         .channels_max = 2,
12898         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12899         /* NID is set in alc_build_pcms */
12900 };
12901
12902 /*
12903  * BIOS auto configuration
12904  */
12905 static int alc269_parse_auto_config(struct hda_codec *codec)
12906 {
12907         struct alc_spec *spec = codec->spec;
12908         int err;
12909         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12910
12911         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12912                                            alc269_ignore);
12913         if (err < 0)
12914                 return err;
12915
12916         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12917         if (err < 0)
12918                 return err;
12919         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12920         if (err < 0)
12921                 return err;
12922
12923         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12924
12925         if (spec->autocfg.dig_outs)
12926                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12927
12928         if (spec->kctls.list)
12929                 add_mixer(spec, spec->kctls.list);
12930
12931         add_verb(spec, alc269_init_verbs);
12932         spec->num_mux_defs = 1;
12933         spec->input_mux = &spec->private_imux[0];
12934         /* set default input source */
12935         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12936                                   0, AC_VERB_SET_CONNECT_SEL,
12937                                   spec->input_mux->items[0].index);
12938
12939         err = alc_auto_add_mic_boost(codec);
12940         if (err < 0)
12941                 return err;
12942
12943         if (!spec->cap_mixer && !spec->no_analog)
12944                 set_capture_mixer(spec);
12945
12946         return 1;
12947 }
12948
12949 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12950 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12951 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12952
12953
12954 /* init callback for auto-configuration model -- overriding the default init */
12955 static void alc269_auto_init(struct hda_codec *codec)
12956 {
12957         struct alc_spec *spec = codec->spec;
12958         alc269_auto_init_multi_out(codec);
12959         alc269_auto_init_hp_out(codec);
12960         alc269_auto_init_analog_input(codec);
12961         if (spec->unsol_event)
12962                 alc_inithook(codec);
12963 }
12964
12965 /*
12966  * configuration and preset
12967  */
12968 static const char *alc269_models[ALC269_MODEL_LAST] = {
12969         [ALC269_BASIC]                  = "basic",
12970         [ALC269_QUANTA_FL1]             = "quanta",
12971         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12972         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12973         [ALC269_FUJITSU]                = "fujitsu",
12974         [ALC269_LIFEBOOK]               = "lifebook"
12975 };
12976
12977 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12978         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12979         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12980                       ALC269_ASUS_EEEPC_P703),
12981         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
12982         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
12983         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
12984         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
12985         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
12986         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
12987         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12988                       ALC269_ASUS_EEEPC_P901),
12989         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12990                       ALC269_ASUS_EEEPC_P901),
12991         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
12992         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12993         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12994         {}
12995 };
12996
12997 static struct alc_config_preset alc269_presets[] = {
12998         [ALC269_BASIC] = {
12999                 .mixers = { alc269_base_mixer },
13000                 .init_verbs = { alc269_init_verbs },
13001                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13002                 .dac_nids = alc269_dac_nids,
13003                 .hp_nid = 0x03,
13004                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13005                 .channel_mode = alc269_modes,
13006                 .input_mux = &alc269_capture_source,
13007         },
13008         [ALC269_QUANTA_FL1] = {
13009                 .mixers = { alc269_quanta_fl1_mixer },
13010                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_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_capture_source,
13017                 .unsol_event = alc269_quanta_fl1_unsol_event,
13018                 .init_hook = alc269_quanta_fl1_init_hook,
13019         },
13020         [ALC269_ASUS_EEEPC_P703] = {
13021                 .mixers = { alc269_eeepc_mixer },
13022                 .cap_mixer = alc269_epc_capture_mixer,
13023                 .init_verbs = { alc269_init_verbs,
13024                                 alc269_eeepc_amic_init_verbs },
13025                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13026                 .dac_nids = alc269_dac_nids,
13027                 .hp_nid = 0x03,
13028                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13029                 .channel_mode = alc269_modes,
13030                 .input_mux = &alc269_eeepc_amic_capture_source,
13031                 .unsol_event = alc269_eeepc_amic_unsol_event,
13032                 .init_hook = alc269_eeepc_amic_inithook,
13033         },
13034         [ALC269_ASUS_EEEPC_P901] = {
13035                 .mixers = { alc269_eeepc_mixer },
13036                 .cap_mixer = alc269_epc_capture_mixer,
13037                 .init_verbs = { alc269_init_verbs,
13038                                 alc269_eeepc_dmic_init_verbs },
13039                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13040                 .dac_nids = alc269_dac_nids,
13041                 .hp_nid = 0x03,
13042                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13043                 .channel_mode = alc269_modes,
13044                 .input_mux = &alc269_eeepc_dmic_capture_source,
13045                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13046                 .init_hook = alc269_eeepc_dmic_inithook,
13047         },
13048         [ALC269_FUJITSU] = {
13049                 .mixers = { alc269_fujitsu_mixer },
13050                 .cap_mixer = alc269_epc_capture_mixer,
13051                 .init_verbs = { alc269_init_verbs,
13052                                 alc269_eeepc_dmic_init_verbs },
13053                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13054                 .dac_nids = alc269_dac_nids,
13055                 .hp_nid = 0x03,
13056                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13057                 .channel_mode = alc269_modes,
13058                 .input_mux = &alc269_eeepc_dmic_capture_source,
13059                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13060                 .init_hook = alc269_eeepc_dmic_inithook,
13061         },
13062         [ALC269_LIFEBOOK] = {
13063                 .mixers = { alc269_lifebook_mixer },
13064                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13065                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13066                 .dac_nids = alc269_dac_nids,
13067                 .hp_nid = 0x03,
13068                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13069                 .channel_mode = alc269_modes,
13070                 .input_mux = &alc269_capture_source,
13071                 .unsol_event = alc269_lifebook_unsol_event,
13072                 .init_hook = alc269_lifebook_init_hook,
13073         },
13074 };
13075
13076 static int patch_alc269(struct hda_codec *codec)
13077 {
13078         struct alc_spec *spec;
13079         int board_config;
13080         int err;
13081
13082         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13083         if (spec == NULL)
13084                 return -ENOMEM;
13085
13086         codec->spec = spec;
13087
13088         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13089
13090         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13091                                                   alc269_models,
13092                                                   alc269_cfg_tbl);
13093
13094         if (board_config < 0) {
13095                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
13096                        "trying auto-probe from BIOS...\n");
13097                 board_config = ALC269_AUTO;
13098         }
13099
13100         if (board_config == ALC269_AUTO) {
13101                 /* automatic parse from the BIOS config */
13102                 err = alc269_parse_auto_config(codec);
13103                 if (err < 0) {
13104                         alc_free(codec);
13105                         return err;
13106                 } else if (!err) {
13107                         printk(KERN_INFO
13108                                "hda_codec: Cannot set up configuration "
13109                                "from BIOS.  Using base mode...\n");
13110                         board_config = ALC269_BASIC;
13111                 }
13112         }
13113
13114         err = snd_hda_attach_beep_device(codec, 0x1);
13115         if (err < 0) {
13116                 alc_free(codec);
13117                 return err;
13118         }
13119
13120         if (board_config != ALC269_AUTO)
13121                 setup_preset(spec, &alc269_presets[board_config]);
13122
13123         spec->stream_name_analog = "ALC269 Analog";
13124         if (codec->subsystem_id == 0x17aa3bf8) {
13125                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13126                  * fix the sample rate of analog I/O to 44.1kHz
13127                  */
13128                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13129                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13130         } else {
13131                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13132                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13133         }
13134         spec->stream_name_digital = "ALC269 Digital";
13135         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13136         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13137
13138         spec->adc_nids = alc269_adc_nids;
13139         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13140         spec->capsrc_nids = alc269_capsrc_nids;
13141         if (!spec->cap_mixer)
13142                 set_capture_mixer(spec);
13143         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13144
13145         codec->patch_ops = alc_patch_ops;
13146         if (board_config == ALC269_AUTO)
13147                 spec->init_hook = alc269_auto_init;
13148 #ifdef CONFIG_SND_HDA_POWER_SAVE
13149         if (!spec->loopback.amplist)
13150                 spec->loopback.amplist = alc269_loopbacks;
13151 #endif
13152         codec->proc_widget_hook = print_realtek_coef;
13153
13154         return 0;
13155 }
13156
13157 /*
13158  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13159  */
13160
13161 /*
13162  * set the path ways for 2 channel output
13163  * need to set the codec line out and mic 1 pin widgets to inputs
13164  */
13165 static struct hda_verb alc861_threestack_ch2_init[] = {
13166         /* set pin widget 1Ah (line in) for input */
13167         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13168         /* set pin widget 18h (mic1/2) for input, for mic also enable
13169          * the vref
13170          */
13171         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13172
13173         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13174 #if 0
13175         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13176         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13177 #endif
13178         { } /* end */
13179 };
13180 /*
13181  * 6ch mode
13182  * need to set the codec line out and mic 1 pin widgets to outputs
13183  */
13184 static struct hda_verb alc861_threestack_ch6_init[] = {
13185         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13186         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13187         /* set pin widget 18h (mic1) for output (CLFE)*/
13188         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13189
13190         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13191         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13192
13193         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13194 #if 0
13195         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13196         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13197 #endif
13198         { } /* end */
13199 };
13200
13201 static struct hda_channel_mode alc861_threestack_modes[2] = {
13202         { 2, alc861_threestack_ch2_init },
13203         { 6, alc861_threestack_ch6_init },
13204 };
13205 /* Set mic1 as input and unmute the mixer */
13206 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13207         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13208         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13209         { } /* end */
13210 };
13211 /* Set mic1 as output and mute mixer */
13212 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13213         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13214         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13215         { } /* end */
13216 };
13217
13218 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13219         { 2, alc861_uniwill_m31_ch2_init },
13220         { 4, alc861_uniwill_m31_ch4_init },
13221 };
13222
13223 /* Set mic1 and line-in as input and unmute the mixer */
13224 static struct hda_verb alc861_asus_ch2_init[] = {
13225         /* set pin widget 1Ah (line in) for input */
13226         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13227         /* set pin widget 18h (mic1/2) for input, for mic also enable
13228          * the vref
13229          */
13230         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13231
13232         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13233 #if 0
13234         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13235         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13236 #endif
13237         { } /* end */
13238 };
13239 /* Set mic1 nad line-in as output and mute mixer */
13240 static struct hda_verb alc861_asus_ch6_init[] = {
13241         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13242         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13243         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13244         /* set pin widget 18h (mic1) for output (CLFE)*/
13245         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13246         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13247         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13248         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13249
13250         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13251 #if 0
13252         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13253         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13254 #endif
13255         { } /* end */
13256 };
13257
13258 static struct hda_channel_mode alc861_asus_modes[2] = {
13259         { 2, alc861_asus_ch2_init },
13260         { 6, alc861_asus_ch6_init },
13261 };
13262
13263 /* patch-ALC861 */
13264
13265 static struct snd_kcontrol_new alc861_base_mixer[] = {
13266         /* output mixer control */
13267         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13268         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13269         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13270         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13271         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13272
13273         /*Input mixer control */
13274         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13275            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13276         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13277         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13278         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13279         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13280         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13281         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13282         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13283         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13284
13285         { } /* end */
13286 };
13287
13288 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13289         /* output mixer control */
13290         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13291         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13292         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13293         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13294         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13295
13296         /* Input mixer control */
13297         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13298            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13299         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13300         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13301         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13302         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13303         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13304         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13305         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13306         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13307
13308         {
13309                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13310                 .name = "Channel Mode",
13311                 .info = alc_ch_mode_info,
13312                 .get = alc_ch_mode_get,
13313                 .put = alc_ch_mode_put,
13314                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13315         },
13316         { } /* end */
13317 };
13318
13319 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13320         /* output mixer control */
13321         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13322         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13323         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13324
13325         { } /* end */
13326 };
13327
13328 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13329         /* output mixer control */
13330         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13331         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13332         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13333         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13334         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13335
13336         /* Input mixer control */
13337         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13338            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13339         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13340         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13341         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13342         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13343         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13344         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13345         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13346         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13347
13348         {
13349                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13350                 .name = "Channel Mode",
13351                 .info = alc_ch_mode_info,
13352                 .get = alc_ch_mode_get,
13353                 .put = alc_ch_mode_put,
13354                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13355         },
13356         { } /* end */
13357 };
13358
13359 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13360         /* output mixer control */
13361         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13362         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13363         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13364         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13365         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13366
13367         /* Input mixer control */
13368         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13369         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13370         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13371         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13372         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13373         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13374         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13375         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13376         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13377         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13378
13379         {
13380                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13381                 .name = "Channel Mode",
13382                 .info = alc_ch_mode_info,
13383                 .get = alc_ch_mode_get,
13384                 .put = alc_ch_mode_put,
13385                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13386         },
13387         { }
13388 };
13389
13390 /* additional mixer */
13391 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13392         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13393         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13394         { }
13395 };
13396
13397 /*
13398  * generic initialization of ADC, input mixers and output mixers
13399  */
13400 static struct hda_verb alc861_base_init_verbs[] = {
13401         /*
13402          * Unmute ADC0 and set the default input to mic-in
13403          */
13404         /* port-A for surround (rear panel) */
13405         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13406         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13407         /* port-B for mic-in (rear panel) with vref */
13408         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13409         /* port-C for line-in (rear panel) */
13410         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13411         /* port-D for Front */
13412         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13413         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13414         /* port-E for HP out (front panel) */
13415         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13416         /* route front PCM to HP */
13417         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13418         /* port-F for mic-in (front panel) with vref */
13419         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13420         /* port-G for CLFE (rear panel) */
13421         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13422         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13423         /* port-H for side (rear panel) */
13424         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13425         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13426         /* CD-in */
13427         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13428         /* route front mic to ADC1*/
13429         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13430         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13431
13432         /* Unmute DAC0~3 & spdif out*/
13433         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13434         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13435         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13436         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13437         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13438
13439         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13440         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13441         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13442         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13443         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13444
13445         /* Unmute Stereo Mixer 15 */
13446         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13447         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13448         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13449         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13450
13451         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13452         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13453         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13454         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13455         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13456         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13457         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13458         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13459         /* hp used DAC 3 (Front) */
13460         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13461         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13462
13463         { }
13464 };
13465
13466 static struct hda_verb alc861_threestack_init_verbs[] = {
13467         /*
13468          * Unmute ADC0 and set the default input to mic-in
13469          */
13470         /* port-A for surround (rear panel) */
13471         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13472         /* port-B for mic-in (rear panel) with vref */
13473         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13474         /* port-C for line-in (rear panel) */
13475         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13476         /* port-D for Front */
13477         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13478         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13479         /* port-E for HP out (front panel) */
13480         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13481         /* route front PCM to HP */
13482         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13483         /* port-F for mic-in (front panel) with vref */
13484         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13485         /* port-G for CLFE (rear panel) */
13486         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13487         /* port-H for side (rear panel) */
13488         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13489         /* CD-in */
13490         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13491         /* route front mic to ADC1*/
13492         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13493         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13494         /* Unmute DAC0~3 & spdif out*/
13495         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13496         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13497         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13498         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13500
13501         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13502         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13503         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13504         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13505         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13506
13507         /* Unmute Stereo Mixer 15 */
13508         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13509         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13510         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13511         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13512
13513         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13514         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13515         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13516         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13517         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13518         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13519         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13520         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13521         /* hp used DAC 3 (Front) */
13522         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13523         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13524         { }
13525 };
13526
13527 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13528         /*
13529          * Unmute ADC0 and set the default input to mic-in
13530          */
13531         /* port-A for surround (rear panel) */
13532         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13533         /* port-B for mic-in (rear panel) with vref */
13534         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13535         /* port-C for line-in (rear panel) */
13536         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13537         /* port-D for Front */
13538         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13539         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13540         /* port-E for HP out (front panel) */
13541         /* this has to be set to VREF80 */
13542         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13543         /* route front PCM to HP */
13544         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13545         /* port-F for mic-in (front panel) with vref */
13546         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13547         /* port-G for CLFE (rear panel) */
13548         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13549         /* port-H for side (rear panel) */
13550         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13551         /* CD-in */
13552         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13553         /* route front mic to ADC1*/
13554         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13555         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13556         /* Unmute DAC0~3 & spdif out*/
13557         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13558         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13559         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13560         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13561         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13562
13563         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13564         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13565         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13566         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13567         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13568
13569         /* Unmute Stereo Mixer 15 */
13570         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13571         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13572         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13573         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13574
13575         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13576         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13577         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13578         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13579         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13580         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13581         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13582         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13583         /* hp used DAC 3 (Front) */
13584         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13585         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13586         { }
13587 };
13588
13589 static struct hda_verb alc861_asus_init_verbs[] = {
13590         /*
13591          * Unmute ADC0 and set the default input to mic-in
13592          */
13593         /* port-A for surround (rear panel)
13594          * according to codec#0 this is the HP jack
13595          */
13596         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13597         /* route front PCM to HP */
13598         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13599         /* port-B for mic-in (rear panel) with vref */
13600         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13601         /* port-C for line-in (rear panel) */
13602         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13603         /* port-D for Front */
13604         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13605         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13606         /* port-E for HP out (front panel) */
13607         /* this has to be set to VREF80 */
13608         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13609         /* route front PCM to HP */
13610         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13611         /* port-F for mic-in (front panel) with vref */
13612         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13613         /* port-G for CLFE (rear panel) */
13614         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13615         /* port-H for side (rear panel) */
13616         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13617         /* CD-in */
13618         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13619         /* route front mic to ADC1*/
13620         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13621         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13622         /* Unmute DAC0~3 & spdif out*/
13623         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13624         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13625         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13626         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13627         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13628         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13629         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13630         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13631         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13632         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13633
13634         /* Unmute Stereo Mixer 15 */
13635         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13636         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13637         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13638         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13639
13640         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13641         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13642         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13643         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13644         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13645         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13646         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13647         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13648         /* hp used DAC 3 (Front) */
13649         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13650         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13651         { }
13652 };
13653
13654 /* additional init verbs for ASUS laptops */
13655 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13656         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13657         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13658         { }
13659 };
13660
13661 /*
13662  * generic initialization of ADC, input mixers and output mixers
13663  */
13664 static struct hda_verb alc861_auto_init_verbs[] = {
13665         /*
13666          * Unmute ADC0 and set the default input to mic-in
13667          */
13668         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13669         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13670
13671         /* Unmute DAC0~3 & spdif out*/
13672         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13673         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13674         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13675         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13676         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13677
13678         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13679         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13680         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13681         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13682         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13683
13684         /* Unmute Stereo Mixer 15 */
13685         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13686         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13687         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13688         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13689
13690         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13691         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13692         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13693         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13694         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13695         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13696         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13697         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13698
13699         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13700         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13701         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13702         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13703         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13704         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13705         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13706         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13707
13708         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13709
13710         { }
13711 };
13712
13713 static struct hda_verb alc861_toshiba_init_verbs[] = {
13714         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13715
13716         { }
13717 };
13718
13719 /* toggle speaker-output according to the hp-jack state */
13720 static void alc861_toshiba_automute(struct hda_codec *codec)
13721 {
13722         unsigned int present;
13723
13724         present = snd_hda_codec_read(codec, 0x0f, 0,
13725                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13726         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13727                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13728         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13729                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13730 }
13731
13732 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13733                                        unsigned int res)
13734 {
13735         if ((res >> 26) == ALC880_HP_EVENT)
13736                 alc861_toshiba_automute(codec);
13737 }
13738
13739 /* pcm configuration: identiacal with ALC880 */
13740 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13741 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13742 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13743 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13744
13745
13746 #define ALC861_DIGOUT_NID       0x07
13747
13748 static struct hda_channel_mode alc861_8ch_modes[1] = {
13749         { 8, NULL }
13750 };
13751
13752 static hda_nid_t alc861_dac_nids[4] = {
13753         /* front, surround, clfe, side */
13754         0x03, 0x06, 0x05, 0x04
13755 };
13756
13757 static hda_nid_t alc660_dac_nids[3] = {
13758         /* front, clfe, surround */
13759         0x03, 0x05, 0x06
13760 };
13761
13762 static hda_nid_t alc861_adc_nids[1] = {
13763         /* ADC0-2 */
13764         0x08,
13765 };
13766
13767 static struct hda_input_mux alc861_capture_source = {
13768         .num_items = 5,
13769         .items = {
13770                 { "Mic", 0x0 },
13771                 { "Front Mic", 0x3 },
13772                 { "Line", 0x1 },
13773                 { "CD", 0x4 },
13774                 { "Mixer", 0x5 },
13775         },
13776 };
13777
13778 /* fill in the dac_nids table from the parsed pin configuration */
13779 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13780                                      const struct auto_pin_cfg *cfg)
13781 {
13782         int i;
13783         hda_nid_t nid;
13784
13785         spec->multiout.dac_nids = spec->private_dac_nids;
13786         for (i = 0; i < cfg->line_outs; i++) {
13787                 nid = cfg->line_out_pins[i];
13788                 if (nid) {
13789                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13790                                 continue;
13791                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13792                 }
13793         }
13794         spec->multiout.num_dacs = cfg->line_outs;
13795         return 0;
13796 }
13797
13798 /* add playback controls from the parsed DAC table */
13799 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13800                                              const struct auto_pin_cfg *cfg)
13801 {
13802         char name[32];
13803         static const char *chname[4] = {
13804                 "Front", "Surround", NULL /*CLFE*/, "Side"
13805         };
13806         hda_nid_t nid;
13807         int i, idx, err;
13808
13809         for (i = 0; i < cfg->line_outs; i++) {
13810                 nid = spec->multiout.dac_nids[i];
13811                 if (!nid)
13812                         continue;
13813                 if (nid == 0x05) {
13814                         /* Center/LFE */
13815                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13816                                           "Center Playback Switch",
13817                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13818                                                               HDA_OUTPUT));
13819                         if (err < 0)
13820                                 return err;
13821                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13822                                           "LFE Playback Switch",
13823                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13824                                                               HDA_OUTPUT));
13825                         if (err < 0)
13826                                 return err;
13827                 } else {
13828                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13829                              idx++)
13830                                 if (nid == alc861_dac_nids[idx])
13831                                         break;
13832                         sprintf(name, "%s Playback Switch", chname[idx]);
13833                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13834                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13835                                                               HDA_OUTPUT));
13836                         if (err < 0)
13837                                 return err;
13838                 }
13839         }
13840         return 0;
13841 }
13842
13843 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13844 {
13845         int err;
13846         hda_nid_t nid;
13847
13848         if (!pin)
13849                 return 0;
13850
13851         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13852                 nid = 0x03;
13853                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13854                                   "Headphone Playback Switch",
13855                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13856                 if (err < 0)
13857                         return err;
13858                 spec->multiout.hp_nid = nid;
13859         }
13860         return 0;
13861 }
13862
13863 /* create playback/capture controls for input pins */
13864 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13865                                                 const struct auto_pin_cfg *cfg)
13866 {
13867         struct hda_input_mux *imux = &spec->private_imux[0];
13868         int i, err, idx, idx1;
13869
13870         for (i = 0; i < AUTO_PIN_LAST; i++) {
13871                 switch (cfg->input_pins[i]) {
13872                 case 0x0c:
13873                         idx1 = 1;
13874                         idx = 2;        /* Line In */
13875                         break;
13876                 case 0x0f:
13877                         idx1 = 2;
13878                         idx = 2;        /* Line In */
13879                         break;
13880                 case 0x0d:
13881                         idx1 = 0;
13882                         idx = 1;        /* Mic In */
13883                         break;
13884                 case 0x10:
13885                         idx1 = 3;
13886                         idx = 1;        /* Mic In */
13887                         break;
13888                 case 0x11:
13889                         idx1 = 4;
13890                         idx = 0;        /* CD */
13891                         break;
13892                 default:
13893                         continue;
13894                 }
13895
13896                 err = new_analog_input(spec, cfg->input_pins[i],
13897                                        auto_pin_cfg_labels[i], idx, 0x15);
13898                 if (err < 0)
13899                         return err;
13900
13901                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13902                 imux->items[imux->num_items].index = idx1;
13903                 imux->num_items++;
13904         }
13905         return 0;
13906 }
13907
13908 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13909                                               hda_nid_t nid,
13910                                               int pin_type, int dac_idx)
13911 {
13912         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13913                             pin_type);
13914         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13915                             AMP_OUT_UNMUTE);
13916 }
13917
13918 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13919 {
13920         struct alc_spec *spec = codec->spec;
13921         int i;
13922
13923         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13924         for (i = 0; i < spec->autocfg.line_outs; i++) {
13925                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13926                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13927                 if (nid)
13928                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13929                                                           spec->multiout.dac_nids[i]);
13930         }
13931 }
13932
13933 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13934 {
13935         struct alc_spec *spec = codec->spec;
13936         hda_nid_t pin;
13937
13938         pin = spec->autocfg.hp_pins[0];
13939         if (pin) /* connect to front */
13940                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13941                                                   spec->multiout.dac_nids[0]);
13942         pin = spec->autocfg.speaker_pins[0];
13943         if (pin)
13944                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13945 }
13946
13947 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13948 {
13949         struct alc_spec *spec = codec->spec;
13950         int i;
13951
13952         for (i = 0; i < AUTO_PIN_LAST; i++) {
13953                 hda_nid_t nid = spec->autocfg.input_pins[i];
13954                 if (nid >= 0x0c && nid <= 0x11)
13955                         alc_set_input_pin(codec, nid, i);
13956         }
13957 }
13958
13959 /* parse the BIOS configuration and set up the alc_spec */
13960 /* return 1 if successful, 0 if the proper config is not found,
13961  * or a negative error code
13962  */
13963 static int alc861_parse_auto_config(struct hda_codec *codec)
13964 {
13965         struct alc_spec *spec = codec->spec;
13966         int err;
13967         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13968
13969         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13970                                            alc861_ignore);
13971         if (err < 0)
13972                 return err;
13973         if (!spec->autocfg.line_outs)
13974                 return 0; /* can't find valid BIOS pin config */
13975
13976         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13977         if (err < 0)
13978                 return err;
13979         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13980         if (err < 0)
13981                 return err;
13982         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13983         if (err < 0)
13984                 return err;
13985         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13986         if (err < 0)
13987                 return err;
13988
13989         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13990
13991         if (spec->autocfg.dig_outs)
13992                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13993
13994         if (spec->kctls.list)
13995                 add_mixer(spec, spec->kctls.list);
13996
13997         add_verb(spec, alc861_auto_init_verbs);
13998
13999         spec->num_mux_defs = 1;
14000         spec->input_mux = &spec->private_imux[0];
14001
14002         spec->adc_nids = alc861_adc_nids;
14003         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14004         set_capture_mixer(spec);
14005
14006         return 1;
14007 }
14008
14009 /* additional initialization for auto-configuration model */
14010 static void alc861_auto_init(struct hda_codec *codec)
14011 {
14012         struct alc_spec *spec = codec->spec;
14013         alc861_auto_init_multi_out(codec);
14014         alc861_auto_init_hp_out(codec);
14015         alc861_auto_init_analog_input(codec);
14016         if (spec->unsol_event)
14017                 alc_inithook(codec);
14018 }
14019
14020 #ifdef CONFIG_SND_HDA_POWER_SAVE
14021 static struct hda_amp_list alc861_loopbacks[] = {
14022         { 0x15, HDA_INPUT, 0 },
14023         { 0x15, HDA_INPUT, 1 },
14024         { 0x15, HDA_INPUT, 2 },
14025         { 0x15, HDA_INPUT, 3 },
14026         { } /* end */
14027 };
14028 #endif
14029
14030
14031 /*
14032  * configuration and preset
14033  */
14034 static const char *alc861_models[ALC861_MODEL_LAST] = {
14035         [ALC861_3ST]            = "3stack",
14036         [ALC660_3ST]            = "3stack-660",
14037         [ALC861_3ST_DIG]        = "3stack-dig",
14038         [ALC861_6ST_DIG]        = "6stack-dig",
14039         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14040         [ALC861_TOSHIBA]        = "toshiba",
14041         [ALC861_ASUS]           = "asus",
14042         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14043         [ALC861_AUTO]           = "auto",
14044 };
14045
14046 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14047         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14048         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14049         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14050         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14051         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14052         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14053         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14054         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14055          *        Any other models that need this preset?
14056          */
14057         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14058         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14059         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14060         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14061         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14062         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14063         /* FIXME: the below seems conflict */
14064         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14065         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14066         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14067         {}
14068 };
14069
14070 static struct alc_config_preset alc861_presets[] = {
14071         [ALC861_3ST] = {
14072                 .mixers = { alc861_3ST_mixer },
14073                 .init_verbs = { alc861_threestack_init_verbs },
14074                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14075                 .dac_nids = alc861_dac_nids,
14076                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14077                 .channel_mode = alc861_threestack_modes,
14078                 .need_dac_fix = 1,
14079                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14080                 .adc_nids = alc861_adc_nids,
14081                 .input_mux = &alc861_capture_source,
14082         },
14083         [ALC861_3ST_DIG] = {
14084                 .mixers = { alc861_base_mixer },
14085                 .init_verbs = { alc861_threestack_init_verbs },
14086                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14087                 .dac_nids = alc861_dac_nids,
14088                 .dig_out_nid = ALC861_DIGOUT_NID,
14089                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14090                 .channel_mode = alc861_threestack_modes,
14091                 .need_dac_fix = 1,
14092                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14093                 .adc_nids = alc861_adc_nids,
14094                 .input_mux = &alc861_capture_source,
14095         },
14096         [ALC861_6ST_DIG] = {
14097                 .mixers = { alc861_base_mixer },
14098                 .init_verbs = { alc861_base_init_verbs },
14099                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14100                 .dac_nids = alc861_dac_nids,
14101                 .dig_out_nid = ALC861_DIGOUT_NID,
14102                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14103                 .channel_mode = alc861_8ch_modes,
14104                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14105                 .adc_nids = alc861_adc_nids,
14106                 .input_mux = &alc861_capture_source,
14107         },
14108         [ALC660_3ST] = {
14109                 .mixers = { alc861_3ST_mixer },
14110                 .init_verbs = { alc861_threestack_init_verbs },
14111                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14112                 .dac_nids = alc660_dac_nids,
14113                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14114                 .channel_mode = alc861_threestack_modes,
14115                 .need_dac_fix = 1,
14116                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14117                 .adc_nids = alc861_adc_nids,
14118                 .input_mux = &alc861_capture_source,
14119         },
14120         [ALC861_UNIWILL_M31] = {
14121                 .mixers = { alc861_uniwill_m31_mixer },
14122                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14123                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14124                 .dac_nids = alc861_dac_nids,
14125                 .dig_out_nid = ALC861_DIGOUT_NID,
14126                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14127                 .channel_mode = alc861_uniwill_m31_modes,
14128                 .need_dac_fix = 1,
14129                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14130                 .adc_nids = alc861_adc_nids,
14131                 .input_mux = &alc861_capture_source,
14132         },
14133         [ALC861_TOSHIBA] = {
14134                 .mixers = { alc861_toshiba_mixer },
14135                 .init_verbs = { alc861_base_init_verbs,
14136                                 alc861_toshiba_init_verbs },
14137                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14138                 .dac_nids = alc861_dac_nids,
14139                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14140                 .channel_mode = alc883_3ST_2ch_modes,
14141                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14142                 .adc_nids = alc861_adc_nids,
14143                 .input_mux = &alc861_capture_source,
14144                 .unsol_event = alc861_toshiba_unsol_event,
14145                 .init_hook = alc861_toshiba_automute,
14146         },
14147         [ALC861_ASUS] = {
14148                 .mixers = { alc861_asus_mixer },
14149                 .init_verbs = { alc861_asus_init_verbs },
14150                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14151                 .dac_nids = alc861_dac_nids,
14152                 .dig_out_nid = ALC861_DIGOUT_NID,
14153                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14154                 .channel_mode = alc861_asus_modes,
14155                 .need_dac_fix = 1,
14156                 .hp_nid = 0x06,
14157                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14158                 .adc_nids = alc861_adc_nids,
14159                 .input_mux = &alc861_capture_source,
14160         },
14161         [ALC861_ASUS_LAPTOP] = {
14162                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14163                 .init_verbs = { alc861_asus_init_verbs,
14164                                 alc861_asus_laptop_init_verbs },
14165                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14166                 .dac_nids = alc861_dac_nids,
14167                 .dig_out_nid = ALC861_DIGOUT_NID,
14168                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14169                 .channel_mode = alc883_3ST_2ch_modes,
14170                 .need_dac_fix = 1,
14171                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14172                 .adc_nids = alc861_adc_nids,
14173                 .input_mux = &alc861_capture_source,
14174         },
14175 };
14176
14177
14178 static int patch_alc861(struct hda_codec *codec)
14179 {
14180         struct alc_spec *spec;
14181         int board_config;
14182         int err;
14183
14184         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14185         if (spec == NULL)
14186                 return -ENOMEM;
14187
14188         codec->spec = spec;
14189
14190         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14191                                                   alc861_models,
14192                                                   alc861_cfg_tbl);
14193
14194         if (board_config < 0) {
14195                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
14196                        "trying auto-probe from BIOS...\n");
14197                 board_config = ALC861_AUTO;
14198         }
14199
14200         if (board_config == ALC861_AUTO) {
14201                 /* automatic parse from the BIOS config */
14202                 err = alc861_parse_auto_config(codec);
14203                 if (err < 0) {
14204                         alc_free(codec);
14205                         return err;
14206                 } else if (!err) {
14207                         printk(KERN_INFO
14208                                "hda_codec: Cannot set up configuration "
14209                                "from BIOS.  Using base mode...\n");
14210                    board_config = ALC861_3ST_DIG;
14211                 }
14212         }
14213
14214         err = snd_hda_attach_beep_device(codec, 0x23);
14215         if (err < 0) {
14216                 alc_free(codec);
14217                 return err;
14218         }
14219
14220         if (board_config != ALC861_AUTO)
14221                 setup_preset(spec, &alc861_presets[board_config]);
14222
14223         spec->stream_name_analog = "ALC861 Analog";
14224         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14225         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14226
14227         spec->stream_name_digital = "ALC861 Digital";
14228         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14229         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14230
14231         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14232
14233         spec->vmaster_nid = 0x03;
14234
14235         codec->patch_ops = alc_patch_ops;
14236         if (board_config == ALC861_AUTO)
14237                 spec->init_hook = alc861_auto_init;
14238 #ifdef CONFIG_SND_HDA_POWER_SAVE
14239         if (!spec->loopback.amplist)
14240                 spec->loopback.amplist = alc861_loopbacks;
14241 #endif
14242         codec->proc_widget_hook = print_realtek_coef;
14243
14244         return 0;
14245 }
14246
14247 /*
14248  * ALC861-VD support
14249  *
14250  * Based on ALC882
14251  *
14252  * In addition, an independent DAC
14253  */
14254 #define ALC861VD_DIGOUT_NID     0x06
14255
14256 static hda_nid_t alc861vd_dac_nids[4] = {
14257         /* front, surr, clfe, side surr */
14258         0x02, 0x03, 0x04, 0x05
14259 };
14260
14261 /* dac_nids for ALC660vd are in a different order - according to
14262  * Realtek's driver.
14263  * This should probably tesult in a different mixer for 6stack models
14264  * of ALC660vd codecs, but for now there is only 3stack mixer
14265  * - and it is the same as in 861vd.
14266  * adc_nids in ALC660vd are (is) the same as in 861vd
14267  */
14268 static hda_nid_t alc660vd_dac_nids[3] = {
14269         /* front, rear, clfe, rear_surr */
14270         0x02, 0x04, 0x03
14271 };
14272
14273 static hda_nid_t alc861vd_adc_nids[1] = {
14274         /* ADC0 */
14275         0x09,
14276 };
14277
14278 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14279
14280 /* input MUX */
14281 /* FIXME: should be a matrix-type input source selection */
14282 static struct hda_input_mux alc861vd_capture_source = {
14283         .num_items = 4,
14284         .items = {
14285                 { "Mic", 0x0 },
14286                 { "Front Mic", 0x1 },
14287                 { "Line", 0x2 },
14288                 { "CD", 0x4 },
14289         },
14290 };
14291
14292 static struct hda_input_mux alc861vd_dallas_capture_source = {
14293         .num_items = 2,
14294         .items = {
14295                 { "Ext Mic", 0x0 },
14296                 { "Int Mic", 0x1 },
14297         },
14298 };
14299
14300 static struct hda_input_mux alc861vd_hp_capture_source = {
14301         .num_items = 2,
14302         .items = {
14303                 { "Front Mic", 0x0 },
14304                 { "ATAPI Mic", 0x1 },
14305         },
14306 };
14307
14308 /*
14309  * 2ch mode
14310  */
14311 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14312         { 2, NULL }
14313 };
14314
14315 /*
14316  * 6ch mode
14317  */
14318 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14319         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14320         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14321         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14322         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14323         { } /* end */
14324 };
14325
14326 /*
14327  * 8ch mode
14328  */
14329 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14330         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14331         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14332         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14333         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14334         { } /* end */
14335 };
14336
14337 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14338         { 6, alc861vd_6stack_ch6_init },
14339         { 8, alc861vd_6stack_ch8_init },
14340 };
14341
14342 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14343         {
14344                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14345                 .name = "Channel Mode",
14346                 .info = alc_ch_mode_info,
14347                 .get = alc_ch_mode_get,
14348                 .put = alc_ch_mode_put,
14349         },
14350         { } /* end */
14351 };
14352
14353 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14354  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14355  */
14356 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14357         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14358         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14359
14360         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14361         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14362
14363         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14364                                 HDA_OUTPUT),
14365         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14366                                 HDA_OUTPUT),
14367         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14368         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14369
14370         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14371         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14372
14373         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14374
14375         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14376         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14377         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14378
14379         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14380         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14381         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14382
14383         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14384         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, 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 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14393         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14394         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14395
14396         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14397
14398         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14399         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14400         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14401
14402         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14403         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14404         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14405
14406         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14407         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14408
14409         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14410         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14411
14412         { } /* end */
14413 };
14414
14415 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14416         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14417         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14418         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14419
14420         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14421
14422         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14423         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14424         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14425
14426         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14427         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14428         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14429
14430         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14431         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14432
14433         { } /* end */
14434 };
14435
14436 /* Pin assignment: Speaker=0x14, HP = 0x15,
14437  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14438  */
14439 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14440         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14441         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14442         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14443         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14444         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14445         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14446         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14447         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14448         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14449         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14450         { } /* end */
14451 };
14452
14453 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14454  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14455  */
14456 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14457         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14458         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14459         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14460         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14461         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14462         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14463         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14464         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14465
14466         { } /* end */
14467 };
14468
14469 /*
14470  * generic initialization of ADC, input mixers and output mixers
14471  */
14472 static struct hda_verb alc861vd_volume_init_verbs[] = {
14473         /*
14474          * Unmute ADC0 and set the default input to mic-in
14475          */
14476         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14477         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14478
14479         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14480          * the analog-loopback mixer widget
14481          */
14482         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14483         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14485         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14486         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14487         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14488
14489         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14490         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14491         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14492         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14493         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14494
14495         /*
14496          * Set up output mixers (0x02 - 0x05)
14497          */
14498         /* set vol=0 to output mixers */
14499         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14500         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14501         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14502         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14503
14504         /* set up input amps for analog loopback */
14505         /* Amp Indices: DAC = 0, mixer = 1 */
14506         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14507         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14508         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14510         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14511         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14512         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14513         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14514
14515         { }
14516 };
14517
14518 /*
14519  * 3-stack pin configuration:
14520  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14521  */
14522 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14523         /*
14524          * Set pin mode and muting
14525          */
14526         /* set front pin widgets 0x14 for output */
14527         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14528         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14529         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
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 /*
14551  * 6-stack pin configuration:
14552  */
14553 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14554         /*
14555          * Set pin mode and muting
14556          */
14557         /* set front pin widgets 0x14 for output */
14558         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14559         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14560         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14561
14562         /* Rear Pin: output 1 (0x0d) */
14563         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14564         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14565         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14566         /* CLFE Pin: output 2 (0x0e) */
14567         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14568         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14569         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14570         /* Side Pin: output 3 (0x0f) */
14571         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14572         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14573         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14574
14575         /* Mic (rear) pin: input vref at 80% */
14576         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14577         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14578         /* Front Mic pin: input vref at 80% */
14579         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14580         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14581         /* Line In pin: input */
14582         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14583         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14584         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14585         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14586         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14587         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14588         /* CD pin widget for input */
14589         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14590
14591         { }
14592 };
14593
14594 static struct hda_verb alc861vd_eapd_verbs[] = {
14595         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14596         { }
14597 };
14598
14599 static struct hda_verb alc660vd_eapd_verbs[] = {
14600         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14601         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14602         { }
14603 };
14604
14605 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14606         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14607         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14608         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14609         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14610         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14611         {}
14612 };
14613
14614 /* toggle speaker-output according to the hp-jack state */
14615 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14616 {
14617         unsigned int present;
14618         unsigned char bits;
14619
14620         present = snd_hda_codec_read(codec, 0x1b, 0,
14621                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14622         bits = present ? HDA_AMP_MUTE : 0;
14623         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14624                                  HDA_AMP_MUTE, bits);
14625 }
14626
14627 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14628 {
14629         unsigned int present;
14630         unsigned char bits;
14631
14632         present = snd_hda_codec_read(codec, 0x18, 0,
14633                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14634         bits = present ? HDA_AMP_MUTE : 0;
14635         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14636                                  HDA_AMP_MUTE, bits);
14637 }
14638
14639 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14640 {
14641         alc861vd_lenovo_hp_automute(codec);
14642         alc861vd_lenovo_mic_automute(codec);
14643 }
14644
14645 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14646                                         unsigned int res)
14647 {
14648         switch (res >> 26) {
14649         case ALC880_HP_EVENT:
14650                 alc861vd_lenovo_hp_automute(codec);
14651                 break;
14652         case ALC880_MIC_EVENT:
14653                 alc861vd_lenovo_mic_automute(codec);
14654                 break;
14655         }
14656 }
14657
14658 static struct hda_verb alc861vd_dallas_verbs[] = {
14659         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14660         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14661         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14662         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14663
14664         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14665         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14666         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14667         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14668         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14669         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14670         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14671         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14672
14673         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14674         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14675         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14676         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14677         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14678         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14679         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14680         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14681
14682         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14683         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14684         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14685         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14686         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14687         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14688         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14689         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14690
14691         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14692         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14693         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14694         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14695
14696         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14697         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14698         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14699
14700         { } /* end */
14701 };
14702
14703 /* toggle speaker-output according to the hp-jack state */
14704 static void alc861vd_dallas_automute(struct hda_codec *codec)
14705 {
14706         unsigned int present;
14707
14708         present = snd_hda_codec_read(codec, 0x15, 0,
14709                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14710         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14711                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14712 }
14713
14714 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14715 {
14716         if ((res >> 26) == ALC880_HP_EVENT)
14717                 alc861vd_dallas_automute(codec);
14718 }
14719
14720 #ifdef CONFIG_SND_HDA_POWER_SAVE
14721 #define alc861vd_loopbacks      alc880_loopbacks
14722 #endif
14723
14724 /* pcm configuration: identiacal with ALC880 */
14725 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14726 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14727 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14728 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14729
14730 /*
14731  * configuration and preset
14732  */
14733 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14734         [ALC660VD_3ST]          = "3stack-660",
14735         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14736         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14737         [ALC861VD_3ST]          = "3stack",
14738         [ALC861VD_3ST_DIG]      = "3stack-digout",
14739         [ALC861VD_6ST_DIG]      = "6stack-digout",
14740         [ALC861VD_LENOVO]       = "lenovo",
14741         [ALC861VD_DALLAS]       = "dallas",
14742         [ALC861VD_HP]           = "hp",
14743         [ALC861VD_AUTO]         = "auto",
14744 };
14745
14746 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14747         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14748         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14749         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14750         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14751         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14752         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14753         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14754         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14755         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14756         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14757         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14758         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14759         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14760         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14761         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14762         {}
14763 };
14764
14765 static struct alc_config_preset alc861vd_presets[] = {
14766         [ALC660VD_3ST] = {
14767                 .mixers = { alc861vd_3st_mixer },
14768                 .init_verbs = { alc861vd_volume_init_verbs,
14769                                  alc861vd_3stack_init_verbs },
14770                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14771                 .dac_nids = alc660vd_dac_nids,
14772                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14773                 .channel_mode = alc861vd_3stack_2ch_modes,
14774                 .input_mux = &alc861vd_capture_source,
14775         },
14776         [ALC660VD_3ST_DIG] = {
14777                 .mixers = { alc861vd_3st_mixer },
14778                 .init_verbs = { alc861vd_volume_init_verbs,
14779                                  alc861vd_3stack_init_verbs },
14780                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14781                 .dac_nids = alc660vd_dac_nids,
14782                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14783                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14784                 .channel_mode = alc861vd_3stack_2ch_modes,
14785                 .input_mux = &alc861vd_capture_source,
14786         },
14787         [ALC861VD_3ST] = {
14788                 .mixers = { alc861vd_3st_mixer },
14789                 .init_verbs = { alc861vd_volume_init_verbs,
14790                                  alc861vd_3stack_init_verbs },
14791                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14792                 .dac_nids = alc861vd_dac_nids,
14793                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14794                 .channel_mode = alc861vd_3stack_2ch_modes,
14795                 .input_mux = &alc861vd_capture_source,
14796         },
14797         [ALC861VD_3ST_DIG] = {
14798                 .mixers = { alc861vd_3st_mixer },
14799                 .init_verbs = { alc861vd_volume_init_verbs,
14800                                  alc861vd_3stack_init_verbs },
14801                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14802                 .dac_nids = alc861vd_dac_nids,
14803                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14804                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14805                 .channel_mode = alc861vd_3stack_2ch_modes,
14806                 .input_mux = &alc861vd_capture_source,
14807         },
14808         [ALC861VD_6ST_DIG] = {
14809                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14810                 .init_verbs = { alc861vd_volume_init_verbs,
14811                                 alc861vd_6stack_init_verbs },
14812                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14813                 .dac_nids = alc861vd_dac_nids,
14814                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14815                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14816                 .channel_mode = alc861vd_6stack_modes,
14817                 .input_mux = &alc861vd_capture_source,
14818         },
14819         [ALC861VD_LENOVO] = {
14820                 .mixers = { alc861vd_lenovo_mixer },
14821                 .init_verbs = { alc861vd_volume_init_verbs,
14822                                 alc861vd_3stack_init_verbs,
14823                                 alc861vd_eapd_verbs,
14824                                 alc861vd_lenovo_unsol_verbs },
14825                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14826                 .dac_nids = alc660vd_dac_nids,
14827                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14828                 .channel_mode = alc861vd_3stack_2ch_modes,
14829                 .input_mux = &alc861vd_capture_source,
14830                 .unsol_event = alc861vd_lenovo_unsol_event,
14831                 .init_hook = alc861vd_lenovo_automute,
14832         },
14833         [ALC861VD_DALLAS] = {
14834                 .mixers = { alc861vd_dallas_mixer },
14835                 .init_verbs = { alc861vd_dallas_verbs },
14836                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14837                 .dac_nids = alc861vd_dac_nids,
14838                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14839                 .channel_mode = alc861vd_3stack_2ch_modes,
14840                 .input_mux = &alc861vd_dallas_capture_source,
14841                 .unsol_event = alc861vd_dallas_unsol_event,
14842                 .init_hook = alc861vd_dallas_automute,
14843         },
14844         [ALC861VD_HP] = {
14845                 .mixers = { alc861vd_hp_mixer },
14846                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14847                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14848                 .dac_nids = alc861vd_dac_nids,
14849                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14850                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14851                 .channel_mode = alc861vd_3stack_2ch_modes,
14852                 .input_mux = &alc861vd_hp_capture_source,
14853                 .unsol_event = alc861vd_dallas_unsol_event,
14854                 .init_hook = alc861vd_dallas_automute,
14855         },
14856         [ALC660VD_ASUS_V1S] = {
14857                 .mixers = { alc861vd_lenovo_mixer },
14858                 .init_verbs = { alc861vd_volume_init_verbs,
14859                                 alc861vd_3stack_init_verbs,
14860                                 alc861vd_eapd_verbs,
14861                                 alc861vd_lenovo_unsol_verbs },
14862                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14863                 .dac_nids = alc660vd_dac_nids,
14864                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14865                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14866                 .channel_mode = alc861vd_3stack_2ch_modes,
14867                 .input_mux = &alc861vd_capture_source,
14868                 .unsol_event = alc861vd_lenovo_unsol_event,
14869                 .init_hook = alc861vd_lenovo_automute,
14870         },
14871 };
14872
14873 /*
14874  * BIOS auto configuration
14875  */
14876 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14877                                 hda_nid_t nid, int pin_type, int dac_idx)
14878 {
14879         alc_set_pin_output(codec, nid, pin_type);
14880 }
14881
14882 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14883 {
14884         struct alc_spec *spec = codec->spec;
14885         int i;
14886
14887         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14888         for (i = 0; i <= HDA_SIDE; i++) {
14889                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14890                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14891                 if (nid)
14892                         alc861vd_auto_set_output_and_unmute(codec, nid,
14893                                                             pin_type, i);
14894         }
14895 }
14896
14897
14898 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14899 {
14900         struct alc_spec *spec = codec->spec;
14901         hda_nid_t pin;
14902
14903         pin = spec->autocfg.hp_pins[0];
14904         if (pin) /* connect to front and  use dac 0 */
14905                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14906         pin = spec->autocfg.speaker_pins[0];
14907         if (pin)
14908                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14909 }
14910
14911 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14912 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14913
14914 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14915 {
14916         struct alc_spec *spec = codec->spec;
14917         int i;
14918
14919         for (i = 0; i < AUTO_PIN_LAST; i++) {
14920                 hda_nid_t nid = spec->autocfg.input_pins[i];
14921                 if (alc861vd_is_input_pin(nid)) {
14922                         alc_set_input_pin(codec, nid, i);
14923                         if (nid != ALC861VD_PIN_CD_NID &&
14924                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14925                                 snd_hda_codec_write(codec, nid, 0,
14926                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14927                                                 AMP_OUT_MUTE);
14928                 }
14929         }
14930 }
14931
14932 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14933
14934 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14935 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14936
14937 /* add playback controls from the parsed DAC table */
14938 /* Based on ALC880 version. But ALC861VD has separate,
14939  * different NIDs for mute/unmute switch and volume control */
14940 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14941                                              const struct auto_pin_cfg *cfg)
14942 {
14943         char name[32];
14944         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14945         hda_nid_t nid_v, nid_s;
14946         int i, err;
14947
14948         for (i = 0; i < cfg->line_outs; i++) {
14949                 if (!spec->multiout.dac_nids[i])
14950                         continue;
14951                 nid_v = alc861vd_idx_to_mixer_vol(
14952                                 alc880_dac_to_idx(
14953                                         spec->multiout.dac_nids[i]));
14954                 nid_s = alc861vd_idx_to_mixer_switch(
14955                                 alc880_dac_to_idx(
14956                                         spec->multiout.dac_nids[i]));
14957
14958                 if (i == 2) {
14959                         /* Center/LFE */
14960                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14961                                           "Center Playback Volume",
14962                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14963                                                               HDA_OUTPUT));
14964                         if (err < 0)
14965                                 return err;
14966                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14967                                           "LFE Playback Volume",
14968                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14969                                                               HDA_OUTPUT));
14970                         if (err < 0)
14971                                 return err;
14972                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14973                                           "Center Playback Switch",
14974                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14975                                                               HDA_INPUT));
14976                         if (err < 0)
14977                                 return err;
14978                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14979                                           "LFE Playback Switch",
14980                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14981                                                               HDA_INPUT));
14982                         if (err < 0)
14983                                 return err;
14984                 } else {
14985                         sprintf(name, "%s Playback Volume", chname[i]);
14986                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14987                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14988                                                               HDA_OUTPUT));
14989                         if (err < 0)
14990                                 return err;
14991                         sprintf(name, "%s Playback Switch", chname[i]);
14992                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14993                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14994                                                               HDA_INPUT));
14995                         if (err < 0)
14996                                 return err;
14997                 }
14998         }
14999         return 0;
15000 }
15001
15002 /* add playback controls for speaker and HP outputs */
15003 /* Based on ALC880 version. But ALC861VD has separate,
15004  * different NIDs for mute/unmute switch and volume control */
15005 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15006                                         hda_nid_t pin, const char *pfx)
15007 {
15008         hda_nid_t nid_v, nid_s;
15009         int err;
15010         char name[32];
15011
15012         if (!pin)
15013                 return 0;
15014
15015         if (alc880_is_fixed_pin(pin)) {
15016                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15017                 /* specify the DAC as the extra output */
15018                 if (!spec->multiout.hp_nid)
15019                         spec->multiout.hp_nid = nid_v;
15020                 else
15021                         spec->multiout.extra_out_nid[0] = nid_v;
15022                 /* control HP volume/switch on the output mixer amp */
15023                 nid_v = alc861vd_idx_to_mixer_vol(
15024                                 alc880_fixed_pin_idx(pin));
15025                 nid_s = alc861vd_idx_to_mixer_switch(
15026                                 alc880_fixed_pin_idx(pin));
15027
15028                 sprintf(name, "%s Playback Volume", pfx);
15029                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15030                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15031                 if (err < 0)
15032                         return err;
15033                 sprintf(name, "%s Playback Switch", pfx);
15034                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15035                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15036                 if (err < 0)
15037                         return err;
15038         } else if (alc880_is_multi_pin(pin)) {
15039                 /* set manual connection */
15040                 /* we have only a switch on HP-out PIN */
15041                 sprintf(name, "%s Playback Switch", pfx);
15042                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15043                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15044                 if (err < 0)
15045                         return err;
15046         }
15047         return 0;
15048 }
15049
15050 /* parse the BIOS configuration and set up the alc_spec
15051  * return 1 if successful, 0 if the proper config is not found,
15052  * or a negative error code
15053  * Based on ALC880 version - had to change it to override
15054  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15055 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15056 {
15057         struct alc_spec *spec = codec->spec;
15058         int err;
15059         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15060
15061         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15062                                            alc861vd_ignore);
15063         if (err < 0)
15064                 return err;
15065         if (!spec->autocfg.line_outs)
15066                 return 0; /* can't find valid BIOS pin config */
15067
15068         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15069         if (err < 0)
15070                 return err;
15071         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15072         if (err < 0)
15073                 return err;
15074         err = alc861vd_auto_create_extra_out(spec,
15075                                              spec->autocfg.speaker_pins[0],
15076                                              "Speaker");
15077         if (err < 0)
15078                 return err;
15079         err = alc861vd_auto_create_extra_out(spec,
15080                                              spec->autocfg.hp_pins[0],
15081                                              "Headphone");
15082         if (err < 0)
15083                 return err;
15084         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15085         if (err < 0)
15086                 return err;
15087
15088         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15089
15090         if (spec->autocfg.dig_outs)
15091                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15092
15093         if (spec->kctls.list)
15094                 add_mixer(spec, spec->kctls.list);
15095
15096         add_verb(spec, alc861vd_volume_init_verbs);
15097
15098         spec->num_mux_defs = 1;
15099         spec->input_mux = &spec->private_imux[0];
15100
15101         err = alc_auto_add_mic_boost(codec);
15102         if (err < 0)
15103                 return err;
15104
15105         return 1;
15106 }
15107
15108 /* additional initialization for auto-configuration model */
15109 static void alc861vd_auto_init(struct hda_codec *codec)
15110 {
15111         struct alc_spec *spec = codec->spec;
15112         alc861vd_auto_init_multi_out(codec);
15113         alc861vd_auto_init_hp_out(codec);
15114         alc861vd_auto_init_analog_input(codec);
15115         alc861vd_auto_init_input_src(codec);
15116         if (spec->unsol_event)
15117                 alc_inithook(codec);
15118 }
15119
15120 static int patch_alc861vd(struct hda_codec *codec)
15121 {
15122         struct alc_spec *spec;
15123         int err, board_config;
15124
15125         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15126         if (spec == NULL)
15127                 return -ENOMEM;
15128
15129         codec->spec = spec;
15130
15131         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15132                                                   alc861vd_models,
15133                                                   alc861vd_cfg_tbl);
15134
15135         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15136                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
15137                         "ALC861VD, trying auto-probe from BIOS...\n");
15138                 board_config = ALC861VD_AUTO;
15139         }
15140
15141         if (board_config == ALC861VD_AUTO) {
15142                 /* automatic parse from the BIOS config */
15143                 err = alc861vd_parse_auto_config(codec);
15144                 if (err < 0) {
15145                         alc_free(codec);
15146                         return err;
15147                 } else if (!err) {
15148                         printk(KERN_INFO
15149                                "hda_codec: Cannot set up configuration "
15150                                "from BIOS.  Using base mode...\n");
15151                         board_config = ALC861VD_3ST;
15152                 }
15153         }
15154
15155         err = snd_hda_attach_beep_device(codec, 0x23);
15156         if (err < 0) {
15157                 alc_free(codec);
15158                 return err;
15159         }
15160
15161         if (board_config != ALC861VD_AUTO)
15162                 setup_preset(spec, &alc861vd_presets[board_config]);
15163
15164         if (codec->vendor_id == 0x10ec0660) {
15165                 spec->stream_name_analog = "ALC660-VD Analog";
15166                 spec->stream_name_digital = "ALC660-VD Digital";
15167                 /* always turn on EAPD */
15168                 add_verb(spec, alc660vd_eapd_verbs);
15169         } else {
15170                 spec->stream_name_analog = "ALC861VD Analog";
15171                 spec->stream_name_digital = "ALC861VD Digital";
15172         }
15173
15174         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15175         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15176
15177         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15178         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15179
15180         spec->adc_nids = alc861vd_adc_nids;
15181         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15182         spec->capsrc_nids = alc861vd_capsrc_nids;
15183         spec->capture_style = CAPT_MIX;
15184
15185         set_capture_mixer(spec);
15186         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15187
15188         spec->vmaster_nid = 0x02;
15189
15190         codec->patch_ops = alc_patch_ops;
15191
15192         if (board_config == ALC861VD_AUTO)
15193                 spec->init_hook = alc861vd_auto_init;
15194 #ifdef CONFIG_SND_HDA_POWER_SAVE
15195         if (!spec->loopback.amplist)
15196                 spec->loopback.amplist = alc861vd_loopbacks;
15197 #endif
15198         codec->proc_widget_hook = print_realtek_coef;
15199
15200         return 0;
15201 }
15202
15203 /*
15204  * ALC662 support
15205  *
15206  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15207  * configuration.  Each pin widget can choose any input DACs and a mixer.
15208  * Each ADC is connected from a mixer of all inputs.  This makes possible
15209  * 6-channel independent captures.
15210  *
15211  * In addition, an independent DAC for the multi-playback (not used in this
15212  * driver yet).
15213  */
15214 #define ALC662_DIGOUT_NID       0x06
15215 #define ALC662_DIGIN_NID        0x0a
15216
15217 static hda_nid_t alc662_dac_nids[4] = {
15218         /* front, rear, clfe, rear_surr */
15219         0x02, 0x03, 0x04
15220 };
15221
15222 static hda_nid_t alc272_dac_nids[2] = {
15223         0x02, 0x03
15224 };
15225
15226 static hda_nid_t alc662_adc_nids[1] = {
15227         /* ADC1-2 */
15228         0x09,
15229 };
15230
15231 static hda_nid_t alc272_adc_nids[1] = {
15232         /* ADC1-2 */
15233         0x08,
15234 };
15235
15236 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15237 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15238
15239
15240 /* input MUX */
15241 /* FIXME: should be a matrix-type input source selection */
15242 static struct hda_input_mux alc662_capture_source = {
15243         .num_items = 4,
15244         .items = {
15245                 { "Mic", 0x0 },
15246                 { "Front Mic", 0x1 },
15247                 { "Line", 0x2 },
15248                 { "CD", 0x4 },
15249         },
15250 };
15251
15252 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15253         .num_items = 2,
15254         .items = {
15255                 { "Mic", 0x1 },
15256                 { "Line", 0x2 },
15257         },
15258 };
15259
15260 static struct hda_input_mux alc662_eeepc_capture_source = {
15261         .num_items = 2,
15262         .items = {
15263                 { "i-Mic", 0x1 },
15264                 { "e-Mic", 0x0 },
15265         },
15266 };
15267
15268 static struct hda_input_mux alc663_capture_source = {
15269         .num_items = 3,
15270         .items = {
15271                 { "Mic", 0x0 },
15272                 { "Front Mic", 0x1 },
15273                 { "Line", 0x2 },
15274         },
15275 };
15276
15277 static struct hda_input_mux alc663_m51va_capture_source = {
15278         .num_items = 2,
15279         .items = {
15280                 { "Ext-Mic", 0x0 },
15281                 { "D-Mic", 0x9 },
15282         },
15283 };
15284
15285 /*
15286  * 2ch mode
15287  */
15288 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15289         { 2, NULL }
15290 };
15291
15292 /*
15293  * 2ch mode
15294  */
15295 static struct hda_verb alc662_3ST_ch2_init[] = {
15296         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15297         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15298         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15299         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15300         { } /* end */
15301 };
15302
15303 /*
15304  * 6ch mode
15305  */
15306 static struct hda_verb alc662_3ST_ch6_init[] = {
15307         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15308         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15309         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15310         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15311         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15312         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15313         { } /* end */
15314 };
15315
15316 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15317         { 2, alc662_3ST_ch2_init },
15318         { 6, alc662_3ST_ch6_init },
15319 };
15320
15321 /*
15322  * 2ch mode
15323  */
15324 static struct hda_verb alc662_sixstack_ch6_init[] = {
15325         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15326         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15327         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15328         { } /* end */
15329 };
15330
15331 /*
15332  * 6ch mode
15333  */
15334 static struct hda_verb alc662_sixstack_ch8_init[] = {
15335         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15336         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15337         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15338         { } /* end */
15339 };
15340
15341 static struct hda_channel_mode alc662_5stack_modes[2] = {
15342         { 2, alc662_sixstack_ch6_init },
15343         { 6, alc662_sixstack_ch8_init },
15344 };
15345
15346 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15347  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15348  */
15349
15350 static struct snd_kcontrol_new alc662_base_mixer[] = {
15351         /* output mixer control */
15352         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15353         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15354         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15355         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15356         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15357         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15358         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15359         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15360         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15361
15362         /*Input mixer control */
15363         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15364         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15365         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15366         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15367         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15368         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15369         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15370         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15371         { } /* end */
15372 };
15373
15374 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15375         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15376         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15377         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15378         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15379         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15380         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15381         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15382         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15383         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15384         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15385         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15386         { } /* end */
15387 };
15388
15389 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15390         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15391         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15392         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15393         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15394         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15395         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15396         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15397         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15398         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15399         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15400         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15401         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15402         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15403         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15404         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15405         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15406         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15407         { } /* end */
15408 };
15409
15410 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15411         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15412         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15413         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15414         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15415         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15416         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15417         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15418         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15419         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15420         { } /* end */
15421 };
15422
15423 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15424         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15425
15426         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15427         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15428
15429         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15430         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15431         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15432
15433         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15434         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15435         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15436         { } /* end */
15437 };
15438
15439 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15440         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15441         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15442         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15443         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15444         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15445         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15446         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15447         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15448         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15449         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15450         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15451         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15452         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15453         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15454         { } /* end */
15455 };
15456
15457 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15458         .ops = &snd_hda_bind_vol,
15459         .values = {
15460                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15461                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15462                 0
15463         },
15464 };
15465
15466 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15467         .ops = &snd_hda_bind_sw,
15468         .values = {
15469                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15470                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15471                 0
15472         },
15473 };
15474
15475 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15476         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15477         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15478         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15479         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15480         { } /* end */
15481 };
15482
15483 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15484         .ops = &snd_hda_bind_sw,
15485         .values = {
15486                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15487                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15488                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15489                 0
15490         },
15491 };
15492
15493 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15494         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15495         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15496         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15497         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15498         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15499         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15500
15501         { } /* end */
15502 };
15503
15504 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15505         .ops = &snd_hda_bind_sw,
15506         .values = {
15507                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15508                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15509                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15510                 0
15511         },
15512 };
15513
15514 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15515         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15516         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15517         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15518         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15519         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15520         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15521         { } /* end */
15522 };
15523
15524 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15525         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15526         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15527         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15528         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15529         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15530         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15531         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15532         { } /* end */
15533 };
15534
15535 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15536         .ops = &snd_hda_bind_vol,
15537         .values = {
15538                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15539                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15540                 0
15541         },
15542 };
15543
15544 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15545         .ops = &snd_hda_bind_sw,
15546         .values = {
15547                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15548                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15549                 0
15550         },
15551 };
15552
15553 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15554         HDA_BIND_VOL("Master Playback Volume",
15555                                 &alc663_asus_two_bind_master_vol),
15556         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15557         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15558         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15559         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15560         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15561         { } /* end */
15562 };
15563
15564 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15565         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15566         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15567         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15568         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15569         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15570         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15571         { } /* end */
15572 };
15573
15574 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15575         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15576         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15577         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15578         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15579         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15580
15581         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15582         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15583         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15584         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15585         { } /* end */
15586 };
15587
15588 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15589         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15590         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15591         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15592
15593         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15594         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15595         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15596         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15597         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15598         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15599         { } /* end */
15600 };
15601
15602 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15603         {
15604                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15605                 .name = "Channel Mode",
15606                 .info = alc_ch_mode_info,
15607                 .get = alc_ch_mode_get,
15608                 .put = alc_ch_mode_put,
15609         },
15610         { } /* end */
15611 };
15612
15613 static struct hda_verb alc662_init_verbs[] = {
15614         /* ADC: mute amp left and right */
15615         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15616         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15617         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15618
15619         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15620         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15621         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15622         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15623         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15624
15625         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15626         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15627         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15628         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15629         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15630         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15631
15632         /* Front Pin: output 0 (0x0c) */
15633         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15634         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15635
15636         /* Rear Pin: output 1 (0x0d) */
15637         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15638         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15639
15640         /* CLFE Pin: output 2 (0x0e) */
15641         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15642         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15643
15644         /* Mic (rear) pin: input vref at 80% */
15645         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15646         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15647         /* Front Mic pin: input vref at 80% */
15648         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15649         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15650         /* Line In pin: input */
15651         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15653         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15654         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15655         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15656         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15657         /* CD pin widget for input */
15658         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15659
15660         /* FIXME: use matrix-type input source selection */
15661         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15662         /* Input mixer */
15663         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15664         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15665
15666         /* always trun on EAPD */
15667         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15668         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15669
15670         { }
15671 };
15672
15673 static struct hda_verb alc662_sue_init_verbs[] = {
15674         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15675         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15676         {}
15677 };
15678
15679 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15680         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15681         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15682         {}
15683 };
15684
15685 /* Set Unsolicited Event*/
15686 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15687         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15688         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15689         {}
15690 };
15691
15692 /*
15693  * generic initialization of ADC, input mixers and output mixers
15694  */
15695 static struct hda_verb alc662_auto_init_verbs[] = {
15696         /*
15697          * Unmute ADC and set the default input to mic-in
15698          */
15699         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15700         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15701
15702         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15703          * mixer widget
15704          * Note: PASD motherboards uses the Line In 2 as the input for front
15705          * panel mic (mic 2)
15706          */
15707         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15708         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15709         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15710         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15711         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15712         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15713
15714         /*
15715          * Set up output mixers (0x0c - 0x0f)
15716          */
15717         /* set vol=0 to output mixers */
15718         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15719         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15720         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15721
15722         /* set up input amps for analog loopback */
15723         /* Amp Indices: DAC = 0, mixer = 1 */
15724         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15725         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15726         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15727         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15728         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15729         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15730
15731
15732         /* FIXME: use matrix-type input source selection */
15733         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15734         /* Input mixer */
15735         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15736         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15737         { }
15738 };
15739
15740 /* additional verbs for ALC663 */
15741 static struct hda_verb alc663_auto_init_verbs[] = {
15742         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15743         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15744         { }
15745 };
15746
15747 static struct hda_verb alc663_m51va_init_verbs[] = {
15748         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15749         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15750         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15751         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15752         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15753         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15754         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15755         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15756         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15757         {}
15758 };
15759
15760 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15761         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15762         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15763         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15764         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15765         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15766         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15767         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15768         {}
15769 };
15770
15771 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15772         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15773         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15774         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15775         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15776         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15777         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15778         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15779         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15780         {}
15781 };
15782
15783 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15784         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15785         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15786         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15787         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15788         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15789         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15790         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15791         {}
15792 };
15793
15794 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15795         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15796         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15797         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15798         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15799         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15800         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15801         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15802         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15803         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15804         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15805         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15806         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15807         {}
15808 };
15809
15810 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15811         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15812         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15813         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15814         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15815         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15816         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15817         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15818         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15819         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15820         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15821         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15822         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15823         {}
15824 };
15825
15826 static struct hda_verb alc663_g71v_init_verbs[] = {
15827         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15828         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15829         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15830
15831         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15832         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15833         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15834
15835         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15836         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15837         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15838         {}
15839 };
15840
15841 static struct hda_verb alc663_g50v_init_verbs[] = {
15842         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15843         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15844         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15845
15846         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15847         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15848         {}
15849 };
15850
15851 static struct hda_verb alc662_ecs_init_verbs[] = {
15852         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15853         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15854         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15855         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15856         {}
15857 };
15858
15859 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
15860         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15861         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15862         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15863         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15864         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15865         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15866         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15867         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15868         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15869         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15870         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15871         {}
15872 };
15873
15874 static struct hda_verb alc272_dell_init_verbs[] = {
15875         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15876         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15877         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15878         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15879         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15880         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15881         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15882         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15883         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15884         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15885         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15886         {}
15887 };
15888
15889 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15890         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15891         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15892         { } /* end */
15893 };
15894
15895 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
15896         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
15897         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
15898         { } /* end */
15899 };
15900
15901 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15902 {
15903         unsigned int present;
15904         unsigned char bits;
15905
15906         present = snd_hda_codec_read(codec, 0x14, 0,
15907                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15908         bits = present ? HDA_AMP_MUTE : 0;
15909         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15910                                  HDA_AMP_MUTE, bits);
15911 }
15912
15913 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15914 {
15915         unsigned int present;
15916         unsigned char bits;
15917
15918         present = snd_hda_codec_read(codec, 0x1b, 0,
15919                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15920         bits = present ? HDA_AMP_MUTE : 0;
15921         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15922                                  HDA_AMP_MUTE, bits);
15923         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15924                                  HDA_AMP_MUTE, bits);
15925 }
15926
15927 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15928                                            unsigned int res)
15929 {
15930         if ((res >> 26) == ALC880_HP_EVENT)
15931                 alc662_lenovo_101e_all_automute(codec);
15932         if ((res >> 26) == ALC880_FRONT_EVENT)
15933                 alc662_lenovo_101e_ispeaker_automute(codec);
15934 }
15935
15936 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15937 {
15938         unsigned int present;
15939
15940         present = snd_hda_codec_read(codec, 0x18, 0,
15941                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15942         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15943                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15944         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15945                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15946         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15947                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15948         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15949                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15950 }
15951
15952 /* unsolicited event for HP jack sensing */
15953 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15954                                      unsigned int res)
15955 {
15956         if ((res >> 26) == ALC880_HP_EVENT)
15957                 alc262_hippo1_automute( codec );
15958
15959         if ((res >> 26) == ALC880_MIC_EVENT)
15960                 alc662_eeepc_mic_automute(codec);
15961 }
15962
15963 static void alc662_eeepc_inithook(struct hda_codec *codec)
15964 {
15965         alc262_hippo1_automute( codec );
15966         alc662_eeepc_mic_automute(codec);
15967 }
15968
15969 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15970 {
15971         unsigned int mute;
15972         unsigned int present;
15973
15974         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15975         present = snd_hda_codec_read(codec, 0x14, 0,
15976                                      AC_VERB_GET_PIN_SENSE, 0);
15977         present = (present & 0x80000000) != 0;
15978         if (present) {
15979                 /* mute internal speaker */
15980                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15981                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15982         } else {
15983                 /* unmute internal speaker if necessary */
15984                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15985                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15986                                         HDA_AMP_MUTE, mute);
15987         }
15988 }
15989
15990 /* unsolicited event for HP jack sensing */
15991 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15992                                           unsigned int res)
15993 {
15994         if ((res >> 26) == ALC880_HP_EVENT)
15995                 alc662_eeepc_ep20_automute(codec);
15996 }
15997
15998 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15999 {
16000         alc662_eeepc_ep20_automute(codec);
16001 }
16002
16003 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16004 {
16005         unsigned int present;
16006         unsigned char bits;
16007
16008         present = snd_hda_codec_read(codec, 0x21, 0,
16009                         AC_VERB_GET_PIN_SENSE, 0)
16010                         & AC_PINSENSE_PRESENCE;
16011         bits = present ? HDA_AMP_MUTE : 0;
16012         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16013                                 AMP_IN_MUTE(0), bits);
16014         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16015                                 AMP_IN_MUTE(0), bits);
16016 }
16017
16018 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16019 {
16020         unsigned int present;
16021         unsigned char bits;
16022
16023         present = snd_hda_codec_read(codec, 0x21, 0,
16024                         AC_VERB_GET_PIN_SENSE, 0)
16025                         & AC_PINSENSE_PRESENCE;
16026         bits = present ? HDA_AMP_MUTE : 0;
16027         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16028                                 AMP_IN_MUTE(0), bits);
16029         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16030                                 AMP_IN_MUTE(0), bits);
16031         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16032                                 AMP_IN_MUTE(0), bits);
16033         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16034                                 AMP_IN_MUTE(0), bits);
16035 }
16036
16037 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16038 {
16039         unsigned int present;
16040         unsigned char bits;
16041
16042         present = snd_hda_codec_read(codec, 0x15, 0,
16043                         AC_VERB_GET_PIN_SENSE, 0)
16044                         & AC_PINSENSE_PRESENCE;
16045         bits = present ? HDA_AMP_MUTE : 0;
16046         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16047                                 AMP_IN_MUTE(0), bits);
16048         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16049                                 AMP_IN_MUTE(0), bits);
16050         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16051                                 AMP_IN_MUTE(0), bits);
16052         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16053                                 AMP_IN_MUTE(0), bits);
16054 }
16055
16056 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16057 {
16058         unsigned int present;
16059         unsigned char bits;
16060
16061         present = snd_hda_codec_read(codec, 0x1b, 0,
16062                         AC_VERB_GET_PIN_SENSE, 0)
16063                         & AC_PINSENSE_PRESENCE;
16064         bits = present ? 0 : PIN_OUT;
16065         snd_hda_codec_write(codec, 0x14, 0,
16066                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16067 }
16068
16069 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16070 {
16071         unsigned int present1, present2;
16072
16073         present1 = snd_hda_codec_read(codec, 0x21, 0,
16074                         AC_VERB_GET_PIN_SENSE, 0)
16075                         & AC_PINSENSE_PRESENCE;
16076         present2 = snd_hda_codec_read(codec, 0x15, 0,
16077                         AC_VERB_GET_PIN_SENSE, 0)
16078                         & AC_PINSENSE_PRESENCE;
16079
16080         if (present1 || present2) {
16081                 snd_hda_codec_write_cache(codec, 0x14, 0,
16082                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16083         } else {
16084                 snd_hda_codec_write_cache(codec, 0x14, 0,
16085                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16086         }
16087 }
16088
16089 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16090 {
16091         unsigned int present1, present2;
16092
16093         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16094                                 AC_VERB_GET_PIN_SENSE, 0)
16095                                 & AC_PINSENSE_PRESENCE;
16096         present2 = snd_hda_codec_read(codec, 0x15, 0,
16097                                 AC_VERB_GET_PIN_SENSE, 0)
16098                                 & AC_PINSENSE_PRESENCE;
16099
16100         if (present1 || present2) {
16101                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16102                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16103                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16104                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16105         } else {
16106                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16107                                 AMP_IN_MUTE(0), 0);
16108                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16109                                 AMP_IN_MUTE(0), 0);
16110         }
16111 }
16112
16113 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16114 {
16115         unsigned int present;
16116
16117         present = snd_hda_codec_read(codec, 0x18, 0,
16118                         AC_VERB_GET_PIN_SENSE, 0)
16119                         & AC_PINSENSE_PRESENCE;
16120         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16121                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16122         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16123                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16124         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16125                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16126         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16127                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16128 }
16129
16130 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16131                                            unsigned int res)
16132 {
16133         switch (res >> 26) {
16134         case ALC880_HP_EVENT:
16135                 alc663_m51va_speaker_automute(codec);
16136                 break;
16137         case ALC880_MIC_EVENT:
16138                 alc663_m51va_mic_automute(codec);
16139                 break;
16140         }
16141 }
16142
16143 static void alc663_m51va_inithook(struct hda_codec *codec)
16144 {
16145         alc663_m51va_speaker_automute(codec);
16146         alc663_m51va_mic_automute(codec);
16147 }
16148
16149 /* ***************** Mode1 ******************************/
16150 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16151                                            unsigned int res)
16152 {
16153         switch (res >> 26) {
16154         case ALC880_HP_EVENT:
16155                 alc663_m51va_speaker_automute(codec);
16156                 break;
16157         case ALC880_MIC_EVENT:
16158                 alc662_eeepc_mic_automute(codec);
16159                 break;
16160         }
16161 }
16162
16163 static void alc663_mode1_inithook(struct hda_codec *codec)
16164 {
16165         alc663_m51va_speaker_automute(codec);
16166         alc662_eeepc_mic_automute(codec);
16167 }
16168 /* ***************** Mode2 ******************************/
16169 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16170                                            unsigned int res)
16171 {
16172         switch (res >> 26) {
16173         case ALC880_HP_EVENT:
16174                 alc662_f5z_speaker_automute(codec);
16175                 break;
16176         case ALC880_MIC_EVENT:
16177                 alc662_eeepc_mic_automute(codec);
16178                 break;
16179         }
16180 }
16181
16182 static void alc662_mode2_inithook(struct hda_codec *codec)
16183 {
16184         alc662_f5z_speaker_automute(codec);
16185         alc662_eeepc_mic_automute(codec);
16186 }
16187 /* ***************** Mode3 ******************************/
16188 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16189                                            unsigned int res)
16190 {
16191         switch (res >> 26) {
16192         case ALC880_HP_EVENT:
16193                 alc663_two_hp_m1_speaker_automute(codec);
16194                 break;
16195         case ALC880_MIC_EVENT:
16196                 alc662_eeepc_mic_automute(codec);
16197                 break;
16198         }
16199 }
16200
16201 static void alc663_mode3_inithook(struct hda_codec *codec)
16202 {
16203         alc663_two_hp_m1_speaker_automute(codec);
16204         alc662_eeepc_mic_automute(codec);
16205 }
16206 /* ***************** Mode4 ******************************/
16207 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16208                                            unsigned int res)
16209 {
16210         switch (res >> 26) {
16211         case ALC880_HP_EVENT:
16212                 alc663_21jd_two_speaker_automute(codec);
16213                 break;
16214         case ALC880_MIC_EVENT:
16215                 alc662_eeepc_mic_automute(codec);
16216                 break;
16217         }
16218 }
16219
16220 static void alc663_mode4_inithook(struct hda_codec *codec)
16221 {
16222         alc663_21jd_two_speaker_automute(codec);
16223         alc662_eeepc_mic_automute(codec);
16224 }
16225 /* ***************** Mode5 ******************************/
16226 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16227                                            unsigned int res)
16228 {
16229         switch (res >> 26) {
16230         case ALC880_HP_EVENT:
16231                 alc663_15jd_two_speaker_automute(codec);
16232                 break;
16233         case ALC880_MIC_EVENT:
16234                 alc662_eeepc_mic_automute(codec);
16235                 break;
16236         }
16237 }
16238
16239 static void alc663_mode5_inithook(struct hda_codec *codec)
16240 {
16241         alc663_15jd_two_speaker_automute(codec);
16242         alc662_eeepc_mic_automute(codec);
16243 }
16244 /* ***************** Mode6 ******************************/
16245 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16246                                            unsigned int res)
16247 {
16248         switch (res >> 26) {
16249         case ALC880_HP_EVENT:
16250                 alc663_two_hp_m2_speaker_automute(codec);
16251                 break;
16252         case ALC880_MIC_EVENT:
16253                 alc662_eeepc_mic_automute(codec);
16254                 break;
16255         }
16256 }
16257
16258 static void alc663_mode6_inithook(struct hda_codec *codec)
16259 {
16260         alc663_two_hp_m2_speaker_automute(codec);
16261         alc662_eeepc_mic_automute(codec);
16262 }
16263
16264 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16265 {
16266         unsigned int present;
16267         unsigned char bits;
16268
16269         present = snd_hda_codec_read(codec, 0x21, 0,
16270                                      AC_VERB_GET_PIN_SENSE, 0)
16271                 & AC_PINSENSE_PRESENCE;
16272         bits = present ? HDA_AMP_MUTE : 0;
16273         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16274                                  HDA_AMP_MUTE, bits);
16275         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16276                                  HDA_AMP_MUTE, bits);
16277 }
16278
16279 static void alc663_g71v_front_automute(struct hda_codec *codec)
16280 {
16281         unsigned int present;
16282         unsigned char bits;
16283
16284         present = snd_hda_codec_read(codec, 0x15, 0,
16285                                      AC_VERB_GET_PIN_SENSE, 0)
16286                 & AC_PINSENSE_PRESENCE;
16287         bits = present ? HDA_AMP_MUTE : 0;
16288         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16289                                  HDA_AMP_MUTE, bits);
16290 }
16291
16292 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16293                                            unsigned int res)
16294 {
16295         switch (res >> 26) {
16296         case ALC880_HP_EVENT:
16297                 alc663_g71v_hp_automute(codec);
16298                 break;
16299         case ALC880_FRONT_EVENT:
16300                 alc663_g71v_front_automute(codec);
16301                 break;
16302         case ALC880_MIC_EVENT:
16303                 alc662_eeepc_mic_automute(codec);
16304                 break;
16305         }
16306 }
16307
16308 static void alc663_g71v_inithook(struct hda_codec *codec)
16309 {
16310         alc663_g71v_front_automute(codec);
16311         alc663_g71v_hp_automute(codec);
16312         alc662_eeepc_mic_automute(codec);
16313 }
16314
16315 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16316                                            unsigned int res)
16317 {
16318         switch (res >> 26) {
16319         case ALC880_HP_EVENT:
16320                 alc663_m51va_speaker_automute(codec);
16321                 break;
16322         case ALC880_MIC_EVENT:
16323                 alc662_eeepc_mic_automute(codec);
16324                 break;
16325         }
16326 }
16327
16328 static void alc663_g50v_inithook(struct hda_codec *codec)
16329 {
16330         alc663_m51va_speaker_automute(codec);
16331         alc662_eeepc_mic_automute(codec);
16332 }
16333
16334 /* bind hp and internal speaker mute (with plug check) */
16335 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16336                                      struct snd_ctl_elem_value *ucontrol)
16337 {
16338         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16339         long *valp = ucontrol->value.integer.value;
16340         int change;
16341
16342         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16343                                           HDA_AMP_MUTE,
16344                                           valp[0] ? 0 : HDA_AMP_MUTE);
16345         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16346                                            HDA_AMP_MUTE,
16347                                            valp[1] ? 0 : HDA_AMP_MUTE);
16348         if (change)
16349                 alc262_hippo1_automute(codec);
16350         return change;
16351 }
16352
16353 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16354         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16355         {
16356                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16357                 .name = "Master Playback Switch",
16358                 .info = snd_hda_mixer_amp_switch_info,
16359                 .get = snd_hda_mixer_amp_switch_get,
16360                 .put = alc662_ecs_master_sw_put,
16361                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16362         },
16363
16364         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16365         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16366         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16367
16368         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16369         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16370         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16371         { } /* end */
16372 };
16373
16374 #ifdef CONFIG_SND_HDA_POWER_SAVE
16375 #define alc662_loopbacks        alc880_loopbacks
16376 #endif
16377
16378
16379 /* pcm configuration: identiacal with ALC880 */
16380 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16381 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16382 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16383 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16384
16385 /*
16386  * configuration and preset
16387  */
16388 static const char *alc662_models[ALC662_MODEL_LAST] = {
16389         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16390         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16391         [ALC662_3ST_6ch]        = "3stack-6ch",
16392         [ALC662_5ST_DIG]        = "6stack-dig",
16393         [ALC662_LENOVO_101E]    = "lenovo-101e",
16394         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16395         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16396         [ALC662_ECS] = "ecs",
16397         [ALC663_ASUS_M51VA] = "m51va",
16398         [ALC663_ASUS_G71V] = "g71v",
16399         [ALC663_ASUS_H13] = "h13",
16400         [ALC663_ASUS_G50V] = "g50v",
16401         [ALC663_ASUS_MODE1] = "asus-mode1",
16402         [ALC662_ASUS_MODE2] = "asus-mode2",
16403         [ALC663_ASUS_MODE3] = "asus-mode3",
16404         [ALC663_ASUS_MODE4] = "asus-mode4",
16405         [ALC663_ASUS_MODE5] = "asus-mode5",
16406         [ALC663_ASUS_MODE6] = "asus-mode6",
16407         [ALC662_AUTO]           = "auto",
16408 };
16409
16410 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16411         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16412         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16413         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16414         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16415         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16416         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16417         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16418         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16419         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16420         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16421         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16422         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16423         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16424         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16425         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16426         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16427         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16428         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16429         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16430         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16431         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16432         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16433         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16434         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16435         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16436         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16437         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16438         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16439         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16440         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16441         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16442         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16443         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16444         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16445         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16446         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16447         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16448         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16449         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16450         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16451         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16452         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16453         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16454         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16455         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16456         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16457         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16458         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16459         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16460         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16461         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16462         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16463                       ALC662_3ST_6ch_DIG),
16464         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16465                       ALC662_3ST_6ch_DIG),
16466         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16467         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16468         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16469         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16470                                         ALC662_3ST_6ch_DIG),
16471         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16472                            ALC663_ASUS_H13),
16473         {}
16474 };
16475
16476 static struct alc_config_preset alc662_presets[] = {
16477         [ALC662_3ST_2ch_DIG] = {
16478                 .mixers = { alc662_3ST_2ch_mixer },
16479                 .init_verbs = { alc662_init_verbs },
16480                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16481                 .dac_nids = alc662_dac_nids,
16482                 .dig_out_nid = ALC662_DIGOUT_NID,
16483                 .dig_in_nid = ALC662_DIGIN_NID,
16484                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16485                 .channel_mode = alc662_3ST_2ch_modes,
16486                 .input_mux = &alc662_capture_source,
16487         },
16488         [ALC662_3ST_6ch_DIG] = {
16489                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16490                 .init_verbs = { alc662_init_verbs },
16491                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16492                 .dac_nids = alc662_dac_nids,
16493                 .dig_out_nid = ALC662_DIGOUT_NID,
16494                 .dig_in_nid = ALC662_DIGIN_NID,
16495                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16496                 .channel_mode = alc662_3ST_6ch_modes,
16497                 .need_dac_fix = 1,
16498                 .input_mux = &alc662_capture_source,
16499         },
16500         [ALC662_3ST_6ch] = {
16501                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16502                 .init_verbs = { alc662_init_verbs },
16503                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16504                 .dac_nids = alc662_dac_nids,
16505                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16506                 .channel_mode = alc662_3ST_6ch_modes,
16507                 .need_dac_fix = 1,
16508                 .input_mux = &alc662_capture_source,
16509         },
16510         [ALC662_5ST_DIG] = {
16511                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16512                 .init_verbs = { alc662_init_verbs },
16513                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16514                 .dac_nids = alc662_dac_nids,
16515                 .dig_out_nid = ALC662_DIGOUT_NID,
16516                 .dig_in_nid = ALC662_DIGIN_NID,
16517                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16518                 .channel_mode = alc662_5stack_modes,
16519                 .input_mux = &alc662_capture_source,
16520         },
16521         [ALC662_LENOVO_101E] = {
16522                 .mixers = { alc662_lenovo_101e_mixer },
16523                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16524                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16525                 .dac_nids = alc662_dac_nids,
16526                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16527                 .channel_mode = alc662_3ST_2ch_modes,
16528                 .input_mux = &alc662_lenovo_101e_capture_source,
16529                 .unsol_event = alc662_lenovo_101e_unsol_event,
16530                 .init_hook = alc662_lenovo_101e_all_automute,
16531         },
16532         [ALC662_ASUS_EEEPC_P701] = {
16533                 .mixers = { alc662_eeepc_p701_mixer },
16534                 .init_verbs = { alc662_init_verbs,
16535                                 alc662_eeepc_sue_init_verbs },
16536                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16537                 .dac_nids = alc662_dac_nids,
16538                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16539                 .channel_mode = alc662_3ST_2ch_modes,
16540                 .input_mux = &alc662_eeepc_capture_source,
16541                 .unsol_event = alc662_eeepc_unsol_event,
16542                 .init_hook = alc662_eeepc_inithook,
16543         },
16544         [ALC662_ASUS_EEEPC_EP20] = {
16545                 .mixers = { alc662_eeepc_ep20_mixer,
16546                             alc662_chmode_mixer },
16547                 .init_verbs = { alc662_init_verbs,
16548                                 alc662_eeepc_ep20_sue_init_verbs },
16549                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16550                 .dac_nids = alc662_dac_nids,
16551                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16552                 .channel_mode = alc662_3ST_6ch_modes,
16553                 .input_mux = &alc662_lenovo_101e_capture_source,
16554                 .unsol_event = alc662_eeepc_ep20_unsol_event,
16555                 .init_hook = alc662_eeepc_ep20_inithook,
16556         },
16557         [ALC662_ECS] = {
16558                 .mixers = { alc662_ecs_mixer },
16559                 .init_verbs = { alc662_init_verbs,
16560                                 alc662_ecs_init_verbs },
16561                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16562                 .dac_nids = alc662_dac_nids,
16563                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16564                 .channel_mode = alc662_3ST_2ch_modes,
16565                 .input_mux = &alc662_eeepc_capture_source,
16566                 .unsol_event = alc662_eeepc_unsol_event,
16567                 .init_hook = alc662_eeepc_inithook,
16568         },
16569         [ALC663_ASUS_M51VA] = {
16570                 .mixers = { alc663_m51va_mixer },
16571                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16572                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
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 = &alc663_m51va_capture_source,
16578                 .unsol_event = alc663_m51va_unsol_event,
16579                 .init_hook = alc663_m51va_inithook,
16580         },
16581         [ALC663_ASUS_G71V] = {
16582                 .mixers = { alc663_g71v_mixer },
16583                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16584                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16585                 .dac_nids = alc662_dac_nids,
16586                 .dig_out_nid = ALC662_DIGOUT_NID,
16587                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16588                 .channel_mode = alc662_3ST_2ch_modes,
16589                 .input_mux = &alc662_eeepc_capture_source,
16590                 .unsol_event = alc663_g71v_unsol_event,
16591                 .init_hook = alc663_g71v_inithook,
16592         },
16593         [ALC663_ASUS_H13] = {
16594                 .mixers = { alc663_m51va_mixer },
16595                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16596                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16597                 .dac_nids = alc662_dac_nids,
16598                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16599                 .channel_mode = alc662_3ST_2ch_modes,
16600                 .input_mux = &alc663_m51va_capture_source,
16601                 .unsol_event = alc663_m51va_unsol_event,
16602                 .init_hook = alc663_m51va_inithook,
16603         },
16604         [ALC663_ASUS_G50V] = {
16605                 .mixers = { alc663_g50v_mixer },
16606                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16607                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16608                 .dac_nids = alc662_dac_nids,
16609                 .dig_out_nid = ALC662_DIGOUT_NID,
16610                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16611                 .channel_mode = alc662_3ST_6ch_modes,
16612                 .input_mux = &alc663_capture_source,
16613                 .unsol_event = alc663_g50v_unsol_event,
16614                 .init_hook = alc663_g50v_inithook,
16615         },
16616         [ALC663_ASUS_MODE1] = {
16617                 .mixers = { alc663_m51va_mixer },
16618                 .cap_mixer = alc662_auto_capture_mixer,
16619                 .init_verbs = { alc662_init_verbs,
16620                                 alc663_21jd_amic_init_verbs },
16621                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16622                 .hp_nid = 0x03,
16623                 .dac_nids = alc662_dac_nids,
16624                 .dig_out_nid = ALC662_DIGOUT_NID,
16625                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16626                 .channel_mode = alc662_3ST_2ch_modes,
16627                 .input_mux = &alc662_eeepc_capture_source,
16628                 .unsol_event = alc663_mode1_unsol_event,
16629                 .init_hook = alc663_mode1_inithook,
16630         },
16631         [ALC662_ASUS_MODE2] = {
16632                 .mixers = { alc662_1bjd_mixer },
16633                 .cap_mixer = alc662_auto_capture_mixer,
16634                 .init_verbs = { alc662_init_verbs,
16635                                 alc662_1bjd_amic_init_verbs },
16636                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16637                 .dac_nids = alc662_dac_nids,
16638                 .dig_out_nid = ALC662_DIGOUT_NID,
16639                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16640                 .channel_mode = alc662_3ST_2ch_modes,
16641                 .input_mux = &alc662_eeepc_capture_source,
16642                 .unsol_event = alc662_mode2_unsol_event,
16643                 .init_hook = alc662_mode2_inithook,
16644         },
16645         [ALC663_ASUS_MODE3] = {
16646                 .mixers = { alc663_two_hp_m1_mixer },
16647                 .cap_mixer = alc662_auto_capture_mixer,
16648                 .init_verbs = { alc662_init_verbs,
16649                                 alc663_two_hp_amic_m1_init_verbs },
16650                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16651                 .hp_nid = 0x03,
16652                 .dac_nids = alc662_dac_nids,
16653                 .dig_out_nid = ALC662_DIGOUT_NID,
16654                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16655                 .channel_mode = alc662_3ST_2ch_modes,
16656                 .input_mux = &alc662_eeepc_capture_source,
16657                 .unsol_event = alc663_mode3_unsol_event,
16658                 .init_hook = alc663_mode3_inithook,
16659         },
16660         [ALC663_ASUS_MODE4] = {
16661                 .mixers = { alc663_asus_21jd_clfe_mixer },
16662                 .cap_mixer = alc662_auto_capture_mixer,
16663                 .init_verbs = { alc662_init_verbs,
16664                                 alc663_21jd_amic_init_verbs},
16665                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16666                 .hp_nid = 0x03,
16667                 .dac_nids = alc662_dac_nids,
16668                 .dig_out_nid = ALC662_DIGOUT_NID,
16669                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16670                 .channel_mode = alc662_3ST_2ch_modes,
16671                 .input_mux = &alc662_eeepc_capture_source,
16672                 .unsol_event = alc663_mode4_unsol_event,
16673                 .init_hook = alc663_mode4_inithook,
16674         },
16675         [ALC663_ASUS_MODE5] = {
16676                 .mixers = { alc663_asus_15jd_clfe_mixer },
16677                 .cap_mixer = alc662_auto_capture_mixer,
16678                 .init_verbs = { alc662_init_verbs,
16679                                 alc663_15jd_amic_init_verbs },
16680                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16681                 .hp_nid = 0x03,
16682                 .dac_nids = alc662_dac_nids,
16683                 .dig_out_nid = ALC662_DIGOUT_NID,
16684                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16685                 .channel_mode = alc662_3ST_2ch_modes,
16686                 .input_mux = &alc662_eeepc_capture_source,
16687                 .unsol_event = alc663_mode5_unsol_event,
16688                 .init_hook = alc663_mode5_inithook,
16689         },
16690         [ALC663_ASUS_MODE6] = {
16691                 .mixers = { alc663_two_hp_m2_mixer },
16692                 .cap_mixer = alc662_auto_capture_mixer,
16693                 .init_verbs = { alc662_init_verbs,
16694                                 alc663_two_hp_amic_m2_init_verbs },
16695                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16696                 .hp_nid = 0x03,
16697                 .dac_nids = alc662_dac_nids,
16698                 .dig_out_nid = ALC662_DIGOUT_NID,
16699                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16700                 .channel_mode = alc662_3ST_2ch_modes,
16701                 .input_mux = &alc662_eeepc_capture_source,
16702                 .unsol_event = alc663_mode6_unsol_event,
16703                 .init_hook = alc663_mode6_inithook,
16704         },
16705         [ALC272_DELL] = {
16706                 .mixers = { alc663_m51va_mixer },
16707                 .cap_mixer = alc272_auto_capture_mixer,
16708                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
16709                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16710                 .dac_nids = alc662_dac_nids,
16711                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16712                 .adc_nids = alc272_adc_nids,
16713                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
16714                 .capsrc_nids = alc272_capsrc_nids,
16715                 .channel_mode = alc662_3ST_2ch_modes,
16716                 .input_mux = &alc663_m51va_capture_source,
16717                 .unsol_event = alc663_m51va_unsol_event,
16718                 .init_hook = alc663_m51va_inithook,
16719         },
16720         [ALC272_DELL_ZM1] = {
16721                 .mixers = { alc663_m51va_mixer },
16722                 .cap_mixer = alc662_auto_capture_mixer,
16723                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
16724                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16725                 .dac_nids = alc662_dac_nids,
16726                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16727                 .adc_nids = alc662_adc_nids,
16728                 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
16729                 .capsrc_nids = alc662_capsrc_nids,
16730                 .channel_mode = alc662_3ST_2ch_modes,
16731                 .input_mux = &alc663_m51va_capture_source,
16732                 .unsol_event = alc663_m51va_unsol_event,
16733                 .init_hook = alc663_m51va_inithook,
16734         },
16735 };
16736
16737
16738 /*
16739  * BIOS auto configuration
16740  */
16741
16742 /* add playback controls from the parsed DAC table */
16743 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16744                                              const struct auto_pin_cfg *cfg)
16745 {
16746         char name[32];
16747         static const char *chname[4] = {
16748                 "Front", "Surround", NULL /*CLFE*/, "Side"
16749         };
16750         hda_nid_t nid;
16751         int i, err;
16752
16753         for (i = 0; i < cfg->line_outs; i++) {
16754                 if (!spec->multiout.dac_nids[i])
16755                         continue;
16756                 nid = alc880_idx_to_dac(i);
16757                 if (i == 2) {
16758                         /* Center/LFE */
16759                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16760                                           "Center Playback Volume",
16761                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16762                                                               HDA_OUTPUT));
16763                         if (err < 0)
16764                                 return err;
16765                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16766                                           "LFE Playback Volume",
16767                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16768                                                               HDA_OUTPUT));
16769                         if (err < 0)
16770                                 return err;
16771                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16772                                           "Center Playback Switch",
16773                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16774                                                               HDA_INPUT));
16775                         if (err < 0)
16776                                 return err;
16777                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16778                                           "LFE Playback Switch",
16779                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16780                                                               HDA_INPUT));
16781                         if (err < 0)
16782                                 return err;
16783                 } else {
16784                         sprintf(name, "%s Playback Volume", chname[i]);
16785                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16786                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16787                                                               HDA_OUTPUT));
16788                         if (err < 0)
16789                                 return err;
16790                         sprintf(name, "%s Playback Switch", chname[i]);
16791                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16792                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16793                                                     3, 0, HDA_INPUT));
16794                         if (err < 0)
16795                                 return err;
16796                 }
16797         }
16798         return 0;
16799 }
16800
16801 /* add playback controls for speaker and HP outputs */
16802 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16803                                         const char *pfx)
16804 {
16805         hda_nid_t nid;
16806         int err;
16807         char name[32];
16808
16809         if (!pin)
16810                 return 0;
16811
16812         if (pin == 0x17) {
16813                 /* ALC663 has a mono output pin on 0x17 */
16814                 sprintf(name, "%s Playback Switch", pfx);
16815                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16816                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16817                 return err;
16818         }
16819
16820         if (alc880_is_fixed_pin(pin)) {
16821                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16822                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16823                 /* specify the DAC as the extra output */
16824                 if (!spec->multiout.hp_nid)
16825                         spec->multiout.hp_nid = nid;
16826                 else
16827                         spec->multiout.extra_out_nid[0] = nid;
16828                 /* control HP volume/switch on the output mixer amp */
16829                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16830                 sprintf(name, "%s Playback Volume", pfx);
16831                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16832                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16833                 if (err < 0)
16834                         return err;
16835                 sprintf(name, "%s Playback Switch", pfx);
16836                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16837                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16838                 if (err < 0)
16839                         return err;
16840         } else if (alc880_is_multi_pin(pin)) {
16841                 /* set manual connection */
16842                 /* we have only a switch on HP-out PIN */
16843                 sprintf(name, "%s Playback Switch", pfx);
16844                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16845                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16846                 if (err < 0)
16847                         return err;
16848         }
16849         return 0;
16850 }
16851
16852 /* return the index of the src widget from the connection list of the nid.
16853  * return -1 if not found
16854  */
16855 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16856                                 hda_nid_t src)
16857 {
16858         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16859         int i, conns;
16860
16861         conns = snd_hda_get_connections(codec, nid, conn_list,
16862                                         ARRAY_SIZE(conn_list));
16863         if (conns < 0)
16864                 return -1;
16865         for (i = 0; i < conns; i++)
16866                 if (conn_list[i] == src)
16867                         return i;
16868         return -1;
16869 }
16870
16871 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16872 {
16873         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16874         return (pincap & AC_PINCAP_IN) != 0;
16875 }
16876
16877 /* create playback/capture controls for input pins */
16878 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16879                                                 const struct auto_pin_cfg *cfg)
16880 {
16881         struct alc_spec *spec = codec->spec;
16882         struct hda_input_mux *imux = &spec->private_imux[0];
16883         int i, err, idx;
16884
16885         for (i = 0; i < AUTO_PIN_LAST; i++) {
16886                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16887                         idx = alc662_input_pin_idx(codec, 0x0b,
16888                                                    cfg->input_pins[i]);
16889                         if (idx >= 0) {
16890                                 err = new_analog_input(spec, cfg->input_pins[i],
16891                                                        auto_pin_cfg_labels[i],
16892                                                        idx, 0x0b);
16893                                 if (err < 0)
16894                                         return err;
16895                         }
16896                         idx = alc662_input_pin_idx(codec, 0x22,
16897                                                    cfg->input_pins[i]);
16898                         if (idx >= 0) {
16899                                 imux->items[imux->num_items].label =
16900                                         auto_pin_cfg_labels[i];
16901                                 imux->items[imux->num_items].index = idx;
16902                                 imux->num_items++;
16903                         }
16904                 }
16905         }
16906         return 0;
16907 }
16908
16909 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16910                                               hda_nid_t nid, int pin_type,
16911                                               int dac_idx)
16912 {
16913         alc_set_pin_output(codec, nid, pin_type);
16914         /* need the manual connection? */
16915         if (alc880_is_multi_pin(nid)) {
16916                 struct alc_spec *spec = codec->spec;
16917                 int idx = alc880_multi_pin_idx(nid);
16918                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16919                                     AC_VERB_SET_CONNECT_SEL,
16920                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16921         }
16922 }
16923
16924 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16925 {
16926         struct alc_spec *spec = codec->spec;
16927         int i;
16928
16929         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16930         for (i = 0; i <= HDA_SIDE; i++) {
16931                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16932                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16933                 if (nid)
16934                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16935                                                           i);
16936         }
16937 }
16938
16939 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16940 {
16941         struct alc_spec *spec = codec->spec;
16942         hda_nid_t pin;
16943
16944         pin = spec->autocfg.hp_pins[0];
16945         if (pin) /* connect to front */
16946                 /* use dac 0 */
16947                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16948         pin = spec->autocfg.speaker_pins[0];
16949         if (pin)
16950                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16951 }
16952
16953 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16954
16955 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16956 {
16957         struct alc_spec *spec = codec->spec;
16958         int i;
16959
16960         for (i = 0; i < AUTO_PIN_LAST; i++) {
16961                 hda_nid_t nid = spec->autocfg.input_pins[i];
16962                 if (alc662_is_input_pin(codec, nid)) {
16963                         alc_set_input_pin(codec, nid, i);
16964                         if (nid != ALC662_PIN_CD_NID &&
16965                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16966                                 snd_hda_codec_write(codec, nid, 0,
16967                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16968                                                     AMP_OUT_MUTE);
16969                 }
16970         }
16971 }
16972
16973 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16974
16975 static int alc662_parse_auto_config(struct hda_codec *codec)
16976 {
16977         struct alc_spec *spec = codec->spec;
16978         int err;
16979         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16980
16981         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16982                                            alc662_ignore);
16983         if (err < 0)
16984                 return err;
16985         if (!spec->autocfg.line_outs)
16986                 return 0; /* can't find valid BIOS pin config */
16987
16988         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16989         if (err < 0)
16990                 return err;
16991         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16992         if (err < 0)
16993                 return err;
16994         err = alc662_auto_create_extra_out(spec,
16995                                            spec->autocfg.speaker_pins[0],
16996                                            "Speaker");
16997         if (err < 0)
16998                 return err;
16999         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
17000                                            "Headphone");
17001         if (err < 0)
17002                 return err;
17003         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
17004         if (err < 0)
17005                 return err;
17006
17007         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17008
17009         if (spec->autocfg.dig_outs)
17010                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17011
17012         if (spec->kctls.list)
17013                 add_mixer(spec, spec->kctls.list);
17014
17015         spec->num_mux_defs = 1;
17016         spec->input_mux = &spec->private_imux[0];
17017
17018         add_verb(spec, alc662_auto_init_verbs);
17019         if (codec->vendor_id == 0x10ec0663)
17020                 add_verb(spec, alc663_auto_init_verbs);
17021
17022         err = alc_auto_add_mic_boost(codec);
17023         if (err < 0)
17024                 return err;
17025
17026         return 1;
17027 }
17028
17029 /* additional initialization for auto-configuration model */
17030 static void alc662_auto_init(struct hda_codec *codec)
17031 {
17032         struct alc_spec *spec = codec->spec;
17033         alc662_auto_init_multi_out(codec);
17034         alc662_auto_init_hp_out(codec);
17035         alc662_auto_init_analog_input(codec);
17036         alc662_auto_init_input_src(codec);
17037         if (spec->unsol_event)
17038                 alc_inithook(codec);
17039 }
17040
17041 static int patch_alc662(struct hda_codec *codec)
17042 {
17043         struct alc_spec *spec;
17044         int err, board_config;
17045
17046         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17047         if (!spec)
17048                 return -ENOMEM;
17049
17050         codec->spec = spec;
17051
17052         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17053
17054         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17055                                                   alc662_models,
17056                                                   alc662_cfg_tbl);
17057         if (board_config < 0) {
17058                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
17059                        "trying auto-probe from BIOS...\n");
17060                 board_config = ALC662_AUTO;
17061         }
17062
17063         if (board_config == ALC662_AUTO) {
17064                 /* automatic parse from the BIOS config */
17065                 err = alc662_parse_auto_config(codec);
17066                 if (err < 0) {
17067                         alc_free(codec);
17068                         return err;
17069                 } else if (!err) {
17070                         printk(KERN_INFO
17071                                "hda_codec: Cannot set up configuration "
17072                                "from BIOS.  Using base mode...\n");
17073                         board_config = ALC662_3ST_2ch_DIG;
17074                 }
17075         }
17076
17077         err = snd_hda_attach_beep_device(codec, 0x1);
17078         if (err < 0) {
17079                 alc_free(codec);
17080                 return err;
17081         }
17082
17083         if (board_config != ALC662_AUTO)
17084                 setup_preset(spec, &alc662_presets[board_config]);
17085
17086         if (codec->vendor_id == 0x10ec0663) {
17087                 spec->stream_name_analog = "ALC663 Analog";
17088                 spec->stream_name_digital = "ALC663 Digital";
17089         } else if (codec->vendor_id == 0x10ec0272) {
17090                 spec->stream_name_analog = "ALC272 Analog";
17091                 spec->stream_name_digital = "ALC272 Digital";
17092         } else {
17093                 spec->stream_name_analog = "ALC662 Analog";
17094                 spec->stream_name_digital = "ALC662 Digital";
17095         }
17096
17097         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17098         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17099
17100         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17101         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17102
17103         spec->adc_nids = alc662_adc_nids;
17104         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17105         spec->capsrc_nids = alc662_capsrc_nids;
17106         spec->capture_style = CAPT_MIX;
17107
17108         if (!spec->cap_mixer)
17109                 set_capture_mixer(spec);
17110         if (codec->vendor_id == 0x10ec0662)
17111                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17112         else
17113                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17114
17115         spec->vmaster_nid = 0x02;
17116
17117         codec->patch_ops = alc_patch_ops;
17118         if (board_config == ALC662_AUTO)
17119                 spec->init_hook = alc662_auto_init;
17120 #ifdef CONFIG_SND_HDA_POWER_SAVE
17121         if (!spec->loopback.amplist)
17122                 spec->loopback.amplist = alc662_loopbacks;
17123 #endif
17124         codec->proc_widget_hook = print_realtek_coef;
17125
17126         return 0;
17127 }
17128
17129 /*
17130  * patch entries
17131  */
17132 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17133         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17134         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17135         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17136         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17137         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17138         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17139         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17140           .patch = patch_alc861 },
17141         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17142         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17143         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17144         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17145           .patch = patch_alc883 },
17146         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17147           .patch = patch_alc662 },
17148         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17149         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17150         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17151         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
17152         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17153           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17154         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17155           .patch = patch_alc882 }, /* should be patch_alc883() in future */
17156         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17157         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
17158         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17159           .patch = patch_alc883 },
17160         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
17161         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
17162         {} /* terminator */
17163 };
17164
17165 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17166
17167 MODULE_LICENSE("GPL");
17168 MODULE_DESCRIPTION("Realtek HD-audio codec");
17169
17170 static struct hda_codec_preset_list realtek_list = {
17171         .preset = snd_hda_preset_realtek,
17172         .owner = THIS_MODULE,
17173 };
17174
17175 static int __init patch_realtek_init(void)
17176 {
17177         return snd_hda_add_codec_preset(&realtek_list);
17178 }
17179
17180 static void __exit patch_realtek_exit(void)
17181 {
17182         snd_hda_delete_codec_preset(&realtek_list);
17183 }
17184
17185 module_init(patch_realtek_init)
17186 module_exit(patch_realtek_exit)