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_patch.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_3013,
  76         ALC260_FUJITSU_S702X,
  77         ALC260_ACER,
  78         ALC260_WILL,
  79         ALC260_REPLACER_672V,
  80 #ifdef CONFIG_SND_DEBUG
  81         ALC260_TEST,
  82 #endif
  83         ALC260_AUTO,
  84         ALC260_MODEL_LAST /* last tag */
  85 };
  86
  87 /* ALC262 models */
  88 enum {
  89         ALC262_BASIC,
  90         ALC262_HIPPO,
  91         ALC262_HIPPO_1,
  92         ALC262_FUJITSU,
  93         ALC262_HP_BPC,
  94         ALC262_HP_BPC_D7000_WL,
  95         ALC262_HP_BPC_D7000_WF,
  96         ALC262_HP_TC_T5735,
  97         ALC262_HP_RP5700,
  98         ALC262_BENQ_ED8,
  99         ALC262_SONY_ASSAMD,
 100         ALC262_BENQ_T31,
 101         ALC262_ULTRA,
 102         ALC262_LENOVO_3000,
 103         ALC262_AUTO,
 104         ALC262_MODEL_LAST /* last tag */
 105 };
 106
 107 /* ALC268 models */
 108 enum {
 109         ALC267_QUANTA_IL1,
 110         ALC268_3ST,
 111         ALC268_TOSHIBA,
 112         ALC268_ACER,
 113         ALC268_DELL,
 114         ALC268_ZEPTO,
 115 #ifdef CONFIG_SND_DEBUG
 116         ALC268_TEST,
 117 #endif
 118         ALC268_AUTO,
 119         ALC268_MODEL_LAST /* last tag */
 120 };
 121
 122 /* ALC269 models */
 123 enum {
 124         ALC269_BASIC,
 125         ALC269_ASUS_EEEPC_P703,
 126         ALC269_ASUS_EEEPC_P901,
 127         ALC269_AUTO,
 128         ALC269_MODEL_LAST /* last tag */
 129 };
 130
 131 /* ALC861 models */
 132 enum {
 133         ALC861_3ST,
 134         ALC660_3ST,
 135         ALC861_3ST_DIG,
 136         ALC861_6ST_DIG,
 137         ALC861_UNIWILL_M31,
 138         ALC861_TOSHIBA,
 139         ALC861_ASUS,
 140         ALC861_ASUS_LAPTOP,
 141         ALC861_AUTO,
 142         ALC861_MODEL_LAST,
 143 };
 144
 145 /* ALC861-VD models */
 146 enum {
 147         ALC660VD_3ST,
 148         ALC660VD_3ST_DIG,
 149         ALC861VD_3ST,
 150         ALC861VD_3ST_DIG,
 151         ALC861VD_6ST_DIG,
 152         ALC861VD_LENOVO,
 153         ALC861VD_DALLAS,
 154         ALC861VD_HP,
 155         ALC861VD_AUTO,
 156         ALC861VD_MODEL_LAST,
 157 };
 158
 159 /* ALC662 models */
 160 enum {
 161         ALC662_3ST_2ch_DIG,
 162         ALC662_3ST_6ch_DIG,
 163         ALC662_3ST_6ch,
 164         ALC662_5ST_DIG,
 165         ALC662_LENOVO_101E,
 166         ALC662_ASUS_EEEPC_P701,
 167         ALC662_ASUS_EEEPC_EP20,
 168         ALC663_ASUS_M51VA,
 169         ALC663_ASUS_G71V,
 170         ALC663_ASUS_H13,
 171         ALC663_ASUS_G50V,
 172         ALC662_AUTO,
 173         ALC662_MODEL_LAST,
 174 };
 175
 176 /* ALC882 models */
 177 enum {
 178         ALC882_3ST_DIG,
 179         ALC882_6ST_DIG,
 180         ALC882_ARIMA,
 181         ALC882_W2JC,
 182         ALC882_TARGA,
 183         ALC882_ASUS_A7J,
 184         ALC882_ASUS_A7M,
 185         ALC885_MACPRO,
 186         ALC885_MBP3,
 187         ALC885_IMAC24,
 188         ALC882_AUTO,
 189         ALC882_MODEL_LAST,
 190 };
 191
 192 /* ALC883 models */
 193 enum {
 194         ALC883_3ST_2ch_DIG,
 195         ALC883_3ST_6ch_DIG,
 196         ALC883_3ST_6ch,
 197         ALC883_6ST_DIG,
 198         ALC883_TARGA_DIG,
 199         ALC883_TARGA_2ch_DIG,
 200         ALC883_ACER,
 201         ALC883_ACER_ASPIRE,
 202         ALC883_MEDION,
 203         ALC883_MEDION_MD2,
 204         ALC883_LAPTOP_EAPD,
 205         ALC883_LENOVO_101E_2ch,
 206         ALC883_LENOVO_NB0763,
 207         ALC888_LENOVO_MS7195_DIG,
 208         ALC883_HAIER_W66,
 209         ALC888_3ST_HP,
 210         ALC888_6ST_DELL,
 211         ALC883_MITAC,
 212         ALC883_CLEVO_M720,
 213         ALC883_FUJITSU_PI2515,
 214         ALC883_3ST_6ch_INTEL,
 215         ALC883_AUTO,
 216         ALC883_MODEL_LAST,
 217 };
 218
 219 /* for GPIO Poll */
 220 #define GPIO_MASK       0x03
 221
 222 struct alc_spec {
 223         /* codec parameterization */
 224         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 225         unsigned int num_mixers;
 226
 227         const struct hda_verb *init_verbs[5];   /* initialization verbs
 228                                                  * don't forget NULL
 229                                                  * termination!
 230                                                  */
 231         unsigned int num_init_verbs;
 232
 233         char *stream_name_analog;       /* analog PCM stream */
 234         struct hda_pcm_stream *stream_analog_playback;
 235         struct hda_pcm_stream *stream_analog_capture;
 236         struct hda_pcm_stream *stream_analog_alt_playback;
 237         struct hda_pcm_stream *stream_analog_alt_capture;
 238
 239         char *stream_name_digital;      /* digital PCM stream */
 240         struct hda_pcm_stream *stream_digital_playback;
 241         struct hda_pcm_stream *stream_digital_capture;
 242
 243         /* playback */
 244         struct hda_multi_out multiout;  /* playback set-up
 245                                          * max_channels, dacs must be set
 246                                          * dig_out_nid and hp_nid are optional
 247                                          */
 248         hda_nid_t alt_dac_nid;
 249
 250         /* capture */
 251         unsigned int num_adc_nids;
 252         hda_nid_t *adc_nids;
 253         hda_nid_t *capsrc_nids;
 254         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 255
 256         /* capture source */
 257         unsigned int num_mux_defs;
 258         const struct hda_input_mux *input_mux;
 259         unsigned int cur_mux[3];
 260
 261         /* channel model */
 262         const struct hda_channel_mode *channel_mode;
 263         int num_channel_mode;
 264         int need_dac_fix;
 265
 266         /* PCM information */
 267         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 268
 269         /* dynamic controls, init_verbs and input_mux */
 270         struct auto_pin_cfg autocfg;
 271         unsigned int num_kctl_alloc, num_kctl_used;
 272         struct snd_kcontrol_new *kctl_alloc;
 273         struct hda_input_mux private_imux;
 274         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 275
 276         /* hooks */
 277         void (*init_hook)(struct hda_codec *codec);
 278         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 279
 280         /* for pin sensing */
 281         unsigned int sense_updated: 1;
 282         unsigned int jack_present: 1;
 283         unsigned int master_sw: 1;
 284
 285         /* for virtual master */
 286         hda_nid_t vmaster_nid;
 287 #ifdef CONFIG_SND_HDA_POWER_SAVE
 288         struct hda_loopback_check loopback;
 289 #endif
 290
 291         /* for PLL fix */
 292         hda_nid_t pll_nid;
 293         unsigned int pll_coef_idx, pll_coef_bit;
 294 };
 295
 296 /*
 297  * configuration template - to be copied to the spec instance
 298  */
 299 struct alc_config_preset {
 300         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 301                                              * with spec
 302                                              */
 303         const struct hda_verb *init_verbs[5];
 304         unsigned int num_dacs;
 305         hda_nid_t *dac_nids;
 306         hda_nid_t dig_out_nid;          /* optional */
 307         hda_nid_t hp_nid;               /* optional */
 308         unsigned int num_adc_nids;
 309         hda_nid_t *adc_nids;
 310         hda_nid_t *capsrc_nids;
 311         hda_nid_t dig_in_nid;
 312         unsigned int num_channel_mode;
 313         const struct hda_channel_mode *channel_mode;
 314         int need_dac_fix;
 315         unsigned int num_mux_defs;
 316         const struct hda_input_mux *input_mux;
 317         void (*unsol_event)(struct hda_codec *, unsigned int);
 318         void (*init_hook)(struct hda_codec *);
 319 #ifdef CONFIG_SND_HDA_POWER_SAVE
 320         struct hda_amp_list *loopbacks;
 321 #endif
 322 };
 323
 324
 325 /*
 326  * input MUX handling
 327  */
 328 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 329                              struct snd_ctl_elem_info *uinfo)
 330 {
 331         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 332         struct alc_spec *spec = codec->spec;
 333         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 334         if (mux_idx >= spec->num_mux_defs)
 335                 mux_idx = 0;
 336         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 337 }
 338
 339 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 340                             struct snd_ctl_elem_value *ucontrol)
 341 {
 342         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 343         struct alc_spec *spec = codec->spec;
 344         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 345
 346         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 347         return 0;
 348 }
 349
 350 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 351                             struct snd_ctl_elem_value *ucontrol)
 352 {
 353         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 354         struct alc_spec *spec = codec->spec;
 355         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 356         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 357         hda_nid_t nid = spec->capsrc_nids ?
 358                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 359         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
 360                                      nid, &spec->cur_mux[adc_idx]);
 361 }
 362
 363
 364 /*
 365  * channel mode setting
 366  */
 367 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 368                             struct snd_ctl_elem_info *uinfo)
 369 {
 370         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 371         struct alc_spec *spec = codec->spec;
 372         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 373                                     spec->num_channel_mode);
 374 }
 375
 376 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 377                            struct snd_ctl_elem_value *ucontrol)
 378 {
 379         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 380         struct alc_spec *spec = codec->spec;
 381         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 382                                    spec->num_channel_mode,
 383                                    spec->multiout.max_channels);
 384 }
 385
 386 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 387                            struct snd_ctl_elem_value *ucontrol)
 388 {
 389         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 390         struct alc_spec *spec = codec->spec;
 391         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 392                                       spec->num_channel_mode,
 393                                       &spec->multiout.max_channels);
 394         if (err >= 0 && spec->need_dac_fix)
 395                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 396         return err;
 397 }
 398
 399 /*
 400  * Control the mode of pin widget settings via the mixer.  "pc" is used
 401  * instead of "%" to avoid consequences of accidently treating the % as
 402  * being part of a format specifier.  Maximum allowed length of a value is
 403  * 63 characters plus NULL terminator.
 404  *
 405  * Note: some retasking pin complexes seem to ignore requests for input
 406  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 407  * are requested.  Therefore order this list so that this behaviour will not
 408  * cause problems when mixer clients move through the enum sequentially.
 409  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 410  * March 2006.
 411  */
 412 static char *alc_pin_mode_names[] = {
 413         "Mic 50pc bias", "Mic 80pc bias",
 414         "Line in", "Line out", "Headphone out",
 415 };
 416 static unsigned char alc_pin_mode_values[] = {
 417         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 418 };
 419 /* The control can present all 5 options, or it can limit the options based
 420  * in the pin being assumed to be exclusively an input or an output pin.  In
 421  * addition, "input" pins may or may not process the mic bias option
 422  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 423  * accept requests for bias as of chip versions up to March 2006) and/or
 424  * wiring in the computer.
 425  */
 426 #define ALC_PIN_DIR_IN              0x00
 427 #define ALC_PIN_DIR_OUT             0x01
 428 #define ALC_PIN_DIR_INOUT           0x02
 429 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 430 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 431
 432 /* Info about the pin modes supported by the different pin direction modes.
 433  * For each direction the minimum and maximum values are given.
 434  */
 435 static signed char alc_pin_mode_dir_info[5][2] = {
 436         { 0, 2 },    /* ALC_PIN_DIR_IN */
 437         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 438         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 439         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 440         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 441 };
 442 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 443 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 444 #define alc_pin_mode_n_items(_dir) \
 445         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 446
 447 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 448                              struct snd_ctl_elem_info *uinfo)
 449 {
 450         unsigned int item_num = uinfo->value.enumerated.item;
 451         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 452
 453         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 454         uinfo->count = 1;
 455         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 456
 457         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 458                 item_num = alc_pin_mode_min(dir);
 459         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 460         return 0;
 461 }
 462
 463 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 464                             struct snd_ctl_elem_value *ucontrol)
 465 {
 466         unsigned int i;
 467         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 468         hda_nid_t nid = kcontrol->private_value & 0xffff;
 469         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 470         long *valp = ucontrol->value.integer.value;
 471         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 472                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 473                                                  0x00);
 474
 475         /* Find enumerated value for current pinctl setting */
 476         i = alc_pin_mode_min(dir);
 477         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 478                 i++;
 479         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 480         return 0;
 481 }
 482
 483 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 484                             struct snd_ctl_elem_value *ucontrol)
 485 {
 486         signed int change;
 487         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 488         hda_nid_t nid = kcontrol->private_value & 0xffff;
 489         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 490         long val = *ucontrol->value.integer.value;
 491         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 492                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 493                                                  0x00);
 494
 495         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 496                 val = alc_pin_mode_min(dir);
 497
 498         change = pinctl != alc_pin_mode_values[val];
 499         if (change) {
 500                 /* Set pin mode to that requested */
 501                 snd_hda_codec_write_cache(codec, nid, 0,
 502                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 503                                           alc_pin_mode_values[val]);
 504
 505                 /* Also enable the retasking pin's input/output as required
 506                  * for the requested pin mode.  Enum values of 2 or less are
 507                  * input modes.
 508                  *
 509                  * Dynamically switching the input/output buffers probably
 510                  * reduces noise slightly (particularly on input) so we'll
 511                  * do it.  However, having both input and output buffers
 512                  * enabled simultaneously doesn't seem to be problematic if
 513                  * this turns out to be necessary in the future.
 514                  */
 515                 if (val <= 2) {
 516                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 517                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 518                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 519                                                  HDA_AMP_MUTE, 0);
 520                 } else {
 521                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 522                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 523                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 524                                                  HDA_AMP_MUTE, 0);
 525                 }
 526         }
 527         return change;
 528 }
 529
 530 #define ALC_PIN_MODE(xname, nid, dir) \
 531         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 532           .info = alc_pin_mode_info, \
 533           .get = alc_pin_mode_get, \
 534           .put = alc_pin_mode_put, \
 535           .private_value = nid | (dir<<16) }
 536
 537 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 538  * together using a mask with more than one bit set.  This control is
 539  * currently used only by the ALC260 test model.  At this stage they are not
 540  * needed for any "production" models.
 541  */
 542 #ifdef CONFIG_SND_DEBUG
 543 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 544
 545 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 546                              struct snd_ctl_elem_value *ucontrol)
 547 {
 548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 549         hda_nid_t nid = kcontrol->private_value & 0xffff;
 550         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 551         long *valp = ucontrol->value.integer.value;
 552         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 553                                               AC_VERB_GET_GPIO_DATA, 0x00);
 554
 555         *valp = (val & mask) != 0;
 556         return 0;
 557 }
 558 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 559                              struct snd_ctl_elem_value *ucontrol)
 560 {
 561         signed int change;
 562         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 563         hda_nid_t nid = kcontrol->private_value & 0xffff;
 564         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 565         long val = *ucontrol->value.integer.value;
 566         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 567                                                     AC_VERB_GET_GPIO_DATA,
 568                                                     0x00);
 569
 570         /* Set/unset the masked GPIO bit(s) as needed */
 571         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 572         if (val == 0)
 573                 gpio_data &= ~mask;
 574         else
 575                 gpio_data |= mask;
 576         snd_hda_codec_write_cache(codec, nid, 0,
 577                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 578
 579         return change;
 580 }
 581 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 582         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 583           .info = alc_gpio_data_info, \
 584           .get = alc_gpio_data_get, \
 585           .put = alc_gpio_data_put, \
 586           .private_value = nid | (mask<<16) }
 587 #endif   /* CONFIG_SND_DEBUG */
 588
 589 /* A switch control to allow the enabling of the digital IO pins on the
 590  * ALC260.  This is incredibly simplistic; the intention of this control is
 591  * to provide something in the test model allowing digital outputs to be
 592  * identified if present.  If models are found which can utilise these
 593  * outputs a more complete mixer control can be devised for those models if
 594  * necessary.
 595  */
 596 #ifdef CONFIG_SND_DEBUG
 597 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 598
 599 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 600                               struct snd_ctl_elem_value *ucontrol)
 601 {
 602         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 603         hda_nid_t nid = kcontrol->private_value & 0xffff;
 604         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 605         long *valp = ucontrol->value.integer.value;
 606         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 607                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 608
 609         *valp = (val & mask) != 0;
 610         return 0;
 611 }
 612 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 613                               struct snd_ctl_elem_value *ucontrol)
 614 {
 615         signed int change;
 616         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 617         hda_nid_t nid = kcontrol->private_value & 0xffff;
 618         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 619         long val = *ucontrol->value.integer.value;
 620         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 621                                                     AC_VERB_GET_DIGI_CONVERT_1,
 622                                                     0x00);
 623
 624         /* Set/unset the masked control bit(s) as needed */
 625         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 626         if (val==0)
 627                 ctrl_data &= ~mask;
 628         else
 629                 ctrl_data |= mask;
 630         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 631                                   ctrl_data);
 632
 633         return change;
 634 }
 635 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 636         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 637           .info = alc_spdif_ctrl_info, \
 638           .get = alc_spdif_ctrl_get, \
 639           .put = alc_spdif_ctrl_put, \
 640           .private_value = nid | (mask<<16) }
 641 #endif   /* CONFIG_SND_DEBUG */
 642
 643 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 644  * Again, this is only used in the ALC26x test models to help identify when
 645  * the EAPD line must be asserted for features to work.
 646  */
 647 #ifdef CONFIG_SND_DEBUG
 648 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 649
 650 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 651                               struct snd_ctl_elem_value *ucontrol)
 652 {
 653         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 654         hda_nid_t nid = kcontrol->private_value & 0xffff;
 655         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 656         long *valp = ucontrol->value.integer.value;
 657         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 658                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 659
 660         *valp = (val & mask) != 0;
 661         return 0;
 662 }
 663
 664 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 665                               struct snd_ctl_elem_value *ucontrol)
 666 {
 667         int change;
 668         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 669         hda_nid_t nid = kcontrol->private_value & 0xffff;
 670         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 671         long val = *ucontrol->value.integer.value;
 672         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 673                                                     AC_VERB_GET_EAPD_BTLENABLE,
 674                                                     0x00);
 675
 676         /* Set/unset the masked control bit(s) as needed */
 677         change = (!val ? 0 : mask) != (ctrl_data & mask);
 678         if (!val)
 679                 ctrl_data &= ~mask;
 680         else
 681                 ctrl_data |= mask;
 682         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 683                                   ctrl_data);
 684
 685         return change;
 686 }
 687
 688 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 689         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 690           .info = alc_eapd_ctrl_info, \
 691           .get = alc_eapd_ctrl_get, \
 692           .put = alc_eapd_ctrl_put, \
 693           .private_value = nid | (mask<<16) }
 694 #endif   /* CONFIG_SND_DEBUG */
 695
 696 /*
 697  * set up from the preset table
 698  */
 699 static void setup_preset(struct alc_spec *spec,
 700                          const struct alc_config_preset *preset)
 701 {
 702         int i;
 703
 704         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 705                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
 706         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 707              i++)
 708                 spec->init_verbs[spec->num_init_verbs++] =
 709                         preset->init_verbs[i];
 710
 711         spec->channel_mode = preset->channel_mode;
 712         spec->num_channel_mode = preset->num_channel_mode;
 713         spec->need_dac_fix = preset->need_dac_fix;
 714
 715         spec->multiout.max_channels = spec->channel_mode[0].channels;
 716
 717         spec->multiout.num_dacs = preset->num_dacs;
 718         spec->multiout.dac_nids = preset->dac_nids;
 719         spec->multiout.dig_out_nid = preset->dig_out_nid;
 720         spec->multiout.hp_nid = preset->hp_nid;
 721
 722         spec->num_mux_defs = preset->num_mux_defs;
 723         if (!spec->num_mux_defs)
 724                 spec->num_mux_defs = 1;
 725         spec->input_mux = preset->input_mux;
 726
 727         spec->num_adc_nids = preset->num_adc_nids;
 728         spec->adc_nids = preset->adc_nids;
 729         spec->capsrc_nids = preset->capsrc_nids;
 730         spec->dig_in_nid = preset->dig_in_nid;
 731
 732         spec->unsol_event = preset->unsol_event;
 733         spec->init_hook = preset->init_hook;
 734 #ifdef CONFIG_SND_HDA_POWER_SAVE
 735         spec->loopback.amplist = preset->loopbacks;
 736 #endif
 737 }
 738
 739 /* Enable GPIO mask and set output */
 740 static struct hda_verb alc_gpio1_init_verbs[] = {
 741         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 742         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 743         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 744         { }
 745 };
 746
 747 static struct hda_verb alc_gpio2_init_verbs[] = {
 748         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 749         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 750         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 751         { }
 752 };
 753
 754 static struct hda_verb alc_gpio3_init_verbs[] = {
 755         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 756         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 757         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 758         { }
 759 };
 760
 761 /*
 762  * Fix hardware PLL issue
 763  * On some codecs, the analog PLL gating control must be off while
 764  * the default value is 1.
 765  */
 766 static void alc_fix_pll(struct hda_codec *codec)
 767 {
 768         struct alc_spec *spec = codec->spec;
 769         unsigned int val;
 770
 771         if (!spec->pll_nid)
 772                 return;
 773         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 774                             spec->pll_coef_idx);
 775         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 776                                  AC_VERB_GET_PROC_COEF, 0);
 777         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 778                             spec->pll_coef_idx);
 779         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 780                             val & ~(1 << spec->pll_coef_bit));
 781 }
 782
 783 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 784                              unsigned int coef_idx, unsigned int coef_bit)
 785 {
 786         struct alc_spec *spec = codec->spec;
 787         spec->pll_nid = nid;
 788         spec->pll_coef_idx = coef_idx;
 789         spec->pll_coef_bit = coef_bit;
 790         alc_fix_pll(codec);
 791 }
 792
 793 static void alc_sku_automute(struct hda_codec *codec)
 794 {
 795         struct alc_spec *spec = codec->spec;
 796         unsigned int present;
 797         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 798         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 799
 800         /* need to execute and sync at first */
 801         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 802         present = snd_hda_codec_read(codec, hp_nid, 0,
 803                                      AC_VERB_GET_PIN_SENSE, 0);
 804         spec->jack_present = (present & 0x80000000) != 0;
 805         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 806                             spec->jack_present ? 0 : PIN_OUT);
 807 }
 808
 809 /* unsolicited event for HP jack sensing */
 810 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 811 {
 812         if (codec->vendor_id == 0x10ec0880)
 813                 res >>= 28;
 814         else
 815                 res >>= 26;
 816         if (res != ALC880_HP_EVENT)
 817                 return;
 818
 819         alc_sku_automute(codec);
 820 }
 821
 822 /* additional initialization for ALC888 variants */
 823 static void alc888_coef_init(struct hda_codec *codec)
 824 {
 825         unsigned int tmp;
 826
 827         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 828         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 829         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 830         if ((tmp & 0xf0) == 2)
 831                 /* alc888S-VC */
 832                 snd_hda_codec_read(codec, 0x20, 0,
 833                                    AC_VERB_SET_PROC_COEF, 0x830);
 834          else
 835                  /* alc888-VB */
 836                  snd_hda_codec_read(codec, 0x20, 0,
 837                                     AC_VERB_SET_PROC_COEF, 0x3030);
 838 }
 839
 840 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 841  *      31 ~ 16 :       Manufacture ID
 842  *      15 ~ 8  :       SKU ID
 843  *      7  ~ 0  :       Assembly ID
 844  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 845  */
 846 static void alc_subsystem_id(struct hda_codec *codec,
 847                              unsigned int porta, unsigned int porte,
 848                              unsigned int portd)
 849 {
 850         unsigned int ass, tmp, i;
 851         unsigned nid;
 852         struct alc_spec *spec = codec->spec;
 853
 854         ass = codec->subsystem_id & 0xffff;
 855         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
 856                 goto do_sku;
 857
 858         /*
 859          * 31~30        : port conetcivity
 860          * 29~21        : reserve
 861          * 20           : PCBEEP input
 862          * 19~16        : Check sum (15:1)
 863          * 15~1         : Custom
 864          * 0            : override
 865         */
 866         nid = 0x1d;
 867         if (codec->vendor_id == 0x10ec0260)
 868                 nid = 0x17;
 869         ass = snd_hda_codec_read(codec, nid, 0,
 870                                  AC_VERB_GET_CONFIG_DEFAULT, 0);
 871         if (!(ass & 1) && !(ass & 0x100000))
 872                 return;
 873         if ((ass >> 30) != 1)   /* no physical connection */
 874                 return;
 875
 876         /* check sum */
 877         tmp = 0;
 878         for (i = 1; i < 16; i++) {
 879                 if ((ass >> i) & 1)
 880                         tmp++;
 881         }
 882         if (((ass >> 16) & 0xf) != tmp)
 883                 return;
 884 do_sku:
 885         /*
 886          * 0 : override
 887          * 1 :  Swap Jack
 888          * 2 : 0 --> Desktop, 1 --> Laptop
 889          * 3~5 : External Amplifier control
 890          * 7~6 : Reserved
 891         */
 892         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 893         switch (tmp) {
 894         case 1:
 895                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 896                 break;
 897         case 3:
 898                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 899                 break;
 900         case 7:
 901                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 902                 break;
 903         case 5: /* set EAPD output high */
 904                 switch (codec->vendor_id) {
 905                 case 0x10ec0260:
 906                         snd_hda_codec_write(codec, 0x0f, 0,
 907                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 908                         snd_hda_codec_write(codec, 0x10, 0,
 909                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 910                         break;
 911                 case 0x10ec0262:
 912                 case 0x10ec0267:
 913                 case 0x10ec0268:
 914                 case 0x10ec0269:
 915                 case 0x10ec0660:
 916                 case 0x10ec0662:
 917                 case 0x10ec0663:
 918                 case 0x10ec0862:
 919                 case 0x10ec0889:
 920                         snd_hda_codec_write(codec, 0x14, 0,
 921                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 922                         snd_hda_codec_write(codec, 0x15, 0,
 923                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 924                         break;
 925                 }
 926                 switch (codec->vendor_id) {
 927                 case 0x10ec0260:
 928                         snd_hda_codec_write(codec, 0x1a, 0,
 929                                             AC_VERB_SET_COEF_INDEX, 7);
 930                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 931                                                  AC_VERB_GET_PROC_COEF, 0);
 932                         snd_hda_codec_write(codec, 0x1a, 0,
 933                                             AC_VERB_SET_COEF_INDEX, 7);
 934                         snd_hda_codec_write(codec, 0x1a, 0,
 935                                             AC_VERB_SET_PROC_COEF,
 936                                             tmp | 0x2010);
 937                         break;
 938                 case 0x10ec0262:
 939                 case 0x10ec0880:
 940                 case 0x10ec0882:
 941                 case 0x10ec0883:
 942                 case 0x10ec0885:
 943                 case 0x10ec0889:
 944                         snd_hda_codec_write(codec, 0x20, 0,
 945                                             AC_VERB_SET_COEF_INDEX, 7);
 946                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 947                                                  AC_VERB_GET_PROC_COEF, 0);
 948                         snd_hda_codec_write(codec, 0x20, 0,
 949                                             AC_VERB_SET_COEF_INDEX, 7);
 950                         snd_hda_codec_write(codec, 0x20, 0,
 951                                             AC_VERB_SET_PROC_COEF,
 952                                             tmp | 0x2010);
 953                         break;
 954                 case 0x10ec0888:
 955                         alc888_coef_init(codec);
 956                         break;
 957                 case 0x10ec0267:
 958                 case 0x10ec0268:
 959                         snd_hda_codec_write(codec, 0x20, 0,
 960                                             AC_VERB_SET_COEF_INDEX, 7);
 961                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 962                                                  AC_VERB_GET_PROC_COEF, 0);
 963                         snd_hda_codec_write(codec, 0x20, 0,
 964                                             AC_VERB_SET_COEF_INDEX, 7);
 965                         snd_hda_codec_write(codec, 0x20, 0,
 966                                             AC_VERB_SET_PROC_COEF,
 967                                             tmp | 0x3000);
 968                         break;
 969                 }
 970         default:
 971                 break;
 972         }
 973
 974         /* is laptop or Desktop and enable the function "Mute internal speaker
 975          * when the external headphone out jack is plugged"
 976          */
 977         if (!(ass & 0x8000))
 978                 return;
 979         /*
 980          * 10~8 : Jack location
 981          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 982          * 14~13: Resvered
 983          * 15   : 1 --> enable the function "Mute internal speaker
 984          *              when the external headphone out jack is plugged"
 985          */
 986         if (!spec->autocfg.speaker_pins[0]) {
 987                 if (spec->autocfg.line_out_pins[0])
 988                         spec->autocfg.speaker_pins[0] =
 989                                 spec->autocfg.line_out_pins[0];
 990                 else
 991                         return;
 992         }
 993
 994         if (!spec->autocfg.hp_pins[0]) {
 995                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 996                 if (tmp == 0)
 997                         spec->autocfg.hp_pins[0] = porta;
 998                 else if (tmp == 1)
 999                         spec->autocfg.hp_pins[0] = porte;
1000                 else if (tmp == 2)
1001                         spec->autocfg.hp_pins[0] = portd;
1002                 else
1003                         return;
1004         }
1005
1006         snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1007                             AC_VERB_SET_UNSOLICITED_ENABLE,
1008                             AC_USRSP_EN | ALC880_HP_EVENT);
1009         spec->unsol_event = alc_sku_unsol_event;
1010 }
1011
1012 /*
1013  * Fix-up pin default configurations
1014  */
1015
1016 struct alc_pincfg {
1017         hda_nid_t nid;
1018         u32 val;
1019 };
1020
1021 static void alc_fix_pincfg(struct hda_codec *codec,
1022                            const struct snd_pci_quirk *quirk,
1023                            const struct alc_pincfg **pinfix)
1024 {
1025         const struct alc_pincfg *cfg;
1026
1027         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1028         if (!quirk)
1029                 return;
1030
1031         cfg = pinfix[quirk->value];
1032         for (; cfg->nid; cfg++) {
1033                 int i;
1034                 u32 val = cfg->val;
1035                 for (i = 0; i < 4; i++) {
1036                         snd_hda_codec_write(codec, cfg->nid, 0,
1037                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1038                                     val & 0xff);
1039                         val >>= 8;
1040                 }
1041         }
1042 }
1043
1044 /*
1045  * ALC880 3-stack model
1046  *
1047  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1048  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1049  *                 F-Mic = 0x1b, HP = 0x19
1050  */
1051
1052 static hda_nid_t alc880_dac_nids[4] = {
1053         /* front, rear, clfe, rear_surr */
1054         0x02, 0x05, 0x04, 0x03
1055 };
1056
1057 static hda_nid_t alc880_adc_nids[3] = {
1058         /* ADC0-2 */
1059         0x07, 0x08, 0x09,
1060 };
1061
1062 /* The datasheet says the node 0x07 is connected from inputs,
1063  * but it shows zero connection in the real implementation on some devices.
1064  * Note: this is a 915GAV bug, fixed on 915GLV
1065  */
1066 static hda_nid_t alc880_adc_nids_alt[2] = {
1067         /* ADC1-2 */
1068         0x08, 0x09,
1069 };
1070
1071 #define ALC880_DIGOUT_NID       0x06
1072 #define ALC880_DIGIN_NID        0x0a
1073
1074 static struct hda_input_mux alc880_capture_source = {
1075         .num_items = 4,
1076         .items = {
1077                 { "Mic", 0x0 },
1078                 { "Front Mic", 0x3 },
1079                 { "Line", 0x2 },
1080                 { "CD", 0x4 },
1081         },
1082 };
1083
1084 /* channel source setting (2/6 channel selection for 3-stack) */
1085 /* 2ch mode */
1086 static struct hda_verb alc880_threestack_ch2_init[] = {
1087         /* set line-in to input, mute it */
1088         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1089         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1090         /* set mic-in to input vref 80%, mute it */
1091         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1092         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1093         { } /* end */
1094 };
1095
1096 /* 6ch mode */
1097 static struct hda_verb alc880_threestack_ch6_init[] = {
1098         /* set line-in to output, unmute it */
1099         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1100         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1101         /* set mic-in to output, unmute it */
1102         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1103         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1104         { } /* end */
1105 };
1106
1107 static struct hda_channel_mode alc880_threestack_modes[2] = {
1108         { 2, alc880_threestack_ch2_init },
1109         { 6, alc880_threestack_ch6_init },
1110 };
1111
1112 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1113         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1114         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1115         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1116         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1117         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1118         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1119         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1120         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1121         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1122         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1123         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1124         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1125         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1126         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1127         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1128         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1129         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1130         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1131         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1132         {
1133                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1134                 .name = "Channel Mode",
1135                 .info = alc_ch_mode_info,
1136                 .get = alc_ch_mode_get,
1137                 .put = alc_ch_mode_put,
1138         },
1139         { } /* end */
1140 };
1141
1142 /* capture mixer elements */
1143 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1144         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1145         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1146         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1147         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1148         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1149         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1150         {
1151                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1152                 /* The multiple "Capture Source" controls confuse alsamixer
1153                  * So call somewhat different..
1154                  */
1155                 /* .name = "Capture Source", */
1156                 .name = "Input Source",
1157                 .count = 3,
1158                 .info = alc_mux_enum_info,
1159                 .get = alc_mux_enum_get,
1160                 .put = alc_mux_enum_put,
1161         },
1162         { } /* end */
1163 };
1164
1165 /* capture mixer elements (in case NID 0x07 not available) */
1166 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1167         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1168         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1169         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1170         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1171         {
1172                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1173                 /* The multiple "Capture Source" controls confuse alsamixer
1174                  * So call somewhat different..
1175                  */
1176                 /* .name = "Capture Source", */
1177                 .name = "Input Source",
1178                 .count = 2,
1179                 .info = alc_mux_enum_info,
1180                 .get = alc_mux_enum_get,
1181                 .put = alc_mux_enum_put,
1182         },
1183         { } /* end */
1184 };
1185
1186
1187
1188 /*
1189  * ALC880 5-stack model
1190  *
1191  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1192  *      Side = 0x02 (0xd)
1193  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1194  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1195  */
1196
1197 /* additional mixers to alc880_three_stack_mixer */
1198 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1199         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1200         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1201         { } /* end */
1202 };
1203
1204 /* channel source setting (6/8 channel selection for 5-stack) */
1205 /* 6ch mode */
1206 static struct hda_verb alc880_fivestack_ch6_init[] = {
1207         /* set line-in to input, mute it */
1208         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1209         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1210         { } /* end */
1211 };
1212
1213 /* 8ch mode */
1214 static struct hda_verb alc880_fivestack_ch8_init[] = {
1215         /* set line-in to output, unmute it */
1216         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1217         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1218         { } /* end */
1219 };
1220
1221 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1222         { 6, alc880_fivestack_ch6_init },
1223         { 8, alc880_fivestack_ch8_init },
1224 };
1225
1226
1227 /*
1228  * ALC880 6-stack model
1229  *
1230  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1231  *      Side = 0x05 (0x0f)
1232  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1233  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1234  */
1235
1236 static hda_nid_t alc880_6st_dac_nids[4] = {
1237         /* front, rear, clfe, rear_surr */
1238         0x02, 0x03, 0x04, 0x05
1239 };
1240
1241 static struct hda_input_mux alc880_6stack_capture_source = {
1242         .num_items = 4,
1243         .items = {
1244                 { "Mic", 0x0 },
1245                 { "Front Mic", 0x1 },
1246                 { "Line", 0x2 },
1247                 { "CD", 0x4 },
1248         },
1249 };
1250
1251 /* fixed 8-channels */
1252 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1253         { 8, NULL },
1254 };
1255
1256 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1257         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1258         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1259         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1260         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1261         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1262         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1263         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1264         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1265         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1266         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1267         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1268         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1269         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1270         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1272         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1273         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1274         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1275         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1276         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1277         {
1278                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1279                 .name = "Channel Mode",
1280                 .info = alc_ch_mode_info,
1281                 .get = alc_ch_mode_get,
1282                 .put = alc_ch_mode_put,
1283         },
1284         { } /* end */
1285 };
1286
1287
1288 /*
1289  * ALC880 W810 model
1290  *
1291  * W810 has rear IO for:
1292  * Front (DAC 02)
1293  * Surround (DAC 03)
1294  * Center/LFE (DAC 04)
1295  * Digital out (06)
1296  *
1297  * The system also has a pair of internal speakers, and a headphone jack.
1298  * These are both connected to Line2 on the codec, hence to DAC 02.
1299  *
1300  * There is a variable resistor to control the speaker or headphone
1301  * volume. This is a hardware-only device without a software API.
1302  *
1303  * Plugging headphones in will disable the internal speakers. This is
1304  * implemented in hardware, not via the driver using jack sense. In
1305  * a similar fashion, plugging into the rear socket marked "front" will
1306  * disable both the speakers and headphones.
1307  *
1308  * For input, there's a microphone jack, and an "audio in" jack.
1309  * These may not do anything useful with this driver yet, because I
1310  * haven't setup any initialization verbs for these yet...
1311  */
1312
1313 static hda_nid_t alc880_w810_dac_nids[3] = {
1314         /* front, rear/surround, clfe */
1315         0x02, 0x03, 0x04
1316 };
1317
1318 /* fixed 6 channels */
1319 static struct hda_channel_mode alc880_w810_modes[1] = {
1320         { 6, NULL }
1321 };
1322
1323 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1324 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1325         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1326         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1327         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1328         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1329         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1330         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1331         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1332         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1333         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1334         { } /* end */
1335 };
1336
1337
1338 /*
1339  * Z710V model
1340  *
1341  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1342  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1343  *                 Line = 0x1a
1344  */
1345
1346 static hda_nid_t alc880_z71v_dac_nids[1] = {
1347         0x02
1348 };
1349 #define ALC880_Z71V_HP_DAC      0x03
1350
1351 /* fixed 2 channels */
1352 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1353         { 2, NULL }
1354 };
1355
1356 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1357         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1358         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1359         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1360         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1361         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1362         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1363         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1364         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1365         { } /* end */
1366 };
1367
1368
1369 /*
1370  * ALC880 F1734 model
1371  *
1372  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1373  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1374  */
1375
1376 static hda_nid_t alc880_f1734_dac_nids[1] = {
1377         0x03
1378 };
1379 #define ALC880_F1734_HP_DAC     0x02
1380
1381 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1382         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1383         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1384         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1385         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1386         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1387         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1388         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1389         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1390         { } /* end */
1391 };
1392
1393 static struct hda_input_mux alc880_f1734_capture_source = {
1394         .num_items = 2,
1395         .items = {
1396                 { "Mic", 0x1 },
1397                 { "CD", 0x4 },
1398         },
1399 };
1400
1401
1402 /*
1403  * ALC880 ASUS model
1404  *
1405  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1406  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1407  *  Mic = 0x18, Line = 0x1a
1408  */
1409
1410 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1411 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1412
1413 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1414         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1415         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1416         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1417         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1418         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1419         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1420         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1421         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1422         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1423         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1424         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1425         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1426         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1427         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1428         {
1429                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1430                 .name = "Channel Mode",
1431                 .info = alc_ch_mode_info,
1432                 .get = alc_ch_mode_get,
1433                 .put = alc_ch_mode_put,
1434         },
1435         { } /* end */
1436 };
1437
1438 /*
1439  * ALC880 ASUS W1V model
1440  *
1441  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1442  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1443  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1444  */
1445
1446 /* additional mixers to alc880_asus_mixer */
1447 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1448         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1449         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1450         { } /* end */
1451 };
1452
1453 /* additional mixers to alc880_asus_mixer */
1454 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1455         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1456         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1457         { } /* end */
1458 };
1459
1460 /* TCL S700 */
1461 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1462         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1463         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1464         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1465         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1466         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1467         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1468         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1469         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1470         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1471         {
1472                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1473                 /* The multiple "Capture Source" controls confuse alsamixer
1474                  * So call somewhat different..
1475                  */
1476                 /* .name = "Capture Source", */
1477                 .name = "Input Source",
1478                 .count = 1,
1479                 .info = alc_mux_enum_info,
1480                 .get = alc_mux_enum_get,
1481                 .put = alc_mux_enum_put,
1482         },
1483         { } /* end */
1484 };
1485
1486 /* Uniwill */
1487 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1488         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1489         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1490         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1491         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1492         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1493         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1494         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1495         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1496         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1497         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1498         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1499         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1500         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1501         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1502         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1503         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1504         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1505         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1506         {
1507                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1508                 .name = "Channel Mode",
1509                 .info = alc_ch_mode_info,
1510                 .get = alc_ch_mode_get,
1511                 .put = alc_ch_mode_put,
1512         },
1513         { } /* end */
1514 };
1515
1516 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1517         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1518         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1519         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1520         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1521         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1522         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1523         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1524         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1525         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1526         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1527         { } /* end */
1528 };
1529
1530 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1531         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1532         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1533         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1534         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1535         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1536         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1537         { } /* end */
1538 };
1539
1540 /*
1541  * virtual master controls
1542  */
1543
1544 /*
1545  * slave controls for virtual master
1546  */
1547 static const char *alc_slave_vols[] = {
1548         "Front Playback Volume",
1549         "Surround Playback Volume",
1550         "Center Playback Volume",
1551         "LFE Playback Volume",
1552         "Side Playback Volume",
1553         "Headphone Playback Volume",
1554         "Speaker Playback Volume",
1555         "Mono Playback Volume",
1556         "Line-Out Playback Volume",
1557         NULL,
1558 };
1559
1560 static const char *alc_slave_sws[] = {
1561         "Front Playback Switch",
1562         "Surround Playback Switch",
1563         "Center Playback Switch",
1564         "LFE Playback Switch",
1565         "Side Playback Switch",
1566         "Headphone Playback Switch",
1567         "Speaker Playback Switch",
1568         "Mono Playback Switch",
1569         "IEC958 Playback Switch",
1570         NULL,
1571 };
1572
1573 /*
1574  * build control elements
1575  */
1576 static int alc_build_controls(struct hda_codec *codec)
1577 {
1578         struct alc_spec *spec = codec->spec;
1579         int err;
1580         int i;
1581
1582         for (i = 0; i < spec->num_mixers; i++) {
1583                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1584                 if (err < 0)
1585                         return err;
1586         }
1587
1588         if (spec->multiout.dig_out_nid) {
1589                 err = snd_hda_create_spdif_out_ctls(codec,
1590                                                     spec->multiout.dig_out_nid);
1591                 if (err < 0)
1592                         return err;
1593                 err = snd_hda_create_spdif_share_sw(codec,
1594                                                     &spec->multiout);
1595                 if (err < 0)
1596                         return err;
1597                 spec->multiout.share_spdif = 1;
1598         }
1599         if (spec->dig_in_nid) {
1600                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1601                 if (err < 0)
1602                         return err;
1603         }
1604
1605         /* if we have no master control, let's create it */
1606         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1607                 unsigned int vmaster_tlv[4];
1608                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1609                                         HDA_OUTPUT, vmaster_tlv);
1610                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1611                                           vmaster_tlv, alc_slave_vols);
1612                 if (err < 0)
1613                         return err;
1614         }
1615         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1616                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1617                                           NULL, alc_slave_sws);
1618                 if (err < 0)
1619                         return err;
1620         }
1621
1622         return 0;
1623 }
1624
1625
1626 /*
1627  * initialize the codec volumes, etc
1628  */
1629
1630 /*
1631  * generic initialization of ADC, input mixers and output mixers
1632  */
1633 static struct hda_verb alc880_volume_init_verbs[] = {
1634         /*
1635          * Unmute ADC0-2 and set the default input to mic-in
1636          */
1637         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1638         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1639         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1640         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1641         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1642         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1643
1644         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1645          * mixer widget
1646          * Note: PASD motherboards uses the Line In 2 as the input for front
1647          * panel mic (mic 2)
1648          */
1649         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1650         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1651         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1652         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1653         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1654         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1655         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1656         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1657
1658         /*
1659          * Set up output mixers (0x0c - 0x0f)
1660          */
1661         /* set vol=0 to output mixers */
1662         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1663         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1664         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1665         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1666         /* set up input amps for analog loopback */
1667         /* Amp Indices: DAC = 0, mixer = 1 */
1668         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1669         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1670         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1671         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1672         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1673         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1674         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1675         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1676
1677         { }
1678 };
1679
1680 /*
1681  * 3-stack pin configuration:
1682  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1683  */
1684 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1685         /*
1686          * preset connection lists of input pins
1687          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1688          */
1689         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1690         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1691         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1692
1693         /*
1694          * Set pin mode and muting
1695          */
1696         /* set front pin widgets 0x14 for output */
1697         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1698         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1699         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1700         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1701         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1702         /* Mic2 (as headphone out) for HP output */
1703         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1704         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1705         /* Line In pin widget for input */
1706         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1707         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1708         /* Line2 (as front mic) pin widget for input and vref at 80% */
1709         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1710         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1711         /* CD pin widget for input */
1712         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1713
1714         { }
1715 };
1716
1717 /*
1718  * 5-stack pin configuration:
1719  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1720  * line-in/side = 0x1a, f-mic = 0x1b
1721  */
1722 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1723         /*
1724          * preset connection lists of input pins
1725          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1726          */
1727         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1728         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1729
1730         /*
1731          * Set pin mode and muting
1732          */
1733         /* set pin widgets 0x14-0x17 for output */
1734         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1735         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1736         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1737         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1738         /* unmute pins for output (no gain on this amp) */
1739         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1740         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1741         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1742         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1743
1744         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1745         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1746         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1747         /* Mic2 (as headphone out) for HP output */
1748         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1749         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1750         /* Line In pin widget for input */
1751         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1752         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1753         /* Line2 (as front mic) pin widget for input and vref at 80% */
1754         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1755         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1756         /* CD pin widget for input */
1757         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1758
1759         { }
1760 };
1761
1762 /*
1763  * W810 pin configuration:
1764  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1765  */
1766 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1767         /* hphone/speaker input selector: front DAC */
1768         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1769
1770         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1771         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1772         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1773         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1774         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1775         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1776
1777         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1778         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1779
1780         { }
1781 };
1782
1783 /*
1784  * Z71V pin configuration:
1785  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1786  */
1787 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1788         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1789         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1790         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1791         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1792
1793         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1794         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1795         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1796         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1797
1798         { }
1799 };
1800
1801 /*
1802  * 6-stack pin configuration:
1803  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1804  * f-mic = 0x19, line = 0x1a, HP = 0x1b
1805  */
1806 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1807         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1808
1809         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1810         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1811         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1812         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1813         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1814         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1815         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1816         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1817
1818         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1819         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1820         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1821         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1822         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1823         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1824         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1825         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1826         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1827
1828         { }
1829 };
1830
1831 /*
1832  * Uniwill pin configuration:
1833  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1834  * line = 0x1a
1835  */
1836 static struct hda_verb alc880_uniwill_init_verbs[] = {
1837         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1838
1839         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1840         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1841         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1842         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1843         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1844         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1845         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1846         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1847         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1848         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1849         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1850         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1851         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1852         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1853
1854         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1855         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1856         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1857         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1858         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1859         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1860         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1861         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1862         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1863
1864         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1865         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1866
1867         { }
1868 };
1869
1870 /*
1871 * Uniwill P53
1872 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1873  */
1874 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1875         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1876
1877         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1878         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1879         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1880         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1881         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1882         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1883         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1884         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1885         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1886         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1887         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1888         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1889
1890         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1891         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1892         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1893         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1894         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1895         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1896
1897         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1898         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1899
1900         { }
1901 };
1902
1903 static struct hda_verb alc880_beep_init_verbs[] = {
1904         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1905         { }
1906 };
1907
1908 /* toggle speaker-output according to the hp-jack state */
1909 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1910 {
1911         unsigned int present;
1912         unsigned char bits;
1913
1914         present = snd_hda_codec_read(codec, 0x14, 0,
1915                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1916         bits = present ? HDA_AMP_MUTE : 0;
1917         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1918                                  HDA_AMP_MUTE, bits);
1919         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1920                                  HDA_AMP_MUTE, bits);
1921 }
1922
1923 /* auto-toggle front mic */
1924 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1925 {
1926         unsigned int present;
1927         unsigned char bits;
1928
1929         present = snd_hda_codec_read(codec, 0x18, 0,
1930                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1931         bits = present ? HDA_AMP_MUTE : 0;
1932         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1933 }
1934
1935 static void alc880_uniwill_automute(struct hda_codec *codec)
1936 {
1937         alc880_uniwill_hp_automute(codec);
1938         alc880_uniwill_mic_automute(codec);
1939 }
1940
1941 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
1942                                        unsigned int res)
1943 {
1944         /* Looks like the unsol event is incompatible with the standard
1945          * definition.  4bit tag is placed at 28 bit!
1946          */
1947         switch (res >> 28) {
1948         case ALC880_HP_EVENT:
1949                 alc880_uniwill_hp_automute(codec);
1950                 break;
1951         case ALC880_MIC_EVENT:
1952                 alc880_uniwill_mic_automute(codec);
1953                 break;
1954         }
1955 }
1956
1957 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
1958 {
1959         unsigned int present;
1960         unsigned char bits;
1961
1962         present = snd_hda_codec_read(codec, 0x14, 0,
1963                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1964         bits = present ? HDA_AMP_MUTE : 0;
1965         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
1966 }
1967
1968 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
1969 {
1970         unsigned int present;
1971
1972         present = snd_hda_codec_read(codec, 0x21, 0,
1973                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
1974         present &= HDA_AMP_VOLMASK;
1975         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
1976                                  HDA_AMP_VOLMASK, present);
1977         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
1978                                  HDA_AMP_VOLMASK, present);
1979 }
1980
1981 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
1982                                            unsigned int res)
1983 {
1984         /* Looks like the unsol event is incompatible with the standard
1985          * definition.  4bit tag is placed at 28 bit!
1986          */
1987         if ((res >> 28) == ALC880_HP_EVENT)
1988                 alc880_uniwill_p53_hp_automute(codec);
1989         if ((res >> 28) == ALC880_DCVOL_EVENT)
1990                 alc880_uniwill_p53_dcvol_automute(codec);
1991 }
1992
1993 /*
1994  * F1734 pin configuration:
1995  * HP = 0x14, speaker-out = 0x15, mic = 0x18
1996  */
1997 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
1998         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
1999         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2000         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2001         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2002         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2003
2004         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2005         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2006         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2007         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2008
2009         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2010         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2011         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2012         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2013         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2014         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2015         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2016         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2017         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2018
2019         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2020         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2021
2022         { }
2023 };
2024
2025 /*
2026  * ASUS pin configuration:
2027  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2028  */
2029 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2030         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2031         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2032         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2033         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2034
2035         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2036         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2037         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2038         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2039         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2040         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2041         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2042         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2043
2044         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2045         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2046         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2047         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2048         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2049         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2050         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2051         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2052         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2053
2054         { }
2055 };
2056
2057 /* Enable GPIO mask and set output */
2058 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2059 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2060
2061 /* Clevo m520g init */
2062 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2063         /* headphone output */
2064         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2065         /* line-out */
2066         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2067         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2068         /* Line-in */
2069         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2070         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2071         /* CD */
2072         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2073         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2074         /* Mic1 (rear panel) */
2075         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2076         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2077         /* Mic2 (front panel) */
2078         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2079         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2080         /* headphone */
2081         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2082         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2083         /* change to EAPD mode */
2084         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2085         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2086
2087         { }
2088 };
2089
2090 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2091         /* change to EAPD mode */
2092         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2093         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2094
2095         /* Headphone output */
2096         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2097         /* Front output*/
2098         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2099         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2100
2101         /* Line In pin widget for input */
2102         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2103         /* CD pin widget for input */
2104         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2105         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2106         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2107
2108         /* change to EAPD mode */
2109         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2110         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2111
2112         { }
2113 };
2114
2115 /*
2116  * LG m1 express dual
2117  *
2118  * Pin assignment:
2119  *   Rear Line-In/Out (blue): 0x14
2120  *   Build-in Mic-In: 0x15
2121  *   Speaker-out: 0x17
2122  *   HP-Out (green): 0x1b
2123  *   Mic-In/Out (red): 0x19
2124  *   SPDIF-Out: 0x1e
2125  */
2126
2127 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2128 static hda_nid_t alc880_lg_dac_nids[3] = {
2129         0x05, 0x02, 0x03
2130 };
2131
2132 /* seems analog CD is not working */
2133 static struct hda_input_mux alc880_lg_capture_source = {
2134         .num_items = 3,
2135         .items = {
2136                 { "Mic", 0x1 },
2137                 { "Line", 0x5 },
2138                 { "Internal Mic", 0x6 },
2139         },
2140 };
2141
2142 /* 2,4,6 channel modes */
2143 static struct hda_verb alc880_lg_ch2_init[] = {
2144         /* set line-in and mic-in to input */
2145         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2146         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2147         { }
2148 };
2149
2150 static struct hda_verb alc880_lg_ch4_init[] = {
2151         /* set line-in to out and mic-in to input */
2152         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2153         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2154         { }
2155 };
2156
2157 static struct hda_verb alc880_lg_ch6_init[] = {
2158         /* set line-in and mic-in to output */
2159         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2160         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2161         { }
2162 };
2163
2164 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2165         { 2, alc880_lg_ch2_init },
2166         { 4, alc880_lg_ch4_init },
2167         { 6, alc880_lg_ch6_init },
2168 };
2169
2170 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2171         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2172         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2173         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2174         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2175         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2176         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2177         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2178         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2179         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2180         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2181         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2182         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2183         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2184         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2185         {
2186                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2187                 .name = "Channel Mode",
2188                 .info = alc_ch_mode_info,
2189                 .get = alc_ch_mode_get,
2190                 .put = alc_ch_mode_put,
2191         },
2192         { } /* end */
2193 };
2194
2195 static struct hda_verb alc880_lg_init_verbs[] = {
2196         /* set capture source to mic-in */
2197         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2198         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2199         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2200         /* mute all amp mixer inputs */
2201         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2202         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2203         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2204         /* line-in to input */
2205         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2206         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2207         /* built-in mic */
2208         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2209         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2210         /* speaker-out */
2211         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2212         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2213         /* mic-in to input */
2214         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2215         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2216         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2217         /* HP-out */
2218         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2219         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2220         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2221         /* jack sense */
2222         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2223         { }
2224 };
2225
2226 /* toggle speaker-output according to the hp-jack state */
2227 static void alc880_lg_automute(struct hda_codec *codec)
2228 {
2229         unsigned int present;
2230         unsigned char bits;
2231
2232         present = snd_hda_codec_read(codec, 0x1b, 0,
2233                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2234         bits = present ? HDA_AMP_MUTE : 0;
2235         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2236                                  HDA_AMP_MUTE, bits);
2237 }
2238
2239 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2240 {
2241         /* Looks like the unsol event is incompatible with the standard
2242          * definition.  4bit tag is placed at 28 bit!
2243          */
2244         if ((res >> 28) == 0x01)
2245                 alc880_lg_automute(codec);
2246 }
2247
2248 /*
2249  * LG LW20
2250  *
2251  * Pin assignment:
2252  *   Speaker-out: 0x14
2253  *   Mic-In: 0x18
2254  *   Built-in Mic-In: 0x19
2255  *   Line-In: 0x1b
2256  *   HP-Out: 0x1a
2257  *   SPDIF-Out: 0x1e
2258  */
2259
2260 static struct hda_input_mux alc880_lg_lw_capture_source = {
2261         .num_items = 3,
2262         .items = {
2263                 { "Mic", 0x0 },
2264                 { "Internal Mic", 0x1 },
2265                 { "Line In", 0x2 },
2266         },
2267 };
2268
2269 #define alc880_lg_lw_modes alc880_threestack_modes
2270
2271 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2272         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2273         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2274         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2275         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2276         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2277         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2278         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2279         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2280         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2281         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2282         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2283         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2284         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2285         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2286         {
2287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2288                 .name = "Channel Mode",
2289                 .info = alc_ch_mode_info,
2290                 .get = alc_ch_mode_get,
2291                 .put = alc_ch_mode_put,
2292         },
2293         { } /* end */
2294 };
2295
2296 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2297         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2298         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2299         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2300
2301         /* set capture source to mic-in */
2302         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2303         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2304         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2305         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2306         /* speaker-out */
2307         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2308         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2309         /* HP-out */
2310         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2311         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2312         /* mic-in to input */
2313         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2314         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2315         /* built-in mic */
2316         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2317         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2318         /* jack sense */
2319         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2320         { }
2321 };
2322
2323 /* toggle speaker-output according to the hp-jack state */
2324 static void alc880_lg_lw_automute(struct hda_codec *codec)
2325 {
2326         unsigned int present;
2327         unsigned char bits;
2328
2329         present = snd_hda_codec_read(codec, 0x1b, 0,
2330                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2331         bits = present ? HDA_AMP_MUTE : 0;
2332         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2333                                  HDA_AMP_MUTE, bits);
2334 }
2335
2336 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2337 {
2338         /* Looks like the unsol event is incompatible with the standard
2339          * definition.  4bit tag is placed at 28 bit!
2340          */
2341         if ((res >> 28) == 0x01)
2342                 alc880_lg_lw_automute(codec);
2343 }
2344
2345 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2346         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2347         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2348         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2349         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2350         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2351         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2352         { } /* end */
2353 };
2354
2355 static struct hda_input_mux alc880_medion_rim_capture_source = {
2356         .num_items = 2,
2357         .items = {
2358                 { "Mic", 0x0 },
2359                 { "Internal Mic", 0x1 },
2360         },
2361 };
2362
2363 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2364         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2365
2366         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2367         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2368
2369         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2370         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2371         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2372         /* Mic2 (as headphone out) for HP output */
2373         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2374         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2375         /* Internal Speaker */
2376         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2377         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2378
2379         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2380         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2381
2382         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2383         { }
2384 };
2385
2386 /* toggle speaker-output according to the hp-jack state */
2387 static void alc880_medion_rim_automute(struct hda_codec *codec)
2388 {
2389         unsigned int present;
2390         unsigned char bits;
2391
2392         present = snd_hda_codec_read(codec, 0x14, 0,
2393                                      AC_VERB_GET_PIN_SENSE, 0)
2394                 & AC_PINSENSE_PRESENCE;
2395         bits = present ? HDA_AMP_MUTE : 0;
2396         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2397                                  HDA_AMP_MUTE, bits);
2398         if (present)
2399                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2400         else
2401                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2402 }
2403
2404 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2405                                           unsigned int res)
2406 {
2407         /* Looks like the unsol event is incompatible with the standard
2408          * definition.  4bit tag is placed at 28 bit!
2409          */
2410         if ((res >> 28) == ALC880_HP_EVENT)
2411                 alc880_medion_rim_automute(codec);
2412 }
2413
2414 #ifdef CONFIG_SND_HDA_POWER_SAVE
2415 static struct hda_amp_list alc880_loopbacks[] = {
2416         { 0x0b, HDA_INPUT, 0 },
2417         { 0x0b, HDA_INPUT, 1 },
2418         { 0x0b, HDA_INPUT, 2 },
2419         { 0x0b, HDA_INPUT, 3 },
2420         { 0x0b, HDA_INPUT, 4 },
2421         { } /* end */
2422 };
2423
2424 static struct hda_amp_list alc880_lg_loopbacks[] = {
2425         { 0x0b, HDA_INPUT, 1 },
2426         { 0x0b, HDA_INPUT, 6 },
2427         { 0x0b, HDA_INPUT, 7 },
2428         { } /* end */
2429 };
2430 #endif
2431
2432 /*
2433  * Common callbacks
2434  */
2435
2436 static int alc_init(struct hda_codec *codec)
2437 {
2438         struct alc_spec *spec = codec->spec;
2439         unsigned int i;
2440
2441         alc_fix_pll(codec);
2442
2443         for (i = 0; i < spec->num_init_verbs; i++)
2444                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2445
2446         if (spec->init_hook)
2447                 spec->init_hook(codec);
2448
2449         return 0;
2450 }
2451
2452 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2453 {
2454         struct alc_spec *spec = codec->spec;
2455
2456         if (spec->unsol_event)
2457                 spec->unsol_event(codec, res);
2458 }
2459
2460 #ifdef CONFIG_SND_HDA_POWER_SAVE
2461 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2462 {
2463         struct alc_spec *spec = codec->spec;
2464         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2465 }
2466 #endif
2467
2468 /*
2469  * Analog playback callbacks
2470  */
2471 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2472                                     struct hda_codec *codec,
2473                                     struct snd_pcm_substream *substream)
2474 {
2475         struct alc_spec *spec = codec->spec;
2476         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2477                                              hinfo);
2478 }
2479
2480 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2481                                        struct hda_codec *codec,
2482                                        unsigned int stream_tag,
2483                                        unsigned int format,
2484                                        struct snd_pcm_substream *substream)
2485 {
2486         struct alc_spec *spec = codec->spec;
2487         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2488                                                 stream_tag, format, substream);
2489 }
2490
2491 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2492                                        struct hda_codec *codec,
2493                                        struct snd_pcm_substream *substream)
2494 {
2495         struct alc_spec *spec = codec->spec;
2496         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2497 }
2498
2499 /*
2500  * Digital out
2501  */
2502 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2503                                         struct hda_codec *codec,
2504                                         struct snd_pcm_substream *substream)
2505 {
2506         struct alc_spec *spec = codec->spec;
2507         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2508 }
2509
2510 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2511                                            struct hda_codec *codec,
2512                                            unsigned int stream_tag,
2513                                            unsigned int format,
2514                                            struct snd_pcm_substream *substream)
2515 {
2516         struct alc_spec *spec = codec->spec;
2517         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2518                                              stream_tag, format, substream);
2519 }
2520
2521 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2522                                          struct hda_codec *codec,
2523                                          struct snd_pcm_substream *substream)
2524 {
2525         struct alc_spec *spec = codec->spec;
2526         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2527 }
2528
2529 /*
2530  * Analog capture
2531  */
2532 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2533                                       struct hda_codec *codec,
2534                                       unsigned int stream_tag,
2535                                       unsigned int format,
2536                                       struct snd_pcm_substream *substream)
2537 {
2538         struct alc_spec *spec = codec->spec;
2539
2540         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2541                                    stream_tag, 0, format);
2542         return 0;
2543 }
2544
2545 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2546                                       struct hda_codec *codec,
2547                                       struct snd_pcm_substream *substream)
2548 {
2549         struct alc_spec *spec = codec->spec;
2550
2551         snd_hda_codec_cleanup_stream(codec,
2552                                      spec->adc_nids[substream->number + 1]);
2553         return 0;
2554 }
2555
2556
2557 /*
2558  */
2559 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2560         .substreams = 1,
2561         .channels_min = 2,
2562         .channels_max = 8,
2563         /* NID is set in alc_build_pcms */
2564         .ops = {
2565                 .open = alc880_playback_pcm_open,
2566                 .prepare = alc880_playback_pcm_prepare,
2567                 .cleanup = alc880_playback_pcm_cleanup
2568         },
2569 };
2570
2571 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2572         .substreams = 1,
2573         .channels_min = 2,
2574         .channels_max = 2,
2575         /* NID is set in alc_build_pcms */
2576 };
2577
2578 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2579         .substreams = 1,
2580         .channels_min = 2,
2581         .channels_max = 2,
2582         /* NID is set in alc_build_pcms */
2583 };
2584
2585 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2586         .substreams = 2, /* can be overridden */
2587         .channels_min = 2,
2588         .channels_max = 2,
2589         /* NID is set in alc_build_pcms */
2590         .ops = {
2591                 .prepare = alc880_alt_capture_pcm_prepare,
2592                 .cleanup = alc880_alt_capture_pcm_cleanup
2593         },
2594 };
2595
2596 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2597         .substreams = 1,
2598         .channels_min = 2,
2599         .channels_max = 2,
2600         /* NID is set in alc_build_pcms */
2601         .ops = {
2602                 .open = alc880_dig_playback_pcm_open,
2603                 .close = alc880_dig_playback_pcm_close,
2604                 .prepare = alc880_dig_playback_pcm_prepare
2605         },
2606 };
2607
2608 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2609         .substreams = 1,
2610         .channels_min = 2,
2611         .channels_max = 2,
2612         /* NID is set in alc_build_pcms */
2613 };
2614
2615 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2616 static struct hda_pcm_stream alc_pcm_null_stream = {
2617         .substreams = 0,
2618         .channels_min = 0,
2619         .channels_max = 0,
2620 };
2621
2622 static int alc_build_pcms(struct hda_codec *codec)
2623 {
2624         struct alc_spec *spec = codec->spec;
2625         struct hda_pcm *info = spec->pcm_rec;
2626         int i;
2627
2628         codec->num_pcms = 1;
2629         codec->pcm_info = info;
2630
2631         info->name = spec->stream_name_analog;
2632         if (spec->stream_analog_playback) {
2633                 snd_assert(spec->multiout.dac_nids, return -EINVAL);
2634                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2635                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2636         }
2637         if (spec->stream_analog_capture) {
2638                 snd_assert(spec->adc_nids, return -EINVAL);
2639                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2640                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2641         }
2642
2643         if (spec->channel_mode) {
2644                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2645                 for (i = 0; i < spec->num_channel_mode; i++) {
2646                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2647                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2648                         }
2649                 }
2650         }
2651
2652         /* SPDIF for stream index #1 */
2653         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2654                 codec->num_pcms = 2;
2655                 info = spec->pcm_rec + 1;
2656                 info->name = spec->stream_name_digital;
2657                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2658                 if (spec->multiout.dig_out_nid &&
2659                     spec->stream_digital_playback) {
2660                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2661                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2662                 }
2663                 if (spec->dig_in_nid &&
2664                     spec->stream_digital_capture) {
2665                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2666                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2667                 }
2668         }
2669
2670         /* If the use of more than one ADC is requested for the current
2671          * model, configure a second analog capture-only PCM.
2672          */
2673         /* Additional Analaog capture for index #2 */
2674         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2675             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2676                 codec->num_pcms = 3;
2677                 info = spec->pcm_rec + 2;
2678                 info->name = spec->stream_name_analog;
2679                 if (spec->alt_dac_nid) {
2680                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2681                                 *spec->stream_analog_alt_playback;
2682                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2683                                 spec->alt_dac_nid;
2684                 } else {
2685                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2686                                 alc_pcm_null_stream;
2687                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2688                 }
2689                 if (spec->num_adc_nids > 1) {
2690                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2691                                 *spec->stream_analog_alt_capture;
2692                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2693                                 spec->adc_nids[1];
2694                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2695                                 spec->num_adc_nids - 1;
2696                 } else {
2697                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2698                                 alc_pcm_null_stream;
2699                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2700                 }
2701         }
2702
2703         return 0;
2704 }
2705
2706 static void alc_free(struct hda_codec *codec)
2707 {
2708         struct alc_spec *spec = codec->spec;
2709         unsigned int i;
2710
2711         if (!spec)
2712                 return;
2713
2714         if (spec->kctl_alloc) {
2715                 for (i = 0; i < spec->num_kctl_used; i++)
2716                         kfree(spec->kctl_alloc[i].name);
2717                 kfree(spec->kctl_alloc);
2718         }
2719         kfree(spec);
2720         codec->spec = NULL; /* to be sure */
2721 }
2722
2723 /*
2724  */
2725 static struct hda_codec_ops alc_patch_ops = {
2726         .build_controls = alc_build_controls,
2727         .build_pcms = alc_build_pcms,
2728         .init = alc_init,
2729         .free = alc_free,
2730         .unsol_event = alc_unsol_event,
2731 #ifdef CONFIG_SND_HDA_POWER_SAVE
2732         .check_power_status = alc_check_power_status,
2733 #endif
2734 };
2735
2736
2737 /*
2738  * Test configuration for debugging
2739  *
2740  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
2741  * enum controls.
2742  */
2743 #ifdef CONFIG_SND_DEBUG
2744 static hda_nid_t alc880_test_dac_nids[4] = {
2745         0x02, 0x03, 0x04, 0x05
2746 };
2747
2748 static struct hda_input_mux alc880_test_capture_source = {
2749         .num_items = 7,
2750         .items = {
2751                 { "In-1", 0x0 },
2752                 { "In-2", 0x1 },
2753                 { "In-3", 0x2 },
2754                 { "In-4", 0x3 },
2755                 { "CD", 0x4 },
2756                 { "Front", 0x5 },
2757                 { "Surround", 0x6 },
2758         },
2759 };
2760
2761 static struct hda_channel_mode alc880_test_modes[4] = {
2762         { 2, NULL },
2763         { 4, NULL },
2764         { 6, NULL },
2765         { 8, NULL },
2766 };
2767
2768 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2769                                  struct snd_ctl_elem_info *uinfo)
2770 {
2771         static char *texts[] = {
2772                 "N/A", "Line Out", "HP Out",
2773                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2774         };
2775         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2776         uinfo->count = 1;
2777         uinfo->value.enumerated.items = 8;
2778         if (uinfo->value.enumerated.item >= 8)
2779                 uinfo->value.enumerated.item = 7;
2780         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2781         return 0;
2782 }
2783
2784 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2785                                 struct snd_ctl_elem_value *ucontrol)
2786 {
2787         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2788         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2789         unsigned int pin_ctl, item = 0;
2790
2791         pin_ctl = snd_hda_codec_read(codec, nid, 0,
2792                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2793         if (pin_ctl & AC_PINCTL_OUT_EN) {
2794                 if (pin_ctl & AC_PINCTL_HP_EN)
2795                         item = 2;
2796                 else
2797                         item = 1;
2798         } else if (pin_ctl & AC_PINCTL_IN_EN) {
2799                 switch (pin_ctl & AC_PINCTL_VREFEN) {
2800                 case AC_PINCTL_VREF_HIZ: item = 3; break;
2801                 case AC_PINCTL_VREF_50:  item = 4; break;
2802                 case AC_PINCTL_VREF_GRD: item = 5; break;
2803                 case AC_PINCTL_VREF_80:  item = 6; break;
2804                 case AC_PINCTL_VREF_100: item = 7; break;
2805                 }
2806         }
2807         ucontrol->value.enumerated.item[0] = item;
2808         return 0;
2809 }
2810
2811 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2812                                 struct snd_ctl_elem_value *ucontrol)
2813 {
2814         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2815         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2816         static unsigned int ctls[] = {
2817                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2818                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2819                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2820                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2821                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2822                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2823         };
2824         unsigned int old_ctl, new_ctl;
2825
2826         old_ctl = snd_hda_codec_read(codec, nid, 0,
2827                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2828         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2829         if (old_ctl != new_ctl) {
2830                 int val;
2831                 snd_hda_codec_write_cache(codec, nid, 0,
2832                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
2833                                           new_ctl);
2834                 val = ucontrol->value.enumerated.item[0] >= 3 ?
2835                         HDA_AMP_MUTE : 0;
2836                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2837                                          HDA_AMP_MUTE, val);
2838                 return 1;
2839         }
2840         return 0;
2841 }
2842
2843 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2844                                  struct snd_ctl_elem_info *uinfo)
2845 {
2846         static char *texts[] = {
2847                 "Front", "Surround", "CLFE", "Side"
2848         };
2849         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2850         uinfo->count = 1;
2851         uinfo->value.enumerated.items = 4;
2852         if (uinfo->value.enumerated.item >= 4)
2853                 uinfo->value.enumerated.item = 3;
2854         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2855         return 0;
2856 }
2857
2858 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2859                                 struct snd_ctl_elem_value *ucontrol)
2860 {
2861         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2862         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2863         unsigned int sel;
2864
2865         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2866         ucontrol->value.enumerated.item[0] = sel & 3;
2867         return 0;
2868 }
2869
2870 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2871                                 struct snd_ctl_elem_value *ucontrol)
2872 {
2873         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2874         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2875         unsigned int sel;
2876
2877         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
2878         if (ucontrol->value.enumerated.item[0] != sel) {
2879                 sel = ucontrol->value.enumerated.item[0] & 3;
2880                 snd_hda_codec_write_cache(codec, nid, 0,
2881                                           AC_VERB_SET_CONNECT_SEL, sel);
2882                 return 1;
2883         }
2884         return 0;
2885 }
2886
2887 #define PIN_CTL_TEST(xname,nid) {                       \
2888                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
2889                         .name = xname,                 \
2890                         .info = alc_test_pin_ctl_info, \
2891                         .get = alc_test_pin_ctl_get,   \
2892                         .put = alc_test_pin_ctl_put,   \
2893                         .private_value = nid           \
2894                         }
2895
2896 #define PIN_SRC_TEST(xname,nid) {                       \
2897                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
2898                         .name = xname,                 \
2899                         .info = alc_test_pin_src_info, \
2900                         .get = alc_test_pin_src_get,   \
2901                         .put = alc_test_pin_src_put,   \
2902                         .private_value = nid           \
2903                         }
2904
2905 static struct snd_kcontrol_new alc880_test_mixer[] = {
2906         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2907         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2908         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2909         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2910         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2911         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2912         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
2913         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2914         PIN_CTL_TEST("Front Pin Mode", 0x14),
2915         PIN_CTL_TEST("Surround Pin Mode", 0x15),
2916         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2917         PIN_CTL_TEST("Side Pin Mode", 0x17),
2918         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2919         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2920         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2921         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2922         PIN_SRC_TEST("In-1 Pin Source", 0x18),
2923         PIN_SRC_TEST("In-2 Pin Source", 0x19),
2924         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2925         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2926         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
2927         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
2928         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
2929         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
2930         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
2931         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
2932         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
2933         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
2934         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
2935         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
2936         {
2937                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2938                 .name = "Channel Mode",
2939                 .info = alc_ch_mode_info,
2940                 .get = alc_ch_mode_get,
2941                 .put = alc_ch_mode_put,
2942         },
2943         { } /* end */
2944 };
2945
2946 static struct hda_verb alc880_test_init_verbs[] = {
2947         /* Unmute inputs of 0x0c - 0x0f */
2948         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2949         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2950         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2951         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2952         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2953         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2954         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2955         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2956         /* Vol output for 0x0c-0x0f */
2957         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2958         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2959         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2960         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2961         /* Set output pins 0x14-0x17 */
2962         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2963         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2964         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2965         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2966         /* Unmute output pins 0x14-0x17 */
2967         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2968         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2969         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2970         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2971         /* Set input pins 0x18-0x1c */
2972         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2973         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2974         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2975         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2976         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2977         /* Mute input pins 0x18-0x1b */
2978         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2979         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2980         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2981         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2982         /* ADC set up */
2983         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2984         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2985         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2986         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2987         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2988         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2989         /* Analog input/passthru */
2990         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2991         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2992         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2993         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2994         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2995         { }
2996 };
2997 #endif
2998
2999 /*
3000  */
3001
3002 static const char *alc880_models[ALC880_MODEL_LAST] = {
3003         [ALC880_3ST]            = "3stack",
3004         [ALC880_TCL_S700]       = "tcl",
3005         [ALC880_3ST_DIG]        = "3stack-digout",
3006         [ALC880_CLEVO]          = "clevo",
3007         [ALC880_5ST]            = "5stack",
3008         [ALC880_5ST_DIG]        = "5stack-digout",
3009         [ALC880_W810]           = "w810",
3010         [ALC880_Z71V]           = "z71v",
3011         [ALC880_6ST]            = "6stack",
3012         [ALC880_6ST_DIG]        = "6stack-digout",
3013         [ALC880_ASUS]           = "asus",
3014         [ALC880_ASUS_W1V]       = "asus-w1v",
3015         [ALC880_ASUS_DIG]       = "asus-dig",
3016         [ALC880_ASUS_DIG2]      = "asus-dig2",
3017         [ALC880_UNIWILL_DIG]    = "uniwill",
3018         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3019         [ALC880_FUJITSU]        = "fujitsu",
3020         [ALC880_F1734]          = "F1734",
3021         [ALC880_LG]             = "lg",
3022         [ALC880_LG_LW]          = "lg-lw",
3023         [ALC880_MEDION_RIM]     = "medion",
3024 #ifdef CONFIG_SND_DEBUG
3025         [ALC880_TEST]           = "test",
3026 #endif
3027         [ALC880_AUTO]           = "auto",
3028 };
3029
3030 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3031         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3032         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3033         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3034         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3035         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3036         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3037         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3038         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3039         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3040         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3041         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3042         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3043         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3044         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3045         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3046         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3047         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3048         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3049         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3050         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3051         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3052         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3053         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3054         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3055         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3056         SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3057         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3058         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3059         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3060         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3061         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3062         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3063         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3064         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3065         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3066         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3067         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3068         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3069         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3070         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3071         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3072         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3073         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3074         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3075         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3076         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3077         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3078         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3079         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3080         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3081         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3082         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3083         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3084         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3085         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3086         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3087         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3088         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3089         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3090         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3091         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3092         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3093         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3094         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3095         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3096         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3097         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3098         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3099         SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3100         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3101         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3102         {}
3103 };
3104
3105 /*
3106  * ALC880 codec presets
3107  */
3108 static struct alc_config_preset alc880_presets[] = {
3109         [ALC880_3ST] = {
3110                 .mixers = { alc880_three_stack_mixer },
3111                 .init_verbs = { alc880_volume_init_verbs,
3112                                 alc880_pin_3stack_init_verbs },
3113                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3114                 .dac_nids = alc880_dac_nids,
3115                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3116                 .channel_mode = alc880_threestack_modes,
3117                 .need_dac_fix = 1,
3118                 .input_mux = &alc880_capture_source,
3119         },
3120         [ALC880_3ST_DIG] = {
3121                 .mixers = { alc880_three_stack_mixer },
3122                 .init_verbs = { alc880_volume_init_verbs,
3123                                 alc880_pin_3stack_init_verbs },
3124                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3125                 .dac_nids = alc880_dac_nids,
3126                 .dig_out_nid = ALC880_DIGOUT_NID,
3127                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3128                 .channel_mode = alc880_threestack_modes,
3129                 .need_dac_fix = 1,
3130                 .input_mux = &alc880_capture_source,
3131         },
3132         [ALC880_TCL_S700] = {
3133                 .mixers = { alc880_tcl_s700_mixer },
3134                 .init_verbs = { alc880_volume_init_verbs,
3135                                 alc880_pin_tcl_S700_init_verbs,
3136                                 alc880_gpio2_init_verbs },
3137                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3138                 .dac_nids = alc880_dac_nids,
3139                 .hp_nid = 0x03,
3140                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3141                 .channel_mode = alc880_2_jack_modes,
3142                 .input_mux = &alc880_capture_source,
3143         },
3144         [ALC880_5ST] = {
3145                 .mixers = { alc880_three_stack_mixer,
3146                             alc880_five_stack_mixer},
3147                 .init_verbs = { alc880_volume_init_verbs,
3148                                 alc880_pin_5stack_init_verbs },
3149                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3150                 .dac_nids = alc880_dac_nids,
3151                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3152                 .channel_mode = alc880_fivestack_modes,
3153                 .input_mux = &alc880_capture_source,
3154         },
3155         [ALC880_5ST_DIG] = {
3156                 .mixers = { alc880_three_stack_mixer,
3157                             alc880_five_stack_mixer },
3158                 .init_verbs = { alc880_volume_init_verbs,
3159                                 alc880_pin_5stack_init_verbs },
3160                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3161                 .dac_nids = alc880_dac_nids,
3162                 .dig_out_nid = ALC880_DIGOUT_NID,
3163                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3164                 .channel_mode = alc880_fivestack_modes,
3165                 .input_mux = &alc880_capture_source,
3166         },
3167         [ALC880_6ST] = {
3168                 .mixers = { alc880_six_stack_mixer },
3169                 .init_verbs = { alc880_volume_init_verbs,
3170                                 alc880_pin_6stack_init_verbs },
3171                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3172                 .dac_nids = alc880_6st_dac_nids,
3173                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3174                 .channel_mode = alc880_sixstack_modes,
3175                 .input_mux = &alc880_6stack_capture_source,
3176         },
3177         [ALC880_6ST_DIG] = {
3178                 .mixers = { alc880_six_stack_mixer },
3179                 .init_verbs = { alc880_volume_init_verbs,
3180                                 alc880_pin_6stack_init_verbs },
3181                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3182                 .dac_nids = alc880_6st_dac_nids,
3183                 .dig_out_nid = ALC880_DIGOUT_NID,
3184                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3185                 .channel_mode = alc880_sixstack_modes,
3186                 .input_mux = &alc880_6stack_capture_source,
3187         },
3188         [ALC880_W810] = {
3189                 .mixers = { alc880_w810_base_mixer },
3190                 .init_verbs = { alc880_volume_init_verbs,
3191                                 alc880_pin_w810_init_verbs,
3192                                 alc880_gpio2_init_verbs },
3193                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3194                 .dac_nids = alc880_w810_dac_nids,
3195                 .dig_out_nid = ALC880_DIGOUT_NID,
3196                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3197                 .channel_mode = alc880_w810_modes,
3198                 .input_mux = &alc880_capture_source,
3199         },
3200         [ALC880_Z71V] = {
3201                 .mixers = { alc880_z71v_mixer },
3202                 .init_verbs = { alc880_volume_init_verbs,
3203                                 alc880_pin_z71v_init_verbs },
3204                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3205                 .dac_nids = alc880_z71v_dac_nids,
3206                 .dig_out_nid = ALC880_DIGOUT_NID,
3207                 .hp_nid = 0x03,
3208                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3209                 .channel_mode = alc880_2_jack_modes,
3210                 .input_mux = &alc880_capture_source,
3211         },
3212         [ALC880_F1734] = {
3213                 .mixers = { alc880_f1734_mixer },
3214                 .init_verbs = { alc880_volume_init_verbs,
3215                                 alc880_pin_f1734_init_verbs },
3216                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3217                 .dac_nids = alc880_f1734_dac_nids,
3218                 .hp_nid = 0x02,
3219                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3220                 .channel_mode = alc880_2_jack_modes,
3221                 .input_mux = &alc880_f1734_capture_source,
3222                 .unsol_event = alc880_uniwill_p53_unsol_event,
3223                 .init_hook = alc880_uniwill_p53_hp_automute,
3224         },
3225         [ALC880_ASUS] = {
3226                 .mixers = { alc880_asus_mixer },
3227                 .init_verbs = { alc880_volume_init_verbs,
3228                                 alc880_pin_asus_init_verbs,
3229                                 alc880_gpio1_init_verbs },
3230                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3231                 .dac_nids = alc880_asus_dac_nids,
3232                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3233                 .channel_mode = alc880_asus_modes,
3234                 .need_dac_fix = 1,
3235                 .input_mux = &alc880_capture_source,
3236         },
3237         [ALC880_ASUS_DIG] = {
3238                 .mixers = { alc880_asus_mixer },
3239                 .init_verbs = { alc880_volume_init_verbs,
3240                                 alc880_pin_asus_init_verbs,
3241                                 alc880_gpio1_init_verbs },
3242                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3243                 .dac_nids = alc880_asus_dac_nids,
3244                 .dig_out_nid = ALC880_DIGOUT_NID,
3245                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3246                 .channel_mode = alc880_asus_modes,
3247                 .need_dac_fix = 1,
3248                 .input_mux = &alc880_capture_source,
3249         },
3250         [ALC880_ASUS_DIG2] = {
3251                 .mixers = { alc880_asus_mixer },
3252                 .init_verbs = { alc880_volume_init_verbs,
3253                                 alc880_pin_asus_init_verbs,
3254                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3255                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3256                 .dac_nids = alc880_asus_dac_nids,
3257                 .dig_out_nid = ALC880_DIGOUT_NID,
3258                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3259                 .channel_mode = alc880_asus_modes,
3260                 .need_dac_fix = 1,
3261                 .input_mux = &alc880_capture_source,
3262         },
3263         [ALC880_ASUS_W1V] = {
3264                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3265                 .init_verbs = { alc880_volume_init_verbs,
3266                                 alc880_pin_asus_init_verbs,
3267                                 alc880_gpio1_init_verbs },
3268                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3269                 .dac_nids = alc880_asus_dac_nids,
3270                 .dig_out_nid = ALC880_DIGOUT_NID,
3271                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3272                 .channel_mode = alc880_asus_modes,
3273                 .need_dac_fix = 1,
3274                 .input_mux = &alc880_capture_source,
3275         },
3276         [ALC880_UNIWILL_DIG] = {
3277                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3278                 .init_verbs = { alc880_volume_init_verbs,
3279                                 alc880_pin_asus_init_verbs },
3280                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3281                 .dac_nids = alc880_asus_dac_nids,
3282                 .dig_out_nid = ALC880_DIGOUT_NID,
3283                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3284                 .channel_mode = alc880_asus_modes,
3285                 .need_dac_fix = 1,
3286                 .input_mux = &alc880_capture_source,
3287         },
3288         [ALC880_UNIWILL] = {
3289                 .mixers = { alc880_uniwill_mixer },
3290                 .init_verbs = { alc880_volume_init_verbs,
3291                                 alc880_uniwill_init_verbs },
3292                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3293                 .dac_nids = alc880_asus_dac_nids,
3294                 .dig_out_nid = ALC880_DIGOUT_NID,
3295                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3296                 .channel_mode = alc880_threestack_modes,
3297                 .need_dac_fix = 1,
3298                 .input_mux = &alc880_capture_source,
3299                 .unsol_event = alc880_uniwill_unsol_event,
3300                 .init_hook = alc880_uniwill_automute,
3301         },
3302         [ALC880_UNIWILL_P53] = {
3303                 .mixers = { alc880_uniwill_p53_mixer },
3304                 .init_verbs = { alc880_volume_init_verbs,
3305                                 alc880_uniwill_p53_init_verbs },
3306                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3307                 .dac_nids = alc880_asus_dac_nids,
3308                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3309                 .channel_mode = alc880_threestack_modes,
3310                 .input_mux = &alc880_capture_source,
3311                 .unsol_event = alc880_uniwill_p53_unsol_event,
3312                 .init_hook = alc880_uniwill_p53_hp_automute,
3313         },
3314         [ALC880_FUJITSU] = {
3315                 .mixers = { alc880_fujitsu_mixer,
3316                             alc880_pcbeep_mixer, },
3317                 .init_verbs = { alc880_volume_init_verbs,
3318                                 alc880_uniwill_p53_init_verbs,
3319                                 alc880_beep_init_verbs },
3320                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3321                 .dac_nids = alc880_dac_nids,
3322                 .dig_out_nid = ALC880_DIGOUT_NID,
3323                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3324                 .channel_mode = alc880_2_jack_modes,
3325                 .input_mux = &alc880_capture_source,
3326                 .unsol_event = alc880_uniwill_p53_unsol_event,
3327                 .init_hook = alc880_uniwill_p53_hp_automute,
3328         },
3329         [ALC880_CLEVO] = {
3330                 .mixers = { alc880_three_stack_mixer },
3331                 .init_verbs = { alc880_volume_init_verbs,
3332                                 alc880_pin_clevo_init_verbs },
3333                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3334                 .dac_nids = alc880_dac_nids,
3335                 .hp_nid = 0x03,
3336                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3337                 .channel_mode = alc880_threestack_modes,
3338                 .need_dac_fix = 1,
3339                 .input_mux = &alc880_capture_source,
3340         },
3341         [ALC880_LG] = {
3342                 .mixers = { alc880_lg_mixer },
3343                 .init_verbs = { alc880_volume_init_verbs,
3344                                 alc880_lg_init_verbs },
3345                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3346                 .dac_nids = alc880_lg_dac_nids,
3347                 .dig_out_nid = ALC880_DIGOUT_NID,
3348                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3349                 .channel_mode = alc880_lg_ch_modes,
3350                 .need_dac_fix = 1,
3351                 .input_mux = &alc880_lg_capture_source,
3352                 .unsol_event = alc880_lg_unsol_event,
3353                 .init_hook = alc880_lg_automute,
3354 #ifdef CONFIG_SND_HDA_POWER_SAVE
3355                 .loopbacks = alc880_lg_loopbacks,
3356 #endif
3357         },
3358         [ALC880_LG_LW] = {
3359                 .mixers = { alc880_lg_lw_mixer },
3360                 .init_verbs = { alc880_volume_init_verbs,
3361                                 alc880_lg_lw_init_verbs },
3362                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3363                 .dac_nids = alc880_dac_nids,
3364                 .dig_out_nid = ALC880_DIGOUT_NID,
3365                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3366                 .channel_mode = alc880_lg_lw_modes,
3367                 .input_mux = &alc880_lg_lw_capture_source,
3368                 .unsol_event = alc880_lg_lw_unsol_event,
3369                 .init_hook = alc880_lg_lw_automute,
3370         },
3371         [ALC880_MEDION_RIM] = {
3372                 .mixers = { alc880_medion_rim_mixer },
3373                 .init_verbs = { alc880_volume_init_verbs,
3374                                 alc880_medion_rim_init_verbs,
3375                                 alc_gpio2_init_verbs },
3376                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3377                 .dac_nids = alc880_dac_nids,
3378                 .dig_out_nid = ALC880_DIGOUT_NID,
3379                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3380                 .channel_mode = alc880_2_jack_modes,
3381                 .input_mux = &alc880_medion_rim_capture_source,
3382                 .unsol_event = alc880_medion_rim_unsol_event,
3383                 .init_hook = alc880_medion_rim_automute,
3384         },
3385 #ifdef CONFIG_SND_DEBUG
3386         [ALC880_TEST] = {
3387                 .mixers = { alc880_test_mixer },
3388                 .init_verbs = { alc880_test_init_verbs },
3389                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3390                 .dac_nids = alc880_test_dac_nids,
3391                 .dig_out_nid = ALC880_DIGOUT_NID,
3392                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3393                 .channel_mode = alc880_test_modes,
3394                 .input_mux = &alc880_test_capture_source,
3395         },
3396 #endif
3397 };
3398
3399 /*
3400  * Automatic parse of I/O pins from the BIOS configuration
3401  */
3402
3403 #define NUM_CONTROL_ALLOC       32
3404 #define NUM_VERB_ALLOC          32
3405
3406 enum {
3407         ALC_CTL_WIDGET_VOL,
3408         ALC_CTL_WIDGET_MUTE,
3409         ALC_CTL_BIND_MUTE,
3410 };
3411 static struct snd_kcontrol_new alc880_control_templates[] = {
3412         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3413         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3414         HDA_BIND_MUTE(NULL, 0, 0, 0),
3415 };
3416
3417 /* add dynamic controls */
3418 static int add_control(struct alc_spec *spec, int type, const char *name,
3419                        unsigned long val)
3420 {
3421         struct snd_kcontrol_new *knew;
3422
3423         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3424                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3425
3426                 /* array + terminator */
3427                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3428                 if (!knew)
3429                         return -ENOMEM;
3430                 if (spec->kctl_alloc) {
3431                         memcpy(knew, spec->kctl_alloc,
3432                                sizeof(*knew) * spec->num_kctl_alloc);
3433                         kfree(spec->kctl_alloc);
3434                 }
3435                 spec->kctl_alloc = knew;
3436                 spec->num_kctl_alloc = num;
3437         }
3438
3439         knew = &spec->kctl_alloc[spec->num_kctl_used];
3440         *knew = alc880_control_templates[type];
3441         knew->name = kstrdup(name, GFP_KERNEL);
3442         if (!knew->name)
3443                 return -ENOMEM;
3444         knew->private_value = val;
3445         spec->num_kctl_used++;
3446         return 0;
3447 }
3448
3449 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3450 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3451 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3452 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3453 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3454 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3455 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3456 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3457 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3458 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3459 #define ALC880_PIN_CD_NID               0x1c
3460
3461 /* fill in the dac_nids table from the parsed pin configuration */
3462 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3463                                      const struct auto_pin_cfg *cfg)
3464 {
3465         hda_nid_t nid;
3466         int assigned[4];
3467         int i, j;
3468
3469         memset(assigned, 0, sizeof(assigned));
3470         spec->multiout.dac_nids = spec->private_dac_nids;
3471
3472         /* check the pins hardwired to audio widget */
3473         for (i = 0; i < cfg->line_outs; i++) {
3474                 nid = cfg->line_out_pins[i];
3475                 if (alc880_is_fixed_pin(nid)) {
3476                         int idx = alc880_fixed_pin_idx(nid);
3477                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3478                         assigned[idx] = 1;
3479                 }
3480         }
3481         /* left pins can be connect to any audio widget */
3482         for (i = 0; i < cfg->line_outs; i++) {
3483                 nid = cfg->line_out_pins[i];
3484                 if (alc880_is_fixed_pin(nid))
3485                         continue;
3486                 /* search for an empty channel */
3487                 for (j = 0; j < cfg->line_outs; j++) {
3488                         if (!assigned[j]) {
3489                                 spec->multiout.dac_nids[i] =
3490                                         alc880_idx_to_dac(j);
3491                                 assigned[j] = 1;
3492                                 break;
3493                         }
3494                 }
3495         }
3496         spec->multiout.num_dacs = cfg->line_outs;
3497         return 0;
3498 }
3499
3500 /* add playback controls from the parsed DAC table */
3501 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3502                                              const struct auto_pin_cfg *cfg)
3503 {
3504         char name[32];
3505         static const char *chname[4] = {
3506                 "Front", "Surround", NULL /*CLFE*/, "Side"
3507         };
3508         hda_nid_t nid;
3509         int i, err;
3510
3511         for (i = 0; i < cfg->line_outs; i++) {
3512                 if (!spec->multiout.dac_nids[i])
3513                         continue;
3514                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3515                 if (i == 2) {
3516                         /* Center/LFE */
3517                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3518                                           "Center Playback Volume",
3519                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3520                                                               HDA_OUTPUT));
3521                         if (err < 0)
3522                                 return err;
3523                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3524                                           "LFE Playback Volume",
3525                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3526                                                               HDA_OUTPUT));
3527                         if (err < 0)
3528                                 return err;
3529                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3530                                           "Center Playback Switch",
3531                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3532                                                               HDA_INPUT));
3533                         if (err < 0)
3534                                 return err;
3535                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3536                                           "LFE Playback Switch",
3537                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3538                                                               HDA_INPUT));
3539                         if (err < 0)
3540                                 return err;
3541                 } else {
3542                         sprintf(name, "%s Playback Volume", chname[i]);
3543                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3544                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3545                                                               HDA_OUTPUT));
3546                         if (err < 0)
3547                                 return err;
3548                         sprintf(name, "%s Playback Switch", chname[i]);
3549                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3550                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3551                                                               HDA_INPUT));
3552                         if (err < 0)
3553                                 return err;
3554                 }
3555         }
3556         return 0;
3557 }
3558
3559 /* add playback controls for speaker and HP outputs */
3560 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3561                                         const char *pfx)
3562 {
3563         hda_nid_t nid;
3564         int err;
3565         char name[32];
3566
3567         if (!pin)
3568                 return 0;
3569
3570         if (alc880_is_fixed_pin(pin)) {
3571                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3572                 /* specify the DAC as the extra output */
3573                 if (!spec->multiout.hp_nid)
3574                         spec->multiout.hp_nid = nid;
3575                 else
3576                         spec->multiout.extra_out_nid[0] = nid;
3577                 /* control HP volume/switch on the output mixer amp */
3578                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3579                 sprintf(name, "%s Playback Volume", pfx);
3580                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3581                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3582                 if (err < 0)
3583                         return err;
3584                 sprintf(name, "%s Playback Switch", pfx);
3585                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3586                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3587                 if (err < 0)
3588                         return err;
3589         } else if (alc880_is_multi_pin(pin)) {
3590                 /* set manual connection */
3591                 /* we have only a switch on HP-out PIN */
3592                 sprintf(name, "%s Playback Switch", pfx);
3593                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3594                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3595                 if (err < 0)
3596                         return err;
3597         }
3598         return 0;
3599 }
3600
3601 /* create input playback/capture controls for the given pin */
3602 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3603                             const char *ctlname,
3604                             int idx, hda_nid_t mix_nid)
3605 {
3606         char name[32];
3607         int err;
3608
3609         sprintf(name, "%s Playback Volume", ctlname);
3610         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3611                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3612         if (err < 0)
3613                 return err;
3614         sprintf(name, "%s Playback Switch", ctlname);
3615         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3616                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3617         if (err < 0)
3618                 return err;
3619         return 0;
3620 }
3621
3622 /* create playback/capture controls for input pins */
3623 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3624                                                 const struct auto_pin_cfg *cfg)
3625 {
3626         struct hda_input_mux *imux = &spec->private_imux;
3627         int i, err, idx;
3628
3629         for (i = 0; i < AUTO_PIN_LAST; i++) {
3630                 if (alc880_is_input_pin(cfg->input_pins[i])) {
3631                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
3632                         err = new_analog_input(spec, cfg->input_pins[i],
3633                                                auto_pin_cfg_labels[i],
3634                                                idx, 0x0b);
3635                         if (err < 0)
3636                                 return err;
3637                         imux->items[imux->num_items].label =
3638                                 auto_pin_cfg_labels[i];
3639                         imux->items[imux->num_items].index =
3640                                 alc880_input_pin_idx(cfg->input_pins[i]);
3641                         imux->num_items++;
3642                 }
3643         }
3644         return 0;
3645 }
3646
3647 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3648                                unsigned int pin_type)
3649 {
3650         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3651                             pin_type);
3652         /* unmute pin */
3653         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3654                             AMP_OUT_UNMUTE);
3655 }
3656
3657 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3658                                               hda_nid_t nid, int pin_type,
3659                                               int dac_idx)
3660 {
3661         alc_set_pin_output(codec, nid, pin_type);
3662         /* need the manual connection? */
3663         if (alc880_is_multi_pin(nid)) {
3664                 struct alc_spec *spec = codec->spec;
3665                 int idx = alc880_multi_pin_idx(nid);
3666                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3667                                     AC_VERB_SET_CONNECT_SEL,
3668                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3669         }
3670 }
3671
3672 static int get_pin_type(int line_out_type)
3673 {
3674         if (line_out_type == AUTO_PIN_HP_OUT)
3675                 return PIN_HP;
3676         else
3677                 return PIN_OUT;
3678 }
3679
3680 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3681 {
3682         struct alc_spec *spec = codec->spec;
3683         int i;
3684
3685         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3686         for (i = 0; i < spec->autocfg.line_outs; i++) {
3687                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3688                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3689                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3690         }
3691 }
3692
3693 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3694 {
3695         struct alc_spec *spec = codec->spec;
3696         hda_nid_t pin;
3697
3698         pin = spec->autocfg.speaker_pins[0];
3699         if (pin) /* connect to front */
3700                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3701         pin = spec->autocfg.hp_pins[0];
3702         if (pin) /* connect to front */
3703                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3704 }
3705
3706 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3707 {
3708         struct alc_spec *spec = codec->spec;
3709         int i;
3710
3711         for (i = 0; i < AUTO_PIN_LAST; i++) {
3712                 hda_nid_t nid = spec->autocfg.input_pins[i];
3713                 if (alc880_is_input_pin(nid)) {
3714                         snd_hda_codec_write(codec, nid, 0,
3715                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
3716                                             i <= AUTO_PIN_FRONT_MIC ?
3717                                             PIN_VREF80 : PIN_IN);
3718                         if (nid != ALC880_PIN_CD_NID)
3719                                 snd_hda_codec_write(codec, nid, 0,
3720                                                     AC_VERB_SET_AMP_GAIN_MUTE,
3721                                                     AMP_OUT_MUTE);
3722                 }
3723         }
3724 }
3725
3726 /* parse the BIOS configuration and set up the alc_spec */
3727 /* return 1 if successful, 0 if the proper config is not found,
3728  * or a negative error code
3729  */
3730 static int alc880_parse_auto_config(struct hda_codec *codec)
3731 {
3732         struct alc_spec *spec = codec->spec;
3733         int err;
3734         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3735
3736         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3737                                            alc880_ignore);
3738         if (err < 0)
3739                 return err;
3740         if (!spec->autocfg.line_outs)
3741                 return 0; /* can't find valid BIOS pin config */
3742
3743         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3744         if (err < 0)
3745                 return err;
3746         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3747         if (err < 0)
3748                 return err;
3749         err = alc880_auto_create_extra_out(spec,
3750                                            spec->autocfg.speaker_pins[0],
3751                                            "Speaker");
3752         if (err < 0)
3753                 return err;
3754         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3755                                            "Headphone");
3756         if (err < 0)
3757                 return err;
3758         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3759         if (err < 0)
3760                 return err;
3761
3762         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3763
3764         if (spec->autocfg.dig_out_pin)
3765                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3766         if (spec->autocfg.dig_in_pin)
3767                 spec->dig_in_nid = ALC880_DIGIN_NID;
3768
3769         if (spec->kctl_alloc)
3770                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3771
3772         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3773
3774         spec->num_mux_defs = 1;
3775         spec->input_mux = &spec->private_imux;
3776
3777         return 1;
3778 }
3779
3780 /* additional initialization for auto-configuration model */
3781 static void alc880_auto_init(struct hda_codec *codec)
3782 {
3783         struct alc_spec *spec = codec->spec;
3784         alc880_auto_init_multi_out(codec);
3785         alc880_auto_init_extra_out(codec);
3786         alc880_auto_init_analog_input(codec);
3787         if (spec->unsol_event)
3788                 alc_sku_automute(codec);
3789 }
3790
3791 /*
3792  * OK, here we have finally the patch for ALC880
3793  */
3794
3795 static int patch_alc880(struct hda_codec *codec)
3796 {
3797         struct alc_spec *spec;
3798         int board_config;
3799         int err;
3800
3801         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3802         if (spec == NULL)
3803                 return -ENOMEM;
3804
3805         codec->spec = spec;
3806
3807         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3808                                                   alc880_models,
3809                                                   alc880_cfg_tbl);
3810         if (board_config < 0) {
3811                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3812                        "trying auto-probe from BIOS...\n");
3813                 board_config = ALC880_AUTO;
3814         }
3815
3816         if (board_config == ALC880_AUTO) {
3817                 /* automatic parse from the BIOS config */
3818                 err = alc880_parse_auto_config(codec);
3819                 if (err < 0) {
3820                         alc_free(codec);
3821                         return err;
3822                 } else if (!err) {
3823                         printk(KERN_INFO
3824                                "hda_codec: Cannot set up configuration "
3825                                "from BIOS.  Using 3-stack mode...\n");
3826                         board_config = ALC880_3ST;
3827                 }
3828         }
3829
3830         if (board_config != ALC880_AUTO)
3831                 setup_preset(spec, &alc880_presets[board_config]);
3832
3833         spec->stream_name_analog = "ALC880 Analog";
3834         spec->stream_analog_playback = &alc880_pcm_analog_playback;
3835         spec->stream_analog_capture = &alc880_pcm_analog_capture;
3836         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3837
3838         spec->stream_name_digital = "ALC880 Digital";
3839         spec->stream_digital_playback = &alc880_pcm_digital_playback;
3840         spec->stream_digital_capture = &alc880_pcm_digital_capture;
3841
3842         if (!spec->adc_nids && spec->input_mux) {
3843                 /* check whether NID 0x07 is valid */
3844                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3845                 /* get type */
3846                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3847                 if (wcap != AC_WID_AUD_IN) {
3848                         spec->adc_nids = alc880_adc_nids_alt;
3849                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3850                         spec->mixers[spec->num_mixers] =
3851                                 alc880_capture_alt_mixer;
3852                         spec->num_mixers++;
3853                 } else {
3854                         spec->adc_nids = alc880_adc_nids;
3855                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3856                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3857                         spec->num_mixers++;
3858                 }
3859         }
3860
3861         spec->vmaster_nid = 0x0c;
3862
3863         codec->patch_ops = alc_patch_ops;
3864         if (board_config == ALC880_AUTO)
3865                 spec->init_hook = alc880_auto_init;
3866 #ifdef CONFIG_SND_HDA_POWER_SAVE
3867         if (!spec->loopback.amplist)
3868                 spec->loopback.amplist = alc880_loopbacks;
3869 #endif
3870
3871         return 0;
3872 }
3873
3874
3875 /*
3876  * ALC260 support
3877  */
3878
3879 static hda_nid_t alc260_dac_nids[1] = {
3880         /* front */
3881         0x02,
3882 };
3883
3884 static hda_nid_t alc260_adc_nids[1] = {
3885         /* ADC0 */
3886         0x04,
3887 };
3888
3889 static hda_nid_t alc260_adc_nids_alt[1] = {
3890         /* ADC1 */
3891         0x05,
3892 };
3893
3894 static hda_nid_t alc260_hp_adc_nids[2] = {
3895         /* ADC1, 0 */
3896         0x05, 0x04
3897 };
3898
3899 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
3900  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
3901  */
3902 static hda_nid_t alc260_dual_adc_nids[2] = {
3903         /* ADC0, ADC1 */
3904         0x04, 0x05
3905 };
3906
3907 #define ALC260_DIGOUT_NID       0x03
3908 #define ALC260_DIGIN_NID        0x06
3909
3910 static struct hda_input_mux alc260_capture_source = {
3911         .num_items = 4,
3912         .items = {
3913                 { "Mic", 0x0 },
3914                 { "Front Mic", 0x1 },
3915                 { "Line", 0x2 },
3916                 { "CD", 0x4 },
3917         },
3918 };
3919
3920 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
3921  * headphone jack and the internal CD lines since these are the only pins at
3922  * which audio can appear.  For flexibility, also allow the option of
3923  * recording the mixer output on the second ADC (ADC0 doesn't have a
3924  * connection to the mixer output).
3925  */
3926 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
3927         {
3928                 .num_items = 3,
3929                 .items = {
3930                         { "Mic/Line", 0x0 },
3931                         { "CD", 0x4 },
3932                         { "Headphone", 0x2 },
3933                 },
3934         },
3935         {
3936                 .num_items = 4,
3937                 .items = {
3938                         { "Mic/Line", 0x0 },
3939                         { "CD", 0x4 },
3940                         { "Headphone", 0x2 },
3941                         { "Mixer", 0x5 },
3942                 },
3943         },
3944
3945 };
3946
3947 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
3948  * the Fujitsu S702x, but jacks are marked differently.
3949  */
3950 static struct hda_input_mux alc260_acer_capture_sources[2] = {
3951         {
3952                 .num_items = 4,
3953                 .items = {
3954                         { "Mic", 0x0 },
3955                         { "Line", 0x2 },
3956                         { "CD", 0x4 },
3957                         { "Headphone", 0x5 },
3958                 },
3959         },
3960         {
3961                 .num_items = 5,
3962                 .items = {
3963                         { "Mic", 0x0 },
3964                         { "Line", 0x2 },
3965                         { "CD", 0x4 },
3966                         { "Headphone", 0x6 },
3967                         { "Mixer", 0x5 },
3968                 },
3969         },
3970 };
3971 /*
3972  * This is just place-holder, so there's something for alc_build_pcms to look
3973  * at when it calculates the maximum number of channels. ALC260 has no mixer
3974  * element which allows changing the channel mode, so the verb list is
3975  * never used.
3976  */
3977 static struct hda_channel_mode alc260_modes[1] = {
3978         { 2, NULL },
3979 };
3980
3981
3982 /* Mixer combinations
3983  *
3984  * basic: base_output + input + pc_beep + capture
3985  * HP: base_output + input + capture_alt
3986  * HP_3013: hp_3013 + input + capture
3987  * fujitsu: fujitsu + capture
3988  * acer: acer + capture
3989  */
3990
3991 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
3992         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3993         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
3994         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3995         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
3996         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3997         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3998         { } /* end */
3999 };
4000
4001 static struct snd_kcontrol_new alc260_input_mixer[] = {
4002         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4003         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4004         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4005         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4006         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4007         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4008         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4009         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4010         { } /* end */
4011 };
4012
4013 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4014         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4015         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4016         { } /* end */
4017 };
4018
4019 /* update HP, line and mono out pins according to the master switch */
4020 static void alc260_hp_master_update(struct hda_codec *codec,
4021                                     hda_nid_t hp, hda_nid_t line,
4022                                     hda_nid_t mono)
4023 {
4024         struct alc_spec *spec = codec->spec;
4025         unsigned int val = spec->master_sw ? PIN_HP : 0;
4026         /* change HP and line-out pins */
4027         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4028                             val);
4029         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4030                             val);
4031         /* mono (speaker) depending on the HP jack sense */
4032         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4033         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4034                             val);
4035 }
4036
4037 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4038                                    struct snd_ctl_elem_value *ucontrol)
4039 {
4040         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4041         struct alc_spec *spec = codec->spec;
4042         *ucontrol->value.integer.value = spec->master_sw;
4043         return 0;
4044 }
4045
4046 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4047                                    struct snd_ctl_elem_value *ucontrol)
4048 {
4049         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4050         struct alc_spec *spec = codec->spec;
4051         int val = !!*ucontrol->value.integer.value;
4052         hda_nid_t hp, line, mono;
4053
4054         if (val == spec->master_sw)
4055                 return 0;
4056         spec->master_sw = val;
4057         hp = (kcontrol->private_value >> 16) & 0xff;
4058         line = (kcontrol->private_value >> 8) & 0xff;
4059         mono = kcontrol->private_value & 0xff;
4060         alc260_hp_master_update(codec, hp, line, mono);
4061         return 1;
4062 }
4063
4064 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4065         {
4066                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4067                 .name = "Master Playback Switch",
4068                 .info = snd_ctl_boolean_mono_info,
4069                 .get = alc260_hp_master_sw_get,
4070                 .put = alc260_hp_master_sw_put,
4071                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4072         },
4073         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4074         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4075         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4076         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4077         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4078                               HDA_OUTPUT),
4079         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4080         { } /* end */
4081 };
4082
4083 static struct hda_verb alc260_hp_unsol_verbs[] = {
4084         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4085         {},
4086 };
4087
4088 static void alc260_hp_automute(struct hda_codec *codec)
4089 {
4090         struct alc_spec *spec = codec->spec;
4091         unsigned int present;
4092
4093         present = snd_hda_codec_read(codec, 0x10, 0,
4094                                      AC_VERB_GET_PIN_SENSE, 0);
4095         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4096         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4097 }
4098
4099 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4100 {
4101         if ((res >> 26) == ALC880_HP_EVENT)
4102                 alc260_hp_automute(codec);
4103 }
4104
4105 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4106         {
4107                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4108                 .name = "Master Playback Switch",
4109                 .info = snd_ctl_boolean_mono_info,
4110                 .get = alc260_hp_master_sw_get,
4111                 .put = alc260_hp_master_sw_put,
4112                 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
4113         },
4114         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4115         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4116         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4117         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4118         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4119         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4120         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4121         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4122         { } /* end */
4123 };
4124
4125 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4126         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4127         {},
4128 };
4129
4130 static void alc260_hp_3013_automute(struct hda_codec *codec)
4131 {
4132         struct alc_spec *spec = codec->spec;
4133         unsigned int present;
4134
4135         present = snd_hda_codec_read(codec, 0x15, 0,
4136                                      AC_VERB_GET_PIN_SENSE, 0);
4137         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4138         alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
4139 }
4140
4141 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4142                                        unsigned int res)
4143 {
4144         if ((res >> 26) == ALC880_HP_EVENT)
4145                 alc260_hp_3013_automute(codec);
4146 }
4147
4148 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4149  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4150  */
4151 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4152         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4153         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4154         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4155         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4156         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4157         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4158         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4159         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4160         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4161         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4162         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4163         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4164         { } /* end */
4165 };
4166
4167 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4168  * versions of the ALC260 don't act on requests to enable mic bias from NID
4169  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4170  * datasheet doesn't mention this restriction.  At this stage it's not clear
4171  * whether this behaviour is intentional or is a hardware bug in chip
4172  * revisions available in early 2006.  Therefore for now allow the
4173  * "Headphone Jack Mode" control to span all choices, but if it turns out
4174  * that the lack of mic bias for this NID is intentional we could change the
4175  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4176  *
4177  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4178  * don't appear to make the mic bias available from the "line" jack, even
4179  * though the NID used for this jack (0x14) can supply it.  The theory is
4180  * that perhaps Acer have included blocking capacitors between the ALC260
4181  * and the output jack.  If this turns out to be the case for all such
4182  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4183  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4184  *
4185  * The C20x Tablet series have a mono internal speaker which is controlled
4186  * via the chip's Mono sum widget and pin complex, so include the necessary
4187  * controls for such models.  On models without a "mono speaker" the control
4188  * won't do anything.
4189  */
4190 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4191         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4192         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4193         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4194         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4195                               HDA_OUTPUT),
4196         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4197                            HDA_INPUT),
4198         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4199         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4200         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4201         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4202         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4203         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4204         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4205         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4206         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4207         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4208         { } /* end */
4209 };
4210
4211 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4212  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4213  */
4214 static struct snd_kcontrol_new alc260_will_mixer[] = {
4215         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4216         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4217         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4218         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4219         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4220         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4221         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4222         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4223         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4224         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4225         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4226         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4227         { } /* end */
4228 };
4229
4230 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4231  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4232  */
4233 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4234         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4235         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4236         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4237         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4238         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4239         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4240         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4241         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4242         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4243         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4244         { } /* end */
4245 };
4246
4247 /* capture mixer elements */
4248 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4249         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4250         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4251         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4252         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4253         {
4254                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4255                 /* The multiple "Capture Source" controls confuse alsamixer
4256                  * So call somewhat different..
4257                  */
4258                 /* .name = "Capture Source", */
4259                 .name = "Input Source",
4260                 .count = 2,
4261                 .info = alc_mux_enum_info,
4262                 .get = alc_mux_enum_get,
4263                 .put = alc_mux_enum_put,
4264         },
4265         { } /* end */
4266 };
4267
4268 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4269         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4270         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4271         {
4272                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4273                 /* The multiple "Capture Source" controls confuse alsamixer
4274                  * So call somewhat different..
4275                  */
4276                 /* .name = "Capture Source", */
4277                 .name = "Input Source",
4278                 .count = 1,
4279                 .info = alc_mux_enum_info,
4280                 .get = alc_mux_enum_get,
4281                 .put = alc_mux_enum_put,
4282         },
4283         { } /* end */
4284 };
4285
4286 /*
4287  * initialization verbs
4288  */
4289 static struct hda_verb alc260_init_verbs[] = {
4290         /* Line In pin widget for input */
4291         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4292         /* CD pin widget for input */
4293         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4294         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4295         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4296         /* Mic2 (front panel) pin widget for input and vref at 80% */
4297         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4298         /* LINE-2 is used for line-out in rear */
4299         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4300         /* select line-out */
4301         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4302         /* LINE-OUT pin */
4303         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4304         /* enable HP */
4305         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4306         /* enable Mono */
4307         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4308         /* mute capture amp left and right */
4309         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4310         /* set connection select to line in (default select for this ADC) */
4311         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4312         /* mute capture amp left and right */
4313         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4314         /* set connection select to line in (default select for this ADC) */
4315         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4316         /* set vol=0 Line-Out mixer amp left and right */
4317         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4318         /* unmute pin widget amp left and right (no gain on this amp) */
4319         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4320         /* set vol=0 HP mixer amp left and right */
4321         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4322         /* unmute pin widget amp left and right (no gain on this amp) */
4323         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4324         /* set vol=0 Mono mixer amp left and right */
4325         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4326         /* unmute pin widget amp left and right (no gain on this amp) */
4327         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4328         /* unmute LINE-2 out pin */
4329         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4330         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4331          * Line In 2 = 0x03
4332          */
4333         /* mute analog inputs */
4334         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4335         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4336         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4337         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4338         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4339         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4340         /* mute Front out path */
4341         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4342         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4343         /* mute Headphone out path */
4344         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4345         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4346         /* mute Mono out path */
4347         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4348         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4349         { }
4350 };
4351
4352 #if 0 /* should be identical with alc260_init_verbs? */
4353 static struct hda_verb alc260_hp_init_verbs[] = {
4354         /* Headphone and output */
4355         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4356         /* mono output */
4357         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4358         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4359         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4360         /* Mic2 (front panel) pin widget for input and vref at 80% */
4361         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4362         /* Line In pin widget for input */
4363         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4364         /* Line-2 pin widget for output */
4365         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4366         /* CD pin widget for input */
4367         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4368         /* unmute amp left and right */
4369         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4370         /* set connection select to line in (default select for this ADC) */
4371         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4372         /* unmute Line-Out mixer amp left and right (volume = 0) */
4373         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4374         /* mute pin widget amp left and right (no gain on this amp) */
4375         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4376         /* unmute HP mixer amp left and right (volume = 0) */
4377         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4378         /* mute pin widget amp left and right (no gain on this amp) */
4379         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4380         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4381          * Line In 2 = 0x03
4382          */
4383         /* mute analog inputs */
4384         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4385         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4386         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4387         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4388         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4389         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4390         /* Unmute Front out path */
4391         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4392         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4393         /* Unmute Headphone out path */
4394         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4395         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4396         /* Unmute Mono out path */
4397         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4398         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4399         { }
4400 };
4401 #endif
4402
4403 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4404         /* Line out and output */
4405         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4406         /* mono output */
4407         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4408         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4409         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4410         /* Mic2 (front panel) pin widget for input and vref at 80% */
4411         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4412         /* Line In pin widget for input */
4413         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4414         /* Headphone pin widget for output */
4415         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4416         /* CD pin widget for input */
4417         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4418         /* unmute amp left and right */
4419         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4420         /* set connection select to line in (default select for this ADC) */
4421         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4422         /* unmute Line-Out mixer amp left and right (volume = 0) */
4423         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4424         /* mute pin widget amp left and right (no gain on this amp) */
4425         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4426         /* unmute HP mixer amp left and right (volume = 0) */
4427         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4428         /* mute pin widget amp left and right (no gain on this amp) */
4429         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4430         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4431          * Line In 2 = 0x03
4432          */
4433         /* mute analog inputs */
4434         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4435         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4436         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4437         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4438         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4439         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4440         /* Unmute Front out path */
4441         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4442         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4443         /* Unmute Headphone out path */
4444         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4445         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4446         /* Unmute Mono out path */
4447         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4448         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4449         { }
4450 };
4451
4452 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4453  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4454  * audio = 0x16, internal speaker = 0x10.
4455  */
4456 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4457         /* Disable all GPIOs */
4458         {0x01, AC_VERB_SET_GPIO_MASK, 0},
4459         /* Internal speaker is connected to headphone pin */
4460         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4461         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4462         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4463         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4464         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4465         /* Ensure all other unused pins are disabled and muted. */
4466         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4467         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4468         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4469         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4470         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4471         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4472         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4473         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4474
4475         /* Disable digital (SPDIF) pins */
4476         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4477         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4478
4479         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4480          * when acting as an output.
4481          */
4482         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4483
4484         /* Start with output sum widgets muted and their output gains at min */
4485         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4486         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4487         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4488         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4489         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4490         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4491         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4492         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4493         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4494
4495         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4496         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4497         /* Unmute Line1 pin widget output buffer since it starts as an output.
4498          * If the pin mode is changed by the user the pin mode control will
4499          * take care of enabling the pin's input/output buffers as needed.
4500          * Therefore there's no need to enable the input buffer at this
4501          * stage.
4502          */
4503         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4504         /* Unmute input buffer of pin widget used for Line-in (no equiv
4505          * mixer ctrl)
4506          */
4507         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4508
4509         /* Mute capture amp left and right */
4510         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4511         /* Set ADC connection select to match default mixer setting - line
4512          * in (on mic1 pin)
4513          */
4514         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4515
4516         /* Do the same for the second ADC: mute capture input amp and
4517          * set ADC connection to line in (on mic1 pin)
4518          */
4519         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4520         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4521
4522         /* Mute all inputs to mixer widget (even unconnected ones) */
4523         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4524         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4525         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4526         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4527         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4528         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4529         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4530         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4531
4532         { }
4533 };
4534
4535 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4536  * similar laptops (adapted from Fujitsu init verbs).
4537  */
4538 static struct hda_verb alc260_acer_init_verbs[] = {
4539         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4540          * the headphone jack.  Turn this on and rely on the standard mute
4541          * methods whenever the user wants to turn these outputs off.
4542          */
4543         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4544         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4545         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4546         /* Internal speaker/Headphone jack is connected to Line-out pin */
4547         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4548         /* Internal microphone/Mic jack is connected to Mic1 pin */
4549         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4550         /* Line In jack is connected to Line1 pin */
4551         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4552         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4553         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4554         /* Ensure all other unused pins are disabled and muted. */
4555         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4556         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4557         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4558         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4559         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4560         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4561         /* Disable digital (SPDIF) pins */
4562         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4563         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4564
4565         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4566          * bus when acting as outputs.
4567          */
4568         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4569         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4570
4571         /* Start with output sum widgets muted and their output gains at min */
4572         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4573         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4574         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4575         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4576         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4577         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4578         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4579         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4580         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4581
4582         /* Unmute Line-out pin widget amp left and right
4583          * (no equiv mixer ctrl)
4584          */
4585         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4586         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4587         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4588         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4589          * inputs. If the pin mode is changed by the user the pin mode control
4590          * will take care of enabling the pin's input/output buffers as needed.
4591          * Therefore there's no need to enable the input buffer at this
4592          * stage.
4593          */
4594         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4595         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4596
4597         /* Mute capture amp left and right */
4598         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4599         /* Set ADC connection select to match default mixer setting - mic
4600          * (on mic1 pin)
4601          */
4602         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4603
4604         /* Do similar with the second ADC: mute capture input amp and
4605          * set ADC connection to mic to match ALSA's default state.
4606          */
4607         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4608         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4609
4610         /* Mute all inputs to mixer widget (even unconnected ones) */
4611         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4612         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4613         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4614         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4615         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4616         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4617         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4618         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4619
4620         { }
4621 };
4622
4623 static struct hda_verb alc260_will_verbs[] = {
4624         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4625         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4626         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4627         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4628         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4629         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4630         {}
4631 };
4632
4633 static struct hda_verb alc260_replacer_672v_verbs[] = {
4634         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4635         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4636         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4637
4638         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4639         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4640         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4641
4642         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4643         {}
4644 };
4645
4646 /* toggle speaker-output according to the hp-jack state */
4647 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4648 {
4649         unsigned int present;
4650
4651         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4652         present = snd_hda_codec_read(codec, 0x0f, 0,
4653                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4654         if (present) {
4655                 snd_hda_codec_write_cache(codec, 0x01, 0,
4656                                           AC_VERB_SET_GPIO_DATA, 1);
4657                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4658                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4659                                           PIN_HP);
4660         } else {
4661                 snd_hda_codec_write_cache(codec, 0x01, 0,
4662                                           AC_VERB_SET_GPIO_DATA, 0);
4663                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4664                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4665                                           PIN_OUT);
4666         }
4667 }
4668
4669 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4670                                        unsigned int res)
4671 {
4672         if ((res >> 26) == ALC880_HP_EVENT)
4673                 alc260_replacer_672v_automute(codec);
4674 }
4675
4676 /* Test configuration for debugging, modelled after the ALC880 test
4677  * configuration.
4678  */
4679 #ifdef CONFIG_SND_DEBUG
4680 static hda_nid_t alc260_test_dac_nids[1] = {
4681         0x02,
4682 };
4683 static hda_nid_t alc260_test_adc_nids[2] = {
4684         0x04, 0x05,
4685 };
4686 /* For testing the ALC260, each input MUX needs its own definition since
4687  * the signal assignments are different.  This assumes that the first ADC
4688  * is NID 0x04.
4689  */
4690 static struct hda_input_mux alc260_test_capture_sources[2] = {
4691         {
4692                 .num_items = 7,
4693                 .items = {
4694                         { "MIC1 pin", 0x0 },
4695                         { "MIC2 pin", 0x1 },
4696                         { "LINE1 pin", 0x2 },
4697                         { "LINE2 pin", 0x3 },
4698                         { "CD pin", 0x4 },
4699                         { "LINE-OUT pin", 0x5 },
4700                         { "HP-OUT pin", 0x6 },
4701                 },
4702         },
4703         {
4704                 .num_items = 8,
4705                 .items = {
4706                         { "MIC1 pin", 0x0 },
4707                         { "MIC2 pin", 0x1 },
4708                         { "LINE1 pin", 0x2 },
4709                         { "LINE2 pin", 0x3 },
4710                         { "CD pin", 0x4 },
4711                         { "Mixer", 0x5 },
4712                         { "LINE-OUT pin", 0x6 },
4713                         { "HP-OUT pin", 0x7 },
4714                 },
4715         },
4716 };
4717 static struct snd_kcontrol_new alc260_test_mixer[] = {
4718         /* Output driver widgets */
4719         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4720         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4721         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4722         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4723         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4724         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4725
4726         /* Modes for retasking pin widgets
4727          * Note: the ALC260 doesn't seem to act on requests to enable mic
4728          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
4729          * mention this restriction.  At this stage it's not clear whether
4730          * this behaviour is intentional or is a hardware bug in chip
4731          * revisions available at least up until early 2006.  Therefore for
4732          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4733          * choices, but if it turns out that the lack of mic bias for these
4734          * NIDs is intentional we could change their modes from
4735          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4736          */
4737         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4738         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4739         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4740         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4741         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4742         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4743
4744         /* Loopback mixer controls */
4745         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4746         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4747         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4748         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4749         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4750         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4751         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4752         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4753         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4754         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4755         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4756         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4757         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4758         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4759         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4760         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4761
4762         /* Controls for GPIO pins, assuming they are configured as outputs */
4763         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4764         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4765         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4766         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4767
4768         /* Switches to allow the digital IO pins to be enabled.  The datasheet
4769          * is ambigious as to which NID is which; testing on laptops which
4770          * make this output available should provide clarification.
4771          */
4772         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4773         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4774
4775         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
4776          * this output to turn on an external amplifier.
4777          */
4778         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4779         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4780
4781         { } /* end */
4782 };
4783 static struct hda_verb alc260_test_init_verbs[] = {
4784         /* Enable all GPIOs as outputs with an initial value of 0 */
4785         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4786         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4787         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4788
4789         /* Enable retasking pins as output, initially without power amp */
4790         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4791         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4792         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4793         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4794         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4795         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4796
4797         /* Disable digital (SPDIF) pins initially, but users can enable
4798          * them via a mixer switch.  In the case of SPDIF-out, this initverb
4799          * payload also sets the generation to 0, output to be in "consumer"
4800          * PCM format, copyright asserted, no pre-emphasis and no validity
4801          * control.
4802          */
4803         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4804         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4805
4806         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4807          * OUT1 sum bus when acting as an output.
4808          */
4809         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4810         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
4811         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4812         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
4813
4814         /* Start with output sum widgets muted and their output gains at min */
4815         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4816         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4817         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4818         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4819         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4820         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4821         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4822         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4823         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4824
4825         /* Unmute retasking pin widget output buffers since the default
4826          * state appears to be output.  As the pin mode is changed by the
4827          * user the pin mode control will take care of enabling the pin's
4828          * input/output buffers as needed.
4829          */
4830         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4831         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4832         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4833         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4834         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4835         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4836         /* Also unmute the mono-out pin widget */
4837         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4838
4839         /* Mute capture amp left and right */
4840         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4841         /* Set ADC connection select to match default mixer setting (mic1
4842          * pin)
4843          */
4844         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4845
4846         /* Do the same for the second ADC: mute capture input amp and
4847          * set ADC connection to mic1 pin
4848          */
4849         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4850         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4851
4852         /* Mute all inputs to mixer widget (even unconnected ones) */
4853         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4854         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4855         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4856         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4857         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4858         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4859         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4860         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4861
4862         { }
4863 };
4864 #endif
4865
4866 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
4867 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
4868
4869 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
4870 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
4871
4872 /*
4873  * for BIOS auto-configuration
4874  */
4875
4876 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
4877                                         const char *pfx)
4878 {
4879         hda_nid_t nid_vol;
4880         unsigned long vol_val, sw_val;
4881         char name[32];
4882         int err;
4883
4884         if (nid >= 0x0f && nid < 0x11) {
4885                 nid_vol = nid - 0x7;
4886                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4887                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4888         } else if (nid == 0x11) {
4889                 nid_vol = nid - 0x7;
4890                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
4891                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
4892         } else if (nid >= 0x12 && nid <= 0x15) {
4893                 nid_vol = 0x08;
4894                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4895                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4896         } else
4897                 return 0; /* N/A */
4898
4899         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
4900         err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
4901         if (err < 0)
4902                 return err;
4903         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
4904         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
4905         if (err < 0)
4906                 return err;
4907         return 1;
4908 }
4909
4910 /* add playback controls from the parsed DAC table */
4911 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
4912                                              const struct auto_pin_cfg *cfg)
4913 {
4914         hda_nid_t nid;
4915         int err;
4916
4917         spec->multiout.num_dacs = 1;
4918         spec->multiout.dac_nids = spec->private_dac_nids;
4919         spec->multiout.dac_nids[0] = 0x02;
4920
4921         nid = cfg->line_out_pins[0];
4922         if (nid) {
4923                 err = alc260_add_playback_controls(spec, nid, "Front");
4924                 if (err < 0)
4925                         return err;
4926         }
4927
4928         nid = cfg->speaker_pins[0];
4929         if (nid) {
4930                 err = alc260_add_playback_controls(spec, nid, "Speaker");
4931                 if (err < 0)
4932                         return err;
4933         }
4934
4935         nid = cfg->hp_pins[0];
4936         if (nid) {
4937                 err = alc260_add_playback_controls(spec, nid, "Headphone");
4938                 if (err < 0)
4939                         return err;
4940         }
4941         return 0;
4942 }
4943
4944 /* create playback/capture controls for input pins */
4945 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
4946                                                 const struct auto_pin_cfg *cfg)
4947 {
4948         struct hda_input_mux *imux = &spec->private_imux;
4949         int i, err, idx;
4950
4951         for (i = 0; i < AUTO_PIN_LAST; i++) {
4952                 if (cfg->input_pins[i] >= 0x12) {
4953                         idx = cfg->input_pins[i] - 0x12;
4954                         err = new_analog_input(spec, cfg->input_pins[i],
4955                                                auto_pin_cfg_labels[i], idx,
4956                                                0x07);
4957                         if (err < 0)
4958                                 return err;
4959                         imux->items[imux->num_items].label =
4960                                 auto_pin_cfg_labels[i];
4961                         imux->items[imux->num_items].index = idx;
4962                         imux->num_items++;
4963                 }
4964                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
4965                         idx = cfg->input_pins[i] - 0x09;
4966                         err = new_analog_input(spec, cfg->input_pins[i],
4967                                                auto_pin_cfg_labels[i], idx,
4968                                                0x07);
4969                         if (err < 0)
4970                                 return err;
4971                         imux->items[imux->num_items].label =
4972                                 auto_pin_cfg_labels[i];
4973                         imux->items[imux->num_items].index = idx;
4974                         imux->num_items++;
4975                 }
4976         }
4977         return 0;
4978 }
4979
4980 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
4981                                               hda_nid_t nid, int pin_type,
4982                                               int sel_idx)
4983 {
4984         alc_set_pin_output(codec, nid, pin_type);
4985         /* need the manual connection? */
4986         if (nid >= 0x12) {
4987                 int idx = nid - 0x12;
4988                 snd_hda_codec_write(codec, idx + 0x0b, 0,
4989                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
4990         }
4991 }
4992
4993 static void alc260_auto_init_multi_out(struct hda_codec *codec)
4994 {
4995         struct alc_spec *spec = codec->spec;
4996         hda_nid_t nid;
4997
4998         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
4999         nid = spec->autocfg.line_out_pins[0];
5000         if (nid) {
5001                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5002                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5003         }
5004
5005         nid = spec->autocfg.speaker_pins[0];
5006         if (nid)
5007                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5008
5009         nid = spec->autocfg.hp_pins[0];
5010         if (nid)
5011                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5012 }
5013
5014 #define ALC260_PIN_CD_NID               0x16
5015 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5016 {
5017         struct alc_spec *spec = codec->spec;
5018         int i;
5019
5020         for (i = 0; i < AUTO_PIN_LAST; i++) {
5021                 hda_nid_t nid = spec->autocfg.input_pins[i];
5022                 if (nid >= 0x12) {
5023                         snd_hda_codec_write(codec, nid, 0,
5024                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
5025                                             i <= AUTO_PIN_FRONT_MIC ?
5026                                             PIN_VREF80 : PIN_IN);
5027                         if (nid != ALC260_PIN_CD_NID)
5028                                 snd_hda_codec_write(codec, nid, 0,
5029                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5030                                                     AMP_OUT_MUTE);
5031                 }
5032         }
5033 }
5034
5035 /*
5036  * generic initialization of ADC, input mixers and output mixers
5037  */
5038 static struct hda_verb alc260_volume_init_verbs[] = {
5039         /*
5040          * Unmute ADC0-1 and set the default input to mic-in
5041          */
5042         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5043         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5044         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5045         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5046
5047         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5048          * mixer widget
5049          * Note: PASD motherboards uses the Line In 2 as the input for
5050          * front panel mic (mic 2)
5051          */
5052         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5053         /* mute analog inputs */
5054         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5055         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5056         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5057         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5058         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5059
5060         /*
5061          * Set up output mixers (0x08 - 0x0a)
5062          */
5063         /* set vol=0 to output mixers */
5064         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5065         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5066         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5067         /* set up input amps for analog loopback */
5068         /* Amp Indices: DAC = 0, mixer = 1 */
5069         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5070         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5071         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5072         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5073         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5074         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5075
5076         { }
5077 };
5078
5079 static int alc260_parse_auto_config(struct hda_codec *codec)
5080 {
5081         struct alc_spec *spec = codec->spec;
5082         unsigned int wcap;
5083         int err;
5084         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5085
5086         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5087                                            alc260_ignore);
5088         if (err < 0)
5089                 return err;
5090         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5091         if (err < 0)
5092                 return err;
5093         if (!spec->kctl_alloc)
5094                 return 0; /* can't find valid BIOS pin config */
5095         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5096         if (err < 0)
5097                 return err;
5098
5099         spec->multiout.max_channels = 2;
5100
5101         if (spec->autocfg.dig_out_pin)
5102                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5103         if (spec->kctl_alloc)
5104                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5105
5106         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
5107
5108         spec->num_mux_defs = 1;
5109         spec->input_mux = &spec->private_imux;
5110
5111         /* check whether NID 0x04 is valid */
5112         wcap = get_wcaps(codec, 0x04);
5113         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5114         if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5115                 spec->adc_nids = alc260_adc_nids_alt;
5116                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5117                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
5118         } else {
5119                 spec->adc_nids = alc260_adc_nids;
5120                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5121                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
5122         }
5123         spec->num_mixers++;
5124
5125         return 1;
5126 }
5127
5128 /* additional initialization for auto-configuration model */
5129 static void alc260_auto_init(struct hda_codec *codec)
5130 {
5131         struct alc_spec *spec = codec->spec;
5132         alc260_auto_init_multi_out(codec);
5133         alc260_auto_init_analog_input(codec);
5134         if (spec->unsol_event)
5135                 alc_sku_automute(codec);
5136 }
5137
5138 #ifdef CONFIG_SND_HDA_POWER_SAVE
5139 static struct hda_amp_list alc260_loopbacks[] = {
5140         { 0x07, HDA_INPUT, 0 },
5141         { 0x07, HDA_INPUT, 1 },
5142         { 0x07, HDA_INPUT, 2 },
5143         { 0x07, HDA_INPUT, 3 },
5144         { 0x07, HDA_INPUT, 4 },
5145         { } /* end */
5146 };
5147 #endif
5148
5149 /*
5150  * ALC260 configurations
5151  */
5152 static const char *alc260_models[ALC260_MODEL_LAST] = {
5153         [ALC260_BASIC]          = "basic",
5154         [ALC260_HP]             = "hp",
5155         [ALC260_HP_3013]        = "hp-3013",
5156         [ALC260_FUJITSU_S702X]  = "fujitsu",
5157         [ALC260_ACER]           = "acer",
5158         [ALC260_WILL]           = "will",
5159         [ALC260_REPLACER_672V]  = "replacer",
5160 #ifdef CONFIG_SND_DEBUG
5161         [ALC260_TEST]           = "test",
5162 #endif
5163         [ALC260_AUTO]           = "auto",
5164 };
5165
5166 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5167         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5168         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5169         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5170         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5171         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5172         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5173         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_3013),
5174         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5175         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5176         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5177         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5178         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5179         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5180         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5181         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5182         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5183         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5184         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5185         {}
5186 };
5187
5188 static struct alc_config_preset alc260_presets[] = {
5189         [ALC260_BASIC] = {
5190                 .mixers = { alc260_base_output_mixer,
5191                             alc260_input_mixer,
5192                             alc260_pc_beep_mixer,
5193                             alc260_capture_mixer },
5194                 .init_verbs = { alc260_init_verbs },
5195                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5196                 .dac_nids = alc260_dac_nids,
5197                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5198                 .adc_nids = alc260_adc_nids,
5199                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5200                 .channel_mode = alc260_modes,
5201                 .input_mux = &alc260_capture_source,
5202         },
5203         [ALC260_HP] = {
5204                 .mixers = { alc260_hp_output_mixer,
5205                             alc260_input_mixer,
5206                             alc260_capture_alt_mixer },
5207                 .init_verbs = { alc260_init_verbs,
5208                                 alc260_hp_unsol_verbs },
5209                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5210                 .dac_nids = alc260_dac_nids,
5211                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5212                 .adc_nids = alc260_hp_adc_nids,
5213                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5214                 .channel_mode = alc260_modes,
5215                 .input_mux = &alc260_capture_source,
5216                 .unsol_event = alc260_hp_unsol_event,
5217                 .init_hook = alc260_hp_automute,
5218         },
5219         [ALC260_HP_3013] = {
5220                 .mixers = { alc260_hp_3013_mixer,
5221                             alc260_input_mixer,
5222                             alc260_capture_alt_mixer },
5223                 .init_verbs = { alc260_hp_3013_init_verbs,
5224                                 alc260_hp_3013_unsol_verbs },
5225                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5226                 .dac_nids = alc260_dac_nids,
5227                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5228                 .adc_nids = alc260_hp_adc_nids,
5229                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5230                 .channel_mode = alc260_modes,
5231                 .input_mux = &alc260_capture_source,
5232                 .unsol_event = alc260_hp_3013_unsol_event,
5233                 .init_hook = alc260_hp_3013_automute,
5234         },
5235         [ALC260_FUJITSU_S702X] = {
5236                 .mixers = { alc260_fujitsu_mixer,
5237                             alc260_capture_mixer },
5238                 .init_verbs = { alc260_fujitsu_init_verbs },
5239                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5240                 .dac_nids = alc260_dac_nids,
5241                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5242                 .adc_nids = alc260_dual_adc_nids,
5243                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5244                 .channel_mode = alc260_modes,
5245                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5246                 .input_mux = alc260_fujitsu_capture_sources,
5247         },
5248         [ALC260_ACER] = {
5249                 .mixers = { alc260_acer_mixer,
5250                             alc260_capture_mixer },
5251                 .init_verbs = { alc260_acer_init_verbs },
5252                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5253                 .dac_nids = alc260_dac_nids,
5254                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5255                 .adc_nids = alc260_dual_adc_nids,
5256                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5257                 .channel_mode = alc260_modes,
5258                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5259                 .input_mux = alc260_acer_capture_sources,
5260         },
5261         [ALC260_WILL] = {
5262                 .mixers = { alc260_will_mixer,
5263                             alc260_capture_mixer },
5264                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5265                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5266                 .dac_nids = alc260_dac_nids,
5267                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5268                 .adc_nids = alc260_adc_nids,
5269                 .dig_out_nid = ALC260_DIGOUT_NID,
5270                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5271                 .channel_mode = alc260_modes,
5272                 .input_mux = &alc260_capture_source,
5273         },
5274         [ALC260_REPLACER_672V] = {
5275                 .mixers = { alc260_replacer_672v_mixer,
5276                             alc260_capture_mixer },
5277                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5278                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5279                 .dac_nids = alc260_dac_nids,
5280                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5281                 .adc_nids = alc260_adc_nids,
5282                 .dig_out_nid = ALC260_DIGOUT_NID,
5283                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5284                 .channel_mode = alc260_modes,
5285                 .input_mux = &alc260_capture_source,
5286                 .unsol_event = alc260_replacer_672v_unsol_event,
5287                 .init_hook = alc260_replacer_672v_automute,
5288         },
5289 #ifdef CONFIG_SND_DEBUG
5290         [ALC260_TEST] = {
5291                 .mixers = { alc260_test_mixer,
5292                             alc260_capture_mixer },
5293                 .init_verbs = { alc260_test_init_verbs },
5294                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5295                 .dac_nids = alc260_test_dac_nids,
5296                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5297                 .adc_nids = alc260_test_adc_nids,
5298                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5299                 .channel_mode = alc260_modes,
5300                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5301                 .input_mux = alc260_test_capture_sources,
5302         },
5303 #endif
5304 };
5305
5306 static int patch_alc260(struct hda_codec *codec)
5307 {
5308         struct alc_spec *spec;
5309         int err, board_config;
5310
5311         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5312         if (spec == NULL)
5313                 return -ENOMEM;
5314
5315         codec->spec = spec;
5316
5317         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5318                                                   alc260_models,
5319                                                   alc260_cfg_tbl);
5320         if (board_config < 0) {
5321                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5322                            "trying auto-probe from BIOS...\n");
5323                 board_config = ALC260_AUTO;
5324         }
5325
5326         if (board_config == ALC260_AUTO) {
5327                 /* automatic parse from the BIOS config */
5328                 err = alc260_parse_auto_config(codec);
5329                 if (err < 0) {
5330                         alc_free(codec);
5331                         return err;
5332                 } else if (!err) {
5333                         printk(KERN_INFO
5334                                "hda_codec: Cannot set up configuration "
5335                                "from BIOS.  Using base mode...\n");
5336                         board_config = ALC260_BASIC;
5337                 }
5338         }
5339
5340         if (board_config != ALC260_AUTO)
5341                 setup_preset(spec, &alc260_presets[board_config]);
5342
5343         spec->stream_name_analog = "ALC260 Analog";
5344         spec->stream_analog_playback = &alc260_pcm_analog_playback;
5345         spec->stream_analog_capture = &alc260_pcm_analog_capture;
5346
5347         spec->stream_name_digital = "ALC260 Digital";
5348         spec->stream_digital_playback = &alc260_pcm_digital_playback;
5349         spec->stream_digital_capture = &alc260_pcm_digital_capture;
5350
5351         spec->vmaster_nid = 0x08;
5352
5353         codec->patch_ops = alc_patch_ops;
5354         if (board_config == ALC260_AUTO)
5355                 spec->init_hook = alc260_auto_init;
5356 #ifdef CONFIG_SND_HDA_POWER_SAVE
5357         if (!spec->loopback.amplist)
5358                 spec->loopback.amplist = alc260_loopbacks;
5359 #endif
5360
5361         return 0;
5362 }
5363
5364
5365 /*
5366  * ALC882 support
5367  *
5368  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5369  * configuration.  Each pin widget can choose any input DACs and a mixer.
5370  * Each ADC is connected from a mixer of all inputs.  This makes possible
5371  * 6-channel independent captures.
5372  *
5373  * In addition, an independent DAC for the multi-playback (not used in this
5374  * driver yet).
5375  */
5376 #define ALC882_DIGOUT_NID       0x06
5377 #define ALC882_DIGIN_NID        0x0a
5378
5379 static struct hda_channel_mode alc882_ch_modes[1] = {
5380         { 8, NULL }
5381 };
5382
5383 static hda_nid_t alc882_dac_nids[4] = {
5384         /* front, rear, clfe, rear_surr */
5385         0x02, 0x03, 0x04, 0x05
5386 };
5387
5388 /* identical with ALC880 */
5389 #define alc882_adc_nids         alc880_adc_nids
5390 #define alc882_adc_nids_alt     alc880_adc_nids_alt
5391
5392 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5393 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5394
5395 /* input MUX */
5396 /* FIXME: should be a matrix-type input source selection */
5397
5398 static struct hda_input_mux alc882_capture_source = {
5399         .num_items = 4,
5400         .items = {
5401                 { "Mic", 0x0 },
5402                 { "Front Mic", 0x1 },
5403                 { "Line", 0x2 },
5404                 { "CD", 0x4 },
5405         },
5406 };
5407 #define alc882_mux_enum_info alc_mux_enum_info
5408 #define alc882_mux_enum_get alc_mux_enum_get
5409
5410 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5411                                struct snd_ctl_elem_value *ucontrol)
5412 {
5413         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5414         struct alc_spec *spec = codec->spec;
5415         const struct hda_input_mux *imux = spec->input_mux;
5416         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5417         hda_nid_t nid = spec->capsrc_nids ?
5418                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
5419         unsigned int *cur_val = &spec->cur_mux[adc_idx];
5420         unsigned int i, idx;
5421
5422         idx = ucontrol->value.enumerated.item[0];
5423         if (idx >= imux->num_items)
5424                 idx = imux->num_items - 1;
5425         if (*cur_val == idx)
5426                 return 0;
5427         for (i = 0; i < imux->num_items; i++) {
5428                 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5429                 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5430                                          imux->items[i].index,
5431                                          HDA_AMP_MUTE, v);
5432         }
5433         *cur_val = idx;
5434         return 1;
5435 }
5436
5437 /*
5438  * 2ch mode
5439  */
5440 static struct hda_verb alc882_3ST_ch2_init[] = {
5441         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5442         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5443         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5444         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5445         { } /* end */
5446 };
5447
5448 /*
5449  * 6ch mode
5450  */
5451 static struct hda_verb alc882_3ST_ch6_init[] = {
5452         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5453         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5454         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5455         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5456         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5457         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5458         { } /* end */
5459 };
5460
5461 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5462         { 2, alc882_3ST_ch2_init },
5463         { 6, alc882_3ST_ch6_init },
5464 };
5465
5466 /*
5467  * 6ch mode
5468  */
5469 static struct hda_verb alc882_sixstack_ch6_init[] = {
5470         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5471         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5472         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5473         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5474         { } /* end */
5475 };
5476
5477 /*
5478  * 8ch mode
5479  */
5480 static struct hda_verb alc882_sixstack_ch8_init[] = {
5481         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5482         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5483         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5484         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5485         { } /* end */
5486 };
5487
5488 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5489         { 6, alc882_sixstack_ch6_init },
5490         { 8, alc882_sixstack_ch8_init },
5491 };
5492
5493 /*
5494  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5495  */
5496
5497 /*
5498  * 2ch mode
5499  */
5500 static struct hda_verb alc885_mbp_ch2_init[] = {
5501         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5502         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5503         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5504         { } /* end */
5505 };
5506
5507 /*
5508  * 6ch mode
5509  */
5510 static struct hda_verb alc885_mbp_ch6_init[] = {
5511         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5512         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5513         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5514         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5515         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5516         { } /* end */
5517 };
5518
5519 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5520         { 2, alc885_mbp_ch2_init },
5521         { 6, alc885_mbp_ch6_init },
5522 };
5523
5524
5525 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5526  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5527  */
5528 static struct snd_kcontrol_new alc882_base_mixer[] = {
5529         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5530         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5531         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5532         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5533         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5534         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5535         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5536         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5537         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5538         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5539         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5540         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5541         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5542         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5543         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5544         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5545         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5546         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5547         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5548         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5549         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5550         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5551         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5552         { } /* end */
5553 };
5554
5555 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5556         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5557         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5558         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5559         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5560         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5561         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5562         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5563         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5564         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5565         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5566         { } /* end */
5567 };
5568 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5569         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5570         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5571         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5572         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5573         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5574         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5575         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5576         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5577         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5578         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5579         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5580         { } /* end */
5581 };
5582
5583 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5584         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5585         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5586         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5587         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5588         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5589         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5590         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5591         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5592         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5593         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5594         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5595         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5596         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5597         { } /* end */
5598 };
5599
5600 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5601  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5602  */
5603 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5604         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5605         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5606         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5607         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5608         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5609         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5610         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5611         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5612         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5613         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5614         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5615         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5616         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5617         { } /* end */
5618 };
5619
5620 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5621         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5622         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5623         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5624         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5625         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5626         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5627         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5628         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5629         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5630         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5631         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5632         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5633         { } /* end */
5634 };
5635
5636 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5637         {
5638                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5639                 .name = "Channel Mode",
5640                 .info = alc_ch_mode_info,
5641                 .get = alc_ch_mode_get,
5642                 .put = alc_ch_mode_put,
5643         },
5644         { } /* end */
5645 };
5646
5647 static struct hda_verb alc882_init_verbs[] = {
5648         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5649         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5650         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5651         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5652         /* Rear mixer */
5653         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5654         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5655         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5656         /* CLFE mixer */
5657         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5658         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5659         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5660         /* Side mixer */
5661         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5662         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5663         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5664
5665         /* Front Pin: output 0 (0x0c) */
5666         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5667         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5668         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5669         /* Rear Pin: output 1 (0x0d) */
5670         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5671         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5672         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5673         /* CLFE Pin: output 2 (0x0e) */
5674         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5675         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5676         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5677         /* Side Pin: output 3 (0x0f) */
5678         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5679         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5680         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5681         /* Mic (rear) pin: input vref at 80% */
5682         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5683         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5684         /* Front Mic pin: input vref at 80% */
5685         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5686         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5687         /* Line In pin: input */
5688         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5689         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5690         /* Line-2 In: Headphone output (output 0 - 0x0c) */
5691         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5692         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5693         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5694         /* CD pin widget for input */
5695         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5696
5697         /* FIXME: use matrix-type input source selection */
5698         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5699         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5700         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5701         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5702         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5703         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5704         /* Input mixer2 */
5705         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5706         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5707         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5708         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5709         /* Input mixer3 */
5710         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5711         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5712         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5713         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5714         /* ADC1: mute amp left and right */
5715         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5716         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5717         /* ADC2: mute amp left and right */
5718         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5719         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5720         /* ADC3: mute amp left and right */
5721         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5722         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5723
5724         { }
5725 };
5726
5727 static struct hda_verb alc882_eapd_verbs[] = {
5728         /* change to EAPD mode */
5729         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5730         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5731         { }
5732 };
5733
5734 /* Mac Pro test */
5735 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5736         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5737         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5738         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5739         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5740         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5741         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5742         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5743         { } /* end */
5744 };
5745
5746 static struct hda_verb alc882_macpro_init_verbs[] = {
5747         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5748         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5749         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5750         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5751         /* Front Pin: output 0 (0x0c) */
5752         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5753         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5754         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5755         /* Front Mic pin: input vref at 80% */
5756         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5757         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5758         /* Speaker:  output */
5759         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5760         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5761         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5762         /* Headphone output (output 0 - 0x0c) */
5763         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5764         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5765         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5766
5767         /* FIXME: use matrix-type input source selection */
5768         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5769         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5770         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5771         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5772         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5773         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5774         /* Input mixer2 */
5775         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5776         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5777         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5778         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5779         /* Input mixer3 */
5780         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5781         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5782         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5783         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5784         /* ADC1: mute amp left and right */
5785         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5786         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5787         /* ADC2: mute amp left and right */
5788         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5789         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5790         /* ADC3: mute amp left and right */
5791         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5792         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5793
5794         { }
5795 };
5796
5797 /* Macbook Pro rev3 */
5798 static struct hda_verb alc885_mbp3_init_verbs[] = {
5799         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5800         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5801         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5802         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5803         /* Rear mixer */
5804         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5805         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5806         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5807         /* Front Pin: output 0 (0x0c) */
5808         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5809         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5810         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5811         /* HP Pin: output 0 (0x0d) */
5812         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
5813         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5814         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5815         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5816         /* Mic (rear) pin: input vref at 80% */
5817         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5818         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5819         /* Front Mic pin: input vref at 80% */
5820         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5821         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5822         /* Line In pin: use output 1 when in LineOut mode */
5823         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5824         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5825         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
5826
5827         /* FIXME: use matrix-type input source selection */
5828         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5829         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5830         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5831         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5832         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5833         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5834         /* Input mixer2 */
5835         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5836         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5837         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5838         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5839         /* Input mixer3 */
5840         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5841         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5842         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5843         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5844         /* ADC1: mute amp left and right */
5845         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5846         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5847         /* ADC2: mute amp left and right */
5848         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5849         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5850         /* ADC3: mute amp left and right */
5851         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5852         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5853
5854         { }
5855 };
5856
5857 /* iMac 24 mixer. */
5858 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
5859         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5860         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
5861         { } /* end */
5862 };
5863
5864 /* iMac 24 init verbs. */
5865 static struct hda_verb alc885_imac24_init_verbs[] = {
5866         /* Internal speakers: output 0 (0x0c) */
5867         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5868         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5869         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5870         /* Internal speakers: output 0 (0x0c) */
5871         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5872         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5873         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
5874         /* Headphone: output 0 (0x0c) */
5875         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5876         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5877         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5878         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5879         /* Front Mic: input vref at 80% */
5880         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5881         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5882         { }
5883 };
5884
5885 /* Toggle speaker-output according to the hp-jack state */
5886 static void alc885_imac24_automute(struct hda_codec *codec)
5887 {
5888         unsigned int present;
5889
5890         present = snd_hda_codec_read(codec, 0x14, 0,
5891                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5892         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
5893                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5894         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
5895                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5896 }
5897
5898 /* Processes unsolicited events. */
5899 static void alc885_imac24_unsol_event(struct hda_codec *codec,
5900                                       unsigned int res)
5901 {
5902         /* Headphone insertion or removal. */
5903         if ((res >> 26) == ALC880_HP_EVENT)
5904                 alc885_imac24_automute(codec);
5905 }
5906
5907 static void alc885_mbp3_automute(struct hda_codec *codec)
5908 {
5909         unsigned int present;
5910
5911         present = snd_hda_codec_read(codec, 0x15, 0,
5912                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5913         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
5914                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5915         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
5916                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
5917
5918 }
5919 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
5920                                     unsigned int res)
5921 {
5922         /* Headphone insertion or removal. */
5923         if ((res >> 26) == ALC880_HP_EVENT)
5924                 alc885_mbp3_automute(codec);
5925 }
5926
5927
5928 static struct hda_verb alc882_targa_verbs[] = {
5929         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5930         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5931
5932         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5933         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5934
5935         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5936         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5937         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5938
5939         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5940         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5941         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
5942         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
5943         { } /* end */
5944 };
5945
5946 /* toggle speaker-output according to the hp-jack state */
5947 static void alc882_targa_automute(struct hda_codec *codec)
5948 {
5949         unsigned int present;
5950
5951         present = snd_hda_codec_read(codec, 0x14, 0,
5952                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5953         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
5954                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5955         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
5956                                   present ? 1 : 3);
5957 }
5958
5959 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
5960 {
5961         /* Looks like the unsol event is incompatible with the standard
5962          * definition.  4bit tag is placed at 26 bit!
5963          */
5964         if (((res >> 26) == ALC880_HP_EVENT)) {
5965                 alc882_targa_automute(codec);
5966         }
5967 }
5968
5969 static struct hda_verb alc882_asus_a7j_verbs[] = {
5970         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5971         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5972
5973         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5974         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5975         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5976
5977         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5978         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5979         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5980
5981         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5982         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5983         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5984         { } /* end */
5985 };
5986
5987 static struct hda_verb alc882_asus_a7m_verbs[] = {
5988         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5989         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5990
5991         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5992         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5993         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5994
5995         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5996         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5997         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5998
5999         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6000         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6001         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6002         { } /* end */
6003 };
6004
6005 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6006 {
6007         unsigned int gpiostate, gpiomask, gpiodir;
6008
6009         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6010                                        AC_VERB_GET_GPIO_DATA, 0);
6011
6012         if (!muted)
6013                 gpiostate |= (1 << pin);
6014         else
6015                 gpiostate &= ~(1 << pin);
6016
6017         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6018                                       AC_VERB_GET_GPIO_MASK, 0);
6019         gpiomask |= (1 << pin);
6020
6021         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6022                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6023         gpiodir |= (1 << pin);
6024
6025
6026         snd_hda_codec_write(codec, codec->afg, 0,
6027                             AC_VERB_SET_GPIO_MASK, gpiomask);
6028         snd_hda_codec_write(codec, codec->afg, 0,
6029                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6030
6031         msleep(1);
6032
6033         snd_hda_codec_write(codec, codec->afg, 0,
6034                             AC_VERB_SET_GPIO_DATA, gpiostate);
6035 }
6036
6037 /* set up GPIO at initialization */
6038 static void alc885_macpro_init_hook(struct hda_codec *codec)
6039 {
6040         alc882_gpio_mute(codec, 0, 0);
6041         alc882_gpio_mute(codec, 1, 0);
6042 }
6043
6044 /* set up GPIO and update auto-muting at initialization */
6045 static void alc885_imac24_init_hook(struct hda_codec *codec)
6046 {
6047         alc885_macpro_init_hook(codec);
6048         alc885_imac24_automute(codec);
6049 }
6050
6051 /*
6052  * generic initialization of ADC, input mixers and output mixers
6053  */
6054 static struct hda_verb alc882_auto_init_verbs[] = {
6055         /*
6056          * Unmute ADC0-2 and set the default input to mic-in
6057          */
6058         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6059         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6060         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6061         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6062         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6063         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6064
6065         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6066          * mixer widget
6067          * Note: PASD motherboards uses the Line In 2 as the input for
6068          * front panel mic (mic 2)
6069          */
6070         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6071         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6072         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6073         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6074         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6075         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6076
6077         /*
6078          * Set up output mixers (0x0c - 0x0f)
6079          */
6080         /* set vol=0 to output mixers */
6081         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6082         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6083         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6084         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6085         /* set up input amps for analog loopback */
6086         /* Amp Indices: DAC = 0, mixer = 1 */
6087         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6088         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6089         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6090         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6091         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6092         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6093         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6094         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6095         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6096         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6097
6098         /* FIXME: use matrix-type input source selection */
6099         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6100         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6101         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6102         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6103         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6104         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6105         /* Input mixer2 */
6106         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6107         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6108         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6109         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6110         /* Input mixer3 */
6111         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6112         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6113         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6114         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6115
6116         { }
6117 };
6118
6119 /* capture mixer elements */
6120 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
6121         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6122         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6123         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6124         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6125         {
6126                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6127                 /* The multiple "Capture Source" controls confuse alsamixer
6128                  * So call somewhat different..
6129                  */
6130                 /* .name = "Capture Source", */
6131                 .name = "Input Source",
6132                 .count = 2,
6133                 .info = alc882_mux_enum_info,
6134                 .get = alc882_mux_enum_get,
6135                 .put = alc882_mux_enum_put,
6136         },
6137         { } /* end */
6138 };
6139
6140 static struct snd_kcontrol_new alc882_capture_mixer[] = {
6141         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
6142         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
6143         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
6144         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
6145         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
6146         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
6147         {
6148                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6149                 /* The multiple "Capture Source" controls confuse alsamixer
6150                  * So call somewhat different..
6151                  */
6152                 /* .name = "Capture Source", */
6153                 .name = "Input Source",
6154                 .count = 3,
6155                 .info = alc882_mux_enum_info,
6156                 .get = alc882_mux_enum_get,
6157                 .put = alc882_mux_enum_put,
6158         },
6159         { } /* end */
6160 };
6161
6162 #ifdef CONFIG_SND_HDA_POWER_SAVE
6163 #define alc882_loopbacks        alc880_loopbacks
6164 #endif
6165
6166 /* pcm configuration: identiacal with ALC880 */
6167 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6168 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6169 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6170 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6171
6172 /*
6173  * configuration and preset
6174  */
6175 static const char *alc882_models[ALC882_MODEL_LAST] = {
6176         [ALC882_3ST_DIG]        = "3stack-dig",
6177         [ALC882_6ST_DIG]        = "6stack-dig",
6178         [ALC882_ARIMA]          = "arima",
6179         [ALC882_W2JC]           = "w2jc",
6180         [ALC882_TARGA]          = "targa",
6181         [ALC882_ASUS_A7J]       = "asus-a7j",
6182         [ALC882_ASUS_A7M]       = "asus-a7m",
6183         [ALC885_MACPRO]         = "macpro",
6184         [ALC885_MBP3]           = "mbp3",
6185         [ALC885_IMAC24]         = "imac24",
6186         [ALC882_AUTO]           = "auto",
6187 };
6188
6189 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6190         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6191         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6192         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6193         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6194         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6195         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6196         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6197         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6198         SND_PCI_QUIRK(0x106b, 0x00a0, "Apple iMac 24''", ALC885_IMAC24),
6199         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6200         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6201         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6202         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6203         {}
6204 };
6205
6206 static struct alc_config_preset alc882_presets[] = {
6207         [ALC882_3ST_DIG] = {
6208                 .mixers = { alc882_base_mixer },
6209                 .init_verbs = { alc882_init_verbs },
6210                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6211                 .dac_nids = alc882_dac_nids,
6212                 .dig_out_nid = ALC882_DIGOUT_NID,
6213                 .dig_in_nid = ALC882_DIGIN_NID,
6214                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6215                 .channel_mode = alc882_ch_modes,
6216                 .need_dac_fix = 1,
6217                 .input_mux = &alc882_capture_source,
6218         },
6219         [ALC882_6ST_DIG] = {
6220                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6221                 .init_verbs = { alc882_init_verbs },
6222                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6223                 .dac_nids = alc882_dac_nids,
6224                 .dig_out_nid = ALC882_DIGOUT_NID,
6225                 .dig_in_nid = ALC882_DIGIN_NID,
6226                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6227                 .channel_mode = alc882_sixstack_modes,
6228                 .input_mux = &alc882_capture_source,
6229         },
6230         [ALC882_ARIMA] = {
6231                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6232                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6233                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6234                 .dac_nids = alc882_dac_nids,
6235                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6236                 .channel_mode = alc882_sixstack_modes,
6237                 .input_mux = &alc882_capture_source,
6238         },
6239         [ALC882_W2JC] = {
6240                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6241                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6242                                 alc880_gpio1_init_verbs },
6243                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6244                 .dac_nids = alc882_dac_nids,
6245                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6246                 .channel_mode = alc880_threestack_modes,
6247                 .need_dac_fix = 1,
6248                 .input_mux = &alc882_capture_source,
6249                 .dig_out_nid = ALC882_DIGOUT_NID,
6250         },
6251         [ALC885_MBP3] = {
6252                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6253                 .init_verbs = { alc885_mbp3_init_verbs,
6254                                 alc880_gpio1_init_verbs },
6255                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6256                 .dac_nids = alc882_dac_nids,
6257                 .channel_mode = alc885_mbp_6ch_modes,
6258                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6259                 .input_mux = &alc882_capture_source,
6260                 .dig_out_nid = ALC882_DIGOUT_NID,
6261                 .dig_in_nid = ALC882_DIGIN_NID,
6262                 .unsol_event = alc885_mbp3_unsol_event,
6263                 .init_hook = alc885_mbp3_automute,
6264         },
6265         [ALC885_MACPRO] = {
6266                 .mixers = { alc882_macpro_mixer },
6267                 .init_verbs = { alc882_macpro_init_verbs },
6268                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6269                 .dac_nids = alc882_dac_nids,
6270                 .dig_out_nid = ALC882_DIGOUT_NID,
6271                 .dig_in_nid = ALC882_DIGIN_NID,
6272                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6273                 .channel_mode = alc882_ch_modes,
6274                 .input_mux = &alc882_capture_source,
6275                 .init_hook = alc885_macpro_init_hook,
6276         },
6277         [ALC885_IMAC24] = {
6278                 .mixers = { alc885_imac24_mixer },
6279                 .init_verbs = { alc885_imac24_init_verbs },
6280                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6281                 .dac_nids = alc882_dac_nids,
6282                 .dig_out_nid = ALC882_DIGOUT_NID,
6283                 .dig_in_nid = ALC882_DIGIN_NID,
6284                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6285                 .channel_mode = alc882_ch_modes,
6286                 .input_mux = &alc882_capture_source,
6287                 .unsol_event = alc885_imac24_unsol_event,
6288                 .init_hook = alc885_imac24_init_hook,
6289         },
6290         [ALC882_TARGA] = {
6291                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6292                             alc882_capture_mixer },
6293                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6294                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6295                 .dac_nids = alc882_dac_nids,
6296                 .dig_out_nid = ALC882_DIGOUT_NID,
6297                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6298                 .adc_nids = alc882_adc_nids,
6299                 .capsrc_nids = alc882_capsrc_nids,
6300                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6301                 .channel_mode = alc882_3ST_6ch_modes,
6302                 .need_dac_fix = 1,
6303                 .input_mux = &alc882_capture_source,
6304                 .unsol_event = alc882_targa_unsol_event,
6305                 .init_hook = alc882_targa_automute,
6306         },
6307         [ALC882_ASUS_A7J] = {
6308                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6309                             alc882_capture_mixer },
6310                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6311                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6312                 .dac_nids = alc882_dac_nids,
6313                 .dig_out_nid = ALC882_DIGOUT_NID,
6314                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6315                 .adc_nids = alc882_adc_nids,
6316                 .capsrc_nids = alc882_capsrc_nids,
6317                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6318                 .channel_mode = alc882_3ST_6ch_modes,
6319                 .need_dac_fix = 1,
6320                 .input_mux = &alc882_capture_source,
6321         },
6322         [ALC882_ASUS_A7M] = {
6323                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6324                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6325                                 alc880_gpio1_init_verbs,
6326                                 alc882_asus_a7m_verbs },
6327                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6328                 .dac_nids = alc882_dac_nids,
6329                 .dig_out_nid = ALC882_DIGOUT_NID,
6330                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6331                 .channel_mode = alc880_threestack_modes,
6332                 .need_dac_fix = 1,
6333                 .input_mux = &alc882_capture_source,
6334         },
6335 };
6336
6337
6338 /*
6339  * Pin config fixes
6340  */
6341 enum {
6342         PINFIX_ABIT_AW9D_MAX
6343 };
6344
6345 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6346         { 0x15, 0x01080104 }, /* side */
6347         { 0x16, 0x01011012 }, /* rear */
6348         { 0x17, 0x01016011 }, /* clfe */
6349         { }
6350 };
6351
6352 static const struct alc_pincfg *alc882_pin_fixes[] = {
6353         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6354 };
6355
6356 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6357         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6358         {}
6359 };
6360
6361 /*
6362  * BIOS auto configuration
6363  */
6364 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6365                                               hda_nid_t nid, int pin_type,
6366                                               int dac_idx)
6367 {
6368         /* set as output */
6369         struct alc_spec *spec = codec->spec;
6370         int idx;
6371
6372         alc_set_pin_output(codec, nid, pin_type);
6373         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6374                 idx = 4;
6375         else
6376                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6377         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6378
6379 }
6380
6381 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6382 {
6383         struct alc_spec *spec = codec->spec;
6384         int i;
6385
6386         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6387         for (i = 0; i <= HDA_SIDE; i++) {
6388                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6389                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6390                 if (nid)
6391                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6392                                                           i);
6393         }
6394 }
6395
6396 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6397 {
6398         struct alc_spec *spec = codec->spec;
6399         hda_nid_t pin;
6400
6401         pin = spec->autocfg.hp_pins[0];
6402         if (pin) /* connect to front */
6403                 /* use dac 0 */
6404                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6405         pin = spec->autocfg.speaker_pins[0];
6406         if (pin)
6407                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6408 }
6409
6410 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
6411 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
6412
6413 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6414 {
6415         struct alc_spec *spec = codec->spec;
6416         int i;
6417
6418         for (i = 0; i < AUTO_PIN_LAST; i++) {
6419                 hda_nid_t nid = spec->autocfg.input_pins[i];
6420                 unsigned int vref;
6421                 if (!nid)
6422                         continue;
6423                 vref = PIN_IN;
6424                 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6425                         unsigned int pincap;
6426                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6427                         if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6428                             AC_PINCAP_VREF_80)
6429                                 vref = PIN_VREF80;
6430                 }
6431                 snd_hda_codec_write(codec, nid, 0,
6432                                     AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6433                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6434                         snd_hda_codec_write(codec, nid, 0,
6435                                             AC_VERB_SET_AMP_GAIN_MUTE,
6436                                             AMP_OUT_MUTE);
6437         }
6438 }
6439
6440 static void alc882_auto_init_input_src(struct hda_codec *codec)
6441 {
6442         struct alc_spec *spec = codec->spec;
6443         const struct hda_input_mux *imux = spec->input_mux;
6444         int c;
6445
6446         for (c = 0; c < spec->num_adc_nids; c++) {
6447                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
6448                 hda_nid_t nid = spec->capsrc_nids[c];
6449                 int conns, mute, idx, item;
6450
6451                 conns = snd_hda_get_connections(codec, nid, conn_list,
6452                                                 ARRAY_SIZE(conn_list));
6453                 if (conns < 0)
6454                         continue;
6455                 for (idx = 0; idx < conns; idx++) {
6456                         /* if the current connection is the selected one,
6457                          * unmute it as default - otherwise mute it
6458                          */
6459                         mute = AMP_IN_MUTE(idx);
6460                         for (item = 0; item < imux->num_items; item++) {
6461                                 if (imux->items[item].index == idx) {
6462                                         if (spec->cur_mux[c] == item)
6463                                                 mute = AMP_IN_UNMUTE(idx);
6464                                         break;
6465                                 }
6466                         }
6467                         snd_hda_codec_write(codec, nid, 0,
6468                                             AC_VERB_SET_AMP_GAIN_MUTE, mute);
6469                 }
6470         }
6471 }
6472
6473 /* add mic boosts if needed */
6474 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6475 {
6476         struct alc_spec *spec = codec->spec;
6477         int err;
6478         hda_nid_t nid;
6479
6480         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6481         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6482                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6483                                   "Mic Boost",
6484                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6485                 if (err < 0)
6486                         return err;
6487         }
6488         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6489         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6490                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6491                                   "Front Mic Boost",
6492                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6493                 if (err < 0)
6494                         return err;
6495         }
6496         return 0;
6497 }
6498
6499 /* almost identical with ALC880 parser... */
6500 static int alc882_parse_auto_config(struct hda_codec *codec)
6501 {
6502         struct alc_spec *spec = codec->spec;
6503         int err = alc880_parse_auto_config(codec);
6504
6505         if (err < 0)
6506                 return err;
6507         else if (!err)
6508                 return 0; /* no config found */
6509
6510         err = alc_auto_add_mic_boost(codec);
6511         if (err < 0)
6512                 return err;
6513
6514         /* hack - override the init verbs */
6515         spec->init_verbs[0] = alc882_auto_init_verbs;
6516
6517         return 1; /* config found */
6518 }
6519
6520 /* additional initialization for auto-configuration model */
6521 static void alc882_auto_init(struct hda_codec *codec)
6522 {
6523         struct alc_spec *spec = codec->spec;
6524         alc882_auto_init_multi_out(codec);
6525         alc882_auto_init_hp_out(codec);
6526         alc882_auto_init_analog_input(codec);
6527         alc882_auto_init_input_src(codec);
6528         if (spec->unsol_event)
6529                 alc_sku_automute(codec);
6530 }
6531
6532 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6533
6534 static int patch_alc882(struct hda_codec *codec)
6535 {
6536         struct alc_spec *spec;
6537         int err, board_config;
6538
6539         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6540         if (spec == NULL)
6541                 return -ENOMEM;
6542
6543         codec->spec = spec;
6544
6545         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6546                                                   alc882_models,
6547                                                   alc882_cfg_tbl);
6548
6549         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6550                 /* Pick up systems that don't supply PCI SSID */
6551                 switch (codec->subsystem_id) {
6552                 case 0x106b0c00: /* Mac Pro */
6553                         board_config = ALC885_MACPRO;
6554                         break;
6555                 case 0x106b1000: /* iMac 24 */
6556                         board_config = ALC885_IMAC24;
6557                         break;
6558                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
6559                 case 0x106b2c00: /* Macbook Pro rev3 */
6560                 case 0x106b3600: /* Macbook 3.1 */
6561                         board_config = ALC885_MBP3;
6562                         break;
6563                 default:
6564                         /* ALC889A is handled better as ALC888-compatible */
6565                         if (codec->revision_id == 0x100103) {
6566                                 alc_free(codec);
6567                                 return patch_alc883(codec);
6568                         }
6569                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6570                                          "trying auto-probe from BIOS...\n");
6571                         board_config = ALC882_AUTO;
6572                 }
6573         }
6574
6575         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6576
6577         if (board_config == ALC882_AUTO) {
6578                 /* automatic parse from the BIOS config */
6579                 err = alc882_parse_auto_config(codec);
6580                 if (err < 0) {
6581                         alc_free(codec);
6582                         return err;
6583                 } else if (!err) {
6584                         printk(KERN_INFO
6585                                "hda_codec: Cannot set up configuration "
6586                                "from BIOS.  Using base mode...\n");
6587                         board_config = ALC882_3ST_DIG;
6588                 }
6589         }
6590
6591         if (board_config != ALC882_AUTO)
6592                 setup_preset(spec, &alc882_presets[board_config]);
6593
6594         if (codec->vendor_id == 0x10ec0885) {
6595                 spec->stream_name_analog = "ALC885 Analog";
6596                 spec->stream_name_digital = "ALC885 Digital";
6597         } else {
6598                 spec->stream_name_analog = "ALC882 Analog";
6599                 spec->stream_name_digital = "ALC882 Digital";
6600         }
6601
6602         spec->stream_analog_playback = &alc882_pcm_analog_playback;
6603         spec->stream_analog_capture = &alc882_pcm_analog_capture;
6604         /* FIXME: setup DAC5 */
6605         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6606         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6607
6608         spec->stream_digital_playback = &alc882_pcm_digital_playback;
6609         spec->stream_digital_capture = &alc882_pcm_digital_capture;
6610
6611         if (!spec->adc_nids && spec->input_mux) {
6612                 /* check whether NID 0x07 is valid */
6613                 unsigned int wcap = get_wcaps(codec, 0x07);
6614                 /* get type */
6615                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6616                 if (wcap != AC_WID_AUD_IN) {
6617                         spec->adc_nids = alc882_adc_nids_alt;
6618                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6619                         spec->capsrc_nids = alc882_capsrc_nids_alt;
6620                         spec->mixers[spec->num_mixers] =
6621                                 alc882_capture_alt_mixer;
6622                         spec->num_mixers++;
6623                 } else {
6624                         spec->adc_nids = alc882_adc_nids;
6625                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6626                         spec->capsrc_nids = alc882_capsrc_nids;
6627                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6628                         spec->num_mixers++;
6629                 }
6630         }
6631
6632         spec->vmaster_nid = 0x0c;
6633
6634         codec->patch_ops = alc_patch_ops;
6635         if (board_config == ALC882_AUTO)
6636                 spec->init_hook = alc882_auto_init;
6637 #ifdef CONFIG_SND_HDA_POWER_SAVE
6638         if (!spec->loopback.amplist)
6639                 spec->loopback.amplist = alc882_loopbacks;
6640 #endif
6641
6642         return 0;
6643 }
6644
6645 /*
6646  * ALC883 support
6647  *
6648  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6649  * configuration.  Each pin widget can choose any input DACs and a mixer.
6650  * Each ADC is connected from a mixer of all inputs.  This makes possible
6651  * 6-channel independent captures.
6652  *
6653  * In addition, an independent DAC for the multi-playback (not used in this
6654  * driver yet).
6655  */
6656 #define ALC883_DIGOUT_NID       0x06
6657 #define ALC883_DIGIN_NID        0x0a
6658
6659 static hda_nid_t alc883_dac_nids[4] = {
6660         /* front, rear, clfe, rear_surr */
6661         0x02, 0x03, 0x04, 0x05
6662 };
6663
6664 static hda_nid_t alc883_adc_nids[2] = {
6665         /* ADC1-2 */
6666         0x08, 0x09,
6667 };
6668
6669 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6670
6671 /* input MUX */
6672 /* FIXME: should be a matrix-type input source selection */
6673
6674 static struct hda_input_mux alc883_capture_source = {
6675         .num_items = 4,
6676         .items = {
6677                 { "Mic", 0x0 },
6678                 { "Front Mic", 0x1 },
6679                 { "Line", 0x2 },
6680                 { "CD", 0x4 },
6681         },
6682 };
6683
6684 static struct hda_input_mux alc883_3stack_6ch_intel = {
6685         .num_items = 4,
6686         .items = {
6687                 { "Mic", 0x1 },
6688                 { "Front Mic", 0x0 },
6689                 { "Line", 0x2 },
6690                 { "CD", 0x4 },
6691         },
6692 };
6693
6694 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6695         .num_items = 2,
6696         .items = {
6697                 { "Mic", 0x1 },
6698                 { "Line", 0x2 },
6699         },
6700 };
6701
6702 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6703         .num_items = 4,
6704         .items = {
6705                 { "Mic", 0x0 },
6706                 { "iMic", 0x1 },
6707                 { "Line", 0x2 },
6708                 { "CD", 0x4 },
6709         },
6710 };
6711
6712 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6713         .num_items = 2,
6714         .items = {
6715                 { "Mic", 0x0 },
6716                 { "Int Mic", 0x1 },
6717         },
6718 };
6719
6720 #define alc883_mux_enum_info alc_mux_enum_info
6721 #define alc883_mux_enum_get alc_mux_enum_get
6722 /* ALC883 has the ALC882-type input selection */
6723 #define alc883_mux_enum_put alc882_mux_enum_put
6724
6725 /*
6726  * 2ch mode
6727  */
6728 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6729         { 2, NULL }
6730 };
6731
6732 /*
6733  * 2ch mode
6734  */
6735 static struct hda_verb alc883_3ST_ch2_init[] = {
6736         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6737         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6738         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6739         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6740         { } /* end */
6741 };
6742
6743 /*
6744  * 4ch mode
6745  */
6746 static struct hda_verb alc883_3ST_ch4_init[] = {
6747         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6748         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6749         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6750         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6751         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6752         { } /* end */
6753 };
6754
6755 /*
6756  * 6ch mode
6757  */
6758 static struct hda_verb alc883_3ST_ch6_init[] = {
6759         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6760         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6761         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6762         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6763         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6764         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6765         { } /* end */
6766 };
6767
6768 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
6769         { 2, alc883_3ST_ch2_init },
6770         { 4, alc883_3ST_ch4_init },
6771         { 6, alc883_3ST_ch6_init },
6772 };
6773
6774 /*
6775  * 2ch mode
6776  */
6777 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6778         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6779         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6780         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6781         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6782         { } /* end */
6783 };
6784
6785 /*
6786  * 4ch mode
6787  */
6788 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6789         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6790         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6791         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6792         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6793         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6794         { } /* end */
6795 };
6796
6797 /*
6798  * 6ch mode
6799  */
6800 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6801         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6802         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6803         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6804         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6805         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6806         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6807         { } /* end */
6808 };
6809
6810 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6811         { 2, alc883_3ST_ch2_intel_init },
6812         { 4, alc883_3ST_ch4_intel_init },
6813         { 6, alc883_3ST_ch6_intel_init },
6814 };
6815
6816 /*
6817  * 6ch mode
6818  */
6819 static struct hda_verb alc883_sixstack_ch6_init[] = {
6820         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6821         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6822         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6823         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6824         { } /* end */
6825 };
6826
6827 /*
6828  * 8ch mode
6829  */
6830 static struct hda_verb alc883_sixstack_ch8_init[] = {
6831         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6832         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6833         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6834         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6835         { } /* end */
6836 };
6837
6838 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6839         { 6, alc883_sixstack_ch6_init },
6840         { 8, alc883_sixstack_ch8_init },
6841 };
6842
6843 static struct hda_verb alc883_medion_eapd_verbs[] = {
6844         /* eanable EAPD on medion laptop */
6845         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6846         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
6847         { }
6848 };
6849
6850 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6851  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6852  */
6853
6854 static struct snd_kcontrol_new alc883_base_mixer[] = {
6855         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6856         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6857         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6858         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6859         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6860         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6861         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6862         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6863         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6864         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6865         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6866         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6867         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6868         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6869         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6870         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6871         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6872         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6873         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6874         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6875         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6876         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6877         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6878         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6879         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6880         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6881         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6882         {
6883                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6884                 /* .name = "Capture Source", */
6885                 .name = "Input Source",
6886                 .count = 2,
6887                 .info = alc883_mux_enum_info,
6888                 .get = alc883_mux_enum_get,
6889                 .put = alc883_mux_enum_put,
6890         },
6891         { } /* end */
6892 };
6893
6894 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
6895         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6896         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6897         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6898         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6899         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6900         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6901         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6903         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6904         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6905         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6906         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6907         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6908         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6909         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6910         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6911         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6912         {
6913                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6914                 /* .name = "Capture Source", */
6915                 .name = "Input Source",
6916                 .count = 2,
6917                 .info = alc883_mux_enum_info,
6918                 .get = alc883_mux_enum_get,
6919                 .put = alc883_mux_enum_put,
6920         },
6921         { } /* end */
6922 };
6923
6924 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
6925         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6926         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
6927         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6928         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6929         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6930         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6932         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6933         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
6934         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6935         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6936         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6937         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6938         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6939         {
6940                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6941                 /* .name = "Capture Source", */
6942                 .name = "Input Source",
6943                 .count = 2,
6944                 .info = alc883_mux_enum_info,
6945                 .get = alc883_mux_enum_get,
6946                 .put = alc883_mux_enum_put,
6947         },
6948         { } /* end */
6949 };
6950
6951 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
6952         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6953         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
6954         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6955         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6956         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6957         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6958         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6959         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6960         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
6961         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6962         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6963         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6964         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6965         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6966         {
6967                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6968                 /* .name = "Capture Source", */
6969                 .name = "Input Source",
6970                 .count = 2,
6971                 .info = alc883_mux_enum_info,
6972                 .get = alc883_mux_enum_get,
6973                 .put = alc883_mux_enum_put,
6974         },
6975         { } /* end */
6976 };
6977
6978 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
6979         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6980         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6981         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6982         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6983         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6984         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6985         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6986         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6987         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6988         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6989         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6990         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6991         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6992         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6993         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6994         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6995         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6996         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6997         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6998         {
6999                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7000                 /* .name = "Capture Source", */
7001                 .name = "Input Source",
7002                 .count = 2,
7003                 .info = alc883_mux_enum_info,
7004                 .get = alc883_mux_enum_get,
7005                 .put = alc883_mux_enum_put,
7006         },
7007         { } /* end */
7008 };
7009
7010 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7011         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7012         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7013         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7014         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7015         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7016         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7017         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7018         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7019         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7020         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7021         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7022         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7023         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7024         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7025         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7026         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7027         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7028         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7029         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7030         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7031         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7032         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7033         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7034         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7035         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7036         {
7037                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7038                 /* .name = "Capture Source", */
7039                 .name = "Input Source",
7040                 .count = 2,
7041                 .info = alc883_mux_enum_info,
7042                 .get = alc883_mux_enum_get,
7043                 .put = alc883_mux_enum_put,
7044         },
7045         { } /* end */
7046 };
7047
7048 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7049         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7050         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7051         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7052         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7053         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7054                               HDA_OUTPUT),
7055         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7056         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7057         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7058         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7059         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7060         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7061         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7062         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7063         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7064         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7065         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7066         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7067         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7068         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7069         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7070         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7071         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7072         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7073         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7074         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7075         {
7076                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7077                 /* .name = "Capture Source", */
7078                 .name = "Input Source",
7079                 .count = 2,
7080                 .info = alc883_mux_enum_info,
7081                 .get = alc883_mux_enum_get,
7082                 .put = alc883_mux_enum_put,
7083         },
7084         { } /* end */
7085 };
7086
7087 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7088         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7089         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7090         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7091         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7092         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7093         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7094         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7095         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7096         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7097         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7098         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7099         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7100         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7101         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7102         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7103         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7104         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7105         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7106         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7107         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7108         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7109         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7110         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7111
7112         {
7113                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7114                 /* .name = "Capture Source", */
7115                 .name = "Input Source",
7116                 .count = 1,
7117                 .info = alc883_mux_enum_info,
7118                 .get = alc883_mux_enum_get,
7119                 .put = alc883_mux_enum_put,
7120         },
7121         { } /* end */
7122 };
7123
7124 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7125         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7126         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7127         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7128         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7129         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7130         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7131         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7132         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7133         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7134         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7135         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7136         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7137         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7138         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7139         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7140         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7141         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7142         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7143         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7144         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7145         {
7146                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7147                 /* .name = "Capture Source", */
7148                 .name = "Input Source",
7149                 .count = 2,
7150                 .info = alc883_mux_enum_info,
7151                 .get = alc883_mux_enum_get,
7152                 .put = alc883_mux_enum_put,
7153         },
7154         { } /* end */
7155 };
7156
7157 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7158         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7159         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7160         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7161         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7162         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7163         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7164         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7165         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7166         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7167         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7168         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7169         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7170         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7171         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7172         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7173         {
7174                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7175                 /* .name = "Capture Source", */
7176                 .name = "Input Source",
7177                 .count = 2,
7178                 .info = alc883_mux_enum_info,
7179                 .get = alc883_mux_enum_get,
7180                 .put = alc883_mux_enum_put,
7181         },
7182         { } /* end */
7183 };
7184
7185 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7186         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7187         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7188         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7189         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7190         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7191         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7192         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7193         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7194         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7195         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7196         {
7197                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7198                 /* .name = "Capture Source", */
7199                 .name = "Input Source",
7200                 .count = 1,
7201                 .info = alc883_mux_enum_info,
7202                 .get = alc883_mux_enum_get,
7203                 .put = alc883_mux_enum_put,
7204         },
7205         { } /* end */
7206 };
7207
7208 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7209         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7210         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7211         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7212         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7213         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7214         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7215         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7216         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7217         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7218         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7219         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7220         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7221         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7222         {
7223                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7224                 /* .name = "Capture Source", */
7225                 .name = "Input Source",
7226                 .count = 2,
7227                 .info = alc883_mux_enum_info,
7228                 .get = alc883_mux_enum_get,
7229                 .put = alc883_mux_enum_put,
7230         },
7231         { } /* end */
7232 };
7233
7234 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7235         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7236         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7237         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7238         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7239         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7241         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7242         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7243         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7244         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7245         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7246         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7247         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7248         {
7249                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7250                 /* .name = "Capture Source", */
7251                 .name = "Input Source",
7252                 .count = 2,
7253                 .info = alc883_mux_enum_info,
7254                 .get = alc883_mux_enum_get,
7255                 .put = alc883_mux_enum_put,
7256         },
7257         { } /* end */
7258 };
7259
7260 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7261         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7262         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7263         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7264         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7265         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7266         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7267         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7268         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7269         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7270         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7271         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7272         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7273         {
7274                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7275                 /* .name = "Capture Source", */
7276                 .name = "Input Source",
7277                 .count = 2,
7278                 .info = alc883_mux_enum_info,
7279                 .get = alc883_mux_enum_get,
7280                 .put = alc883_mux_enum_put,
7281         },
7282         { } /* end */
7283 };
7284
7285 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7286         {
7287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7288                 .name = "Channel Mode",
7289                 .info = alc_ch_mode_info,
7290                 .get = alc_ch_mode_get,
7291                 .put = alc_ch_mode_put,
7292         },
7293         { } /* end */
7294 };
7295
7296 static struct hda_verb alc883_init_verbs[] = {
7297         /* ADC1: mute amp left and right */
7298         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7299         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7300         /* ADC2: mute amp left and right */
7301         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7302         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7303         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7304         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7305         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7306         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7307         /* Rear mixer */
7308         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7309         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7310         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7311         /* CLFE mixer */
7312         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7313         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7314         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7315         /* Side mixer */
7316         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7317         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7318         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7319
7320         /* mute analog input loopbacks */
7321         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7322         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7323         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7324         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7325         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7326
7327         /* Front Pin: output 0 (0x0c) */
7328         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7329         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7330         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7331         /* Rear Pin: output 1 (0x0d) */
7332         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7333         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7334         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7335         /* CLFE Pin: output 2 (0x0e) */
7336         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7337         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7338         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7339         /* Side Pin: output 3 (0x0f) */
7340         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7341         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7342         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7343         /* Mic (rear) pin: input vref at 80% */
7344         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7345         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7346         /* Front Mic pin: input vref at 80% */
7347         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7348         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7349         /* Line In pin: input */
7350         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7351         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7352         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7353         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7354         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7355         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7356         /* CD pin widget for input */
7357         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7358
7359         /* FIXME: use matrix-type input source selection */
7360         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7361         /* Input mixer2 */
7362         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7363         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7364         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7365         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7366         /* Input mixer3 */
7367         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7368         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7369         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7370         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7371         { }
7372 };
7373
7374 /* toggle speaker-output according to the hp-jack state */
7375 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7376 {
7377         unsigned int present;
7378
7379         present = snd_hda_codec_read(codec, 0x15, 0,
7380                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7381         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7382                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7383         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7384                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7385 }
7386
7387 /* auto-toggle front mic */
7388 /*
7389 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7390 {
7391         unsigned int present;
7392         unsigned char bits;
7393
7394         present = snd_hda_codec_read(codec, 0x18, 0,
7395                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7396         bits = present ? HDA_AMP_MUTE : 0;
7397         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7398 }
7399 */
7400
7401 static void alc883_mitac_automute(struct hda_codec *codec)
7402 {
7403         alc883_mitac_hp_automute(codec);
7404         /* alc883_mitac_mic_automute(codec); */
7405 }
7406
7407 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7408                                            unsigned int res)
7409 {
7410         switch (res >> 26) {
7411         case ALC880_HP_EVENT:
7412                 alc883_mitac_hp_automute(codec);
7413                 break;
7414         case ALC880_MIC_EVENT:
7415                 /* alc883_mitac_mic_automute(codec); */
7416                 break;
7417         }
7418 }
7419
7420 static struct hda_verb alc883_mitac_verbs[] = {
7421         /* HP */
7422         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7423         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7424         /* Subwoofer */
7425         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7426         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7427
7428         /* enable unsolicited event */
7429         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7430         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7431
7432         { } /* end */
7433 };
7434
7435 static struct hda_verb alc883_clevo_m720_verbs[] = {
7436         /* HP */
7437         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7438         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7439         /* Int speaker */
7440         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7441         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7442
7443         /* enable unsolicited event */
7444         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7445         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7446
7447         { } /* end */
7448 };
7449
7450 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7451         /* HP */
7452         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7453         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7454         /* Subwoofer */
7455         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7456         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7457
7458         /* enable unsolicited event */
7459         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7460
7461         { } /* end */
7462 };
7463
7464 static struct hda_verb alc883_tagra_verbs[] = {
7465         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7466         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7467
7468         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7469         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7470
7471         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7472         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7473         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7474
7475         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7476         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7477         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7478         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7479
7480         { } /* end */
7481 };
7482
7483 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7484         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7485         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7486         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7487         { } /* end */
7488 };
7489
7490 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7491         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7492         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7493         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7494         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7495         { } /* end */
7496 };
7497
7498 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7499         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7500         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7501         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7502         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7503         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7504         { } /* end */
7505 };
7506
7507 static struct hda_verb alc883_haier_w66_verbs[] = {
7508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7509         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7510
7511         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7512
7513         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7514         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7515         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7516         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7517         { } /* end */
7518 };
7519
7520 static struct hda_verb alc888_3st_hp_verbs[] = {
7521         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7522         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7523         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7524         { }
7525 };
7526
7527 static struct hda_verb alc888_6st_dell_verbs[] = {
7528         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7529         { }
7530 };
7531
7532 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7533         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7534         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7535         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7536         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7537         { }
7538 };
7539
7540 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7541         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7542         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7543         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7544         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7545         { }
7546 };
7547
7548 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7549         { 2, alc888_3st_hp_2ch_init },
7550         { 6, alc888_3st_hp_6ch_init },
7551 };
7552
7553 /* toggle front-jack and RCA according to the hp-jack state */
7554 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7555 {
7556         unsigned int present;
7557
7558         present = snd_hda_codec_read(codec, 0x1b, 0,
7559                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7560         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7561                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7562         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7563                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7564 }
7565
7566 /* toggle RCA according to the front-jack state */
7567 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7568 {
7569         unsigned int present;
7570
7571         present = snd_hda_codec_read(codec, 0x14, 0,
7572                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7573         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7574                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7575 }
7576
7577 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7578                                              unsigned int res)
7579 {
7580         if ((res >> 26) == ALC880_HP_EVENT)
7581                 alc888_lenovo_ms7195_front_automute(codec);
7582         if ((res >> 26) == ALC880_FRONT_EVENT)
7583                 alc888_lenovo_ms7195_rca_automute(codec);
7584 }
7585
7586 static struct hda_verb alc883_medion_md2_verbs[] = {
7587         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7588         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7589
7590         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7591
7592         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7593         { } /* end */
7594 };
7595
7596 /* toggle speaker-output according to the hp-jack state */
7597 static void alc883_medion_md2_automute(struct hda_codec *codec)
7598 {
7599         unsigned int present;
7600
7601         present = snd_hda_codec_read(codec, 0x14, 0,
7602                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7603         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7604                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7605 }
7606
7607 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7608                                           unsigned int res)
7609 {
7610         if ((res >> 26) == ALC880_HP_EVENT)
7611                 alc883_medion_md2_automute(codec);
7612 }
7613
7614 /* toggle speaker-output according to the hp-jack state */
7615 static void alc883_tagra_automute(struct hda_codec *codec)
7616 {
7617         unsigned int present;
7618         unsigned char bits;
7619
7620         present = snd_hda_codec_read(codec, 0x14, 0,
7621                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7622         bits = present ? HDA_AMP_MUTE : 0;
7623         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7624                                  HDA_AMP_MUTE, bits);
7625         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7626                                   present ? 1 : 3);
7627 }
7628
7629 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7630 {
7631         if ((res >> 26) == ALC880_HP_EVENT)
7632                 alc883_tagra_automute(codec);
7633 }
7634
7635 /* toggle speaker-output according to the hp-jack state */
7636 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7637 {
7638         unsigned int present;
7639         unsigned char bits;
7640
7641         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7642                 & AC_PINSENSE_PRESENCE;
7643         bits = present ? HDA_AMP_MUTE : 0;
7644         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7645                                  HDA_AMP_MUTE, bits);
7646 }
7647
7648 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7649 {
7650         unsigned int present;
7651
7652         present = snd_hda_codec_read(codec, 0x18, 0,
7653                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7654         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7655                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7656 }
7657
7658 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7659 {
7660         alc883_clevo_m720_hp_automute(codec);
7661         alc883_clevo_m720_mic_automute(codec);
7662 }
7663
7664 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7665                                            unsigned int res)
7666 {
7667         switch (res >> 26) {
7668         case ALC880_HP_EVENT:
7669                 alc883_clevo_m720_hp_automute(codec);
7670                 break;
7671         case ALC880_MIC_EVENT:
7672                 alc883_clevo_m720_mic_automute(codec);
7673                 break;
7674         }
7675 }
7676
7677 /* toggle speaker-output according to the hp-jack state */
7678 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
7679 {
7680         unsigned int present;
7681         unsigned char bits;
7682
7683         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
7684                 & AC_PINSENSE_PRESENCE;
7685         bits = present ? HDA_AMP_MUTE : 0;
7686         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7687                                  HDA_AMP_MUTE, bits);
7688 }
7689
7690 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
7691                                                   unsigned int res)
7692 {
7693         if ((res >> 26) == ALC880_HP_EVENT)
7694                 alc883_2ch_fujitsu_pi2515_automute(codec);
7695 }
7696
7697 static void alc883_haier_w66_automute(struct hda_codec *codec)
7698 {
7699         unsigned int present;
7700         unsigned char bits;
7701
7702         present = snd_hda_codec_read(codec, 0x1b, 0,
7703                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7704         bits = present ? 0x80 : 0;
7705         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7706                                  0x80, bits);
7707 }
7708
7709 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
7710                                          unsigned int res)
7711 {
7712         if ((res >> 26) == ALC880_HP_EVENT)
7713                 alc883_haier_w66_automute(codec);
7714 }
7715
7716 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
7717 {
7718         unsigned int present;
7719         unsigned char bits;
7720
7721         present = snd_hda_codec_read(codec, 0x14, 0,
7722                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7723         bits = present ? HDA_AMP_MUTE : 0;
7724         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7725                                  HDA_AMP_MUTE, bits);
7726 }
7727
7728 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
7729 {
7730         unsigned int present;
7731         unsigned char bits;
7732
7733         present = snd_hda_codec_read(codec, 0x1b, 0,
7734                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7735         bits = present ? HDA_AMP_MUTE : 0;
7736         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7737                                  HDA_AMP_MUTE, bits);
7738         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7739                                  HDA_AMP_MUTE, bits);
7740 }
7741
7742 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
7743                                            unsigned int res)
7744 {
7745         if ((res >> 26) == ALC880_HP_EVENT)
7746                 alc883_lenovo_101e_all_automute(codec);
7747         if ((res >> 26) == ALC880_FRONT_EVENT)
7748                 alc883_lenovo_101e_ispeaker_automute(codec);
7749 }
7750
7751 /* toggle speaker-output according to the hp-jack state */
7752 static void alc883_acer_aspire_automute(struct hda_codec *codec)
7753 {
7754         unsigned int present;
7755
7756         present = snd_hda_codec_read(codec, 0x14, 0,
7757                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7758         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7759                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7760         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7761                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7762 }
7763
7764 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
7765                                            unsigned int res)
7766 {
7767         if ((res >> 26) == ALC880_HP_EVENT)
7768                 alc883_acer_aspire_automute(codec);
7769 }
7770
7771 static struct hda_verb alc883_acer_eapd_verbs[] = {
7772         /* HP Pin: output 0 (0x0c) */
7773         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7774         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7775         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7776         /* Front Pin: output 0 (0x0c) */
7777         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7778         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7779         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7780         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
7781         /* eanable EAPD on medion laptop */
7782         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7783         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
7784         /* enable unsolicited event */
7785         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7786         { }
7787 };
7788
7789 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
7790 {
7791         unsigned int present;
7792
7793         present = snd_hda_codec_read(codec, 0x1b, 0,
7794                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7795         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7796                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7797         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7798                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7799         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7800                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7801         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7802                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7803 }
7804
7805 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
7806                                              unsigned int res)
7807 {
7808         switch (res >> 26) {
7809         case ALC880_HP_EVENT:
7810                 printk("hp_event\n");
7811                 alc888_6st_dell_front_automute(codec);
7812                 break;
7813         }
7814 }
7815
7816 /*
7817  * generic initialization of ADC, input mixers and output mixers
7818  */
7819 static struct hda_verb alc883_auto_init_verbs[] = {
7820         /*
7821          * Unmute ADC0-2 and set the default input to mic-in
7822          */
7823         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7824         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7825         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7826         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7827
7828         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7829          * mixer widget
7830          * Note: PASD motherboards uses the Line In 2 as the input for
7831          * front panel mic (mic 2)
7832          */
7833         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7834         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7835         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7836         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7837         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7838         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7839
7840         /*
7841          * Set up output mixers (0x0c - 0x0f)
7842          */
7843         /* set vol=0 to output mixers */
7844         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7845         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7846         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7847         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7848         /* set up input amps for analog loopback */
7849         /* Amp Indices: DAC = 0, mixer = 1 */
7850         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7851         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7852         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7853         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7854         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7855         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7856         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7857         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7858         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7859         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7860
7861         /* FIXME: use matrix-type input source selection */
7862         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7863         /* Input mixer1 */
7864         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7865         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7866         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7867         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7868         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7869         /* Input mixer2 */
7870         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7871         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7872         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7873         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7874         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7875
7876         { }
7877 };
7878
7879 /* capture mixer elements */
7880 static struct snd_kcontrol_new alc883_capture_mixer[] = {
7881         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7882         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7883         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7884         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7885         {
7886                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7887                 /* The multiple "Capture Source" controls confuse alsamixer
7888                  * So call somewhat different..
7889                  */
7890                 /* .name = "Capture Source", */
7891                 .name = "Input Source",
7892                 .count = 2,
7893                 .info = alc882_mux_enum_info,
7894                 .get = alc882_mux_enum_get,
7895                 .put = alc882_mux_enum_put,
7896         },
7897         { } /* end */
7898 };
7899
7900 #ifdef CONFIG_SND_HDA_POWER_SAVE
7901 #define alc883_loopbacks        alc880_loopbacks
7902 #endif
7903
7904 /* pcm configuration: identiacal with ALC880 */
7905 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
7906 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
7907 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
7908 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
7909 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
7910
7911 /*
7912  * configuration and preset
7913  */
7914 static const char *alc883_models[ALC883_MODEL_LAST] = {
7915         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
7916         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
7917         [ALC883_3ST_6ch]        = "3stack-6ch",
7918         [ALC883_6ST_DIG]        = "6stack-dig",
7919         [ALC883_TARGA_DIG]      = "targa-dig",
7920         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
7921         [ALC883_ACER]           = "acer",
7922         [ALC883_ACER_ASPIRE]    = "acer-aspire",
7923         [ALC883_MEDION]         = "medion",
7924         [ALC883_MEDION_MD2]     = "medion-md2",
7925         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
7926         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
7927         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
7928         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
7929         [ALC883_HAIER_W66]      = "haier-w66",
7930         [ALC888_3ST_HP]         = "3stack-hp",
7931         [ALC888_6ST_DELL]       = "6stack-dell",
7932         [ALC883_MITAC]          = "mitac",
7933         [ALC883_CLEVO_M720]     = "clevo-m720",
7934         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
7935         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
7936         [ALC883_AUTO]           = "auto",
7937 };
7938
7939 static struct snd_pci_quirk alc883_cfg_tbl[] = {
7940         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
7941         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
7942         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
7943         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
7944         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
7945         SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
7946         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
7947         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
7948         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
7949         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
7950         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
7951         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
7952         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
7953         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
7954         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
7955         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
7956         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
7957         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
7958         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
7959         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
7960         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
7961         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
7962         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
7963         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
7964         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
7965         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
7966         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
7967         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
7968         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
7969         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
7970         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
7971         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
7972         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
7973         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
7974         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
7975         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
7976         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
7977         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
7978         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
7979         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
7980         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
7981         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
7982         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
7983         SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
7984         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
7985         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
7986         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
7987         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
7988         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7989         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7990         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7991         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
7992         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
7993         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
7994         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
7995         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
7996         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
7997         {}
7998 };
7999
8000 static struct alc_config_preset alc883_presets[] = {
8001         [ALC883_3ST_2ch_DIG] = {
8002                 .mixers = { alc883_3ST_2ch_mixer },
8003                 .init_verbs = { alc883_init_verbs },
8004                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8005                 .dac_nids = alc883_dac_nids,
8006                 .dig_out_nid = ALC883_DIGOUT_NID,
8007                 .dig_in_nid = ALC883_DIGIN_NID,
8008                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8009                 .channel_mode = alc883_3ST_2ch_modes,
8010                 .input_mux = &alc883_capture_source,
8011         },
8012         [ALC883_3ST_6ch_DIG] = {
8013                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8014                 .init_verbs = { alc883_init_verbs },
8015                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8016                 .dac_nids = alc883_dac_nids,
8017                 .dig_out_nid = ALC883_DIGOUT_NID,
8018                 .dig_in_nid = ALC883_DIGIN_NID,
8019                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8020                 .channel_mode = alc883_3ST_6ch_modes,
8021                 .need_dac_fix = 1,
8022                 .input_mux = &alc883_capture_source,
8023         },
8024         [ALC883_3ST_6ch] = {
8025                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8026                 .init_verbs = { alc883_init_verbs },
8027                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8028                 .dac_nids = alc883_dac_nids,
8029                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8030                 .channel_mode = alc883_3ST_6ch_modes,
8031                 .need_dac_fix = 1,
8032                 .input_mux = &alc883_capture_source,
8033         },
8034         [ALC883_3ST_6ch_INTEL] = {
8035                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8036                 .init_verbs = { alc883_init_verbs },
8037                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8038                 .dac_nids = alc883_dac_nids,
8039                 .dig_out_nid = ALC883_DIGOUT_NID,
8040                 .dig_in_nid = ALC883_DIGIN_NID,
8041                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8042                 .channel_mode = alc883_3ST_6ch_intel_modes,
8043                 .need_dac_fix = 1,
8044                 .input_mux = &alc883_3stack_6ch_intel,
8045         },
8046         [ALC883_6ST_DIG] = {
8047                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8048                 .init_verbs = { alc883_init_verbs },
8049                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8050                 .dac_nids = alc883_dac_nids,
8051                 .dig_out_nid = ALC883_DIGOUT_NID,
8052                 .dig_in_nid = ALC883_DIGIN_NID,
8053                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8054                 .channel_mode = alc883_sixstack_modes,
8055                 .input_mux = &alc883_capture_source,
8056         },
8057         [ALC883_TARGA_DIG] = {
8058                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8059                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8060                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8061                 .dac_nids = alc883_dac_nids,
8062                 .dig_out_nid = ALC883_DIGOUT_NID,
8063                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8064                 .channel_mode = alc883_3ST_6ch_modes,
8065                 .need_dac_fix = 1,
8066                 .input_mux = &alc883_capture_source,
8067                 .unsol_event = alc883_tagra_unsol_event,
8068                 .init_hook = alc883_tagra_automute,
8069         },
8070         [ALC883_TARGA_2ch_DIG] = {
8071                 .mixers = { alc883_tagra_2ch_mixer},
8072                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8073                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8074                 .dac_nids = alc883_dac_nids,
8075                 .dig_out_nid = ALC883_DIGOUT_NID,
8076                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8077                 .channel_mode = alc883_3ST_2ch_modes,
8078                 .input_mux = &alc883_capture_source,
8079                 .unsol_event = alc883_tagra_unsol_event,
8080                 .init_hook = alc883_tagra_automute,
8081         },
8082         [ALC883_ACER] = {
8083                 .mixers = { alc883_base_mixer },
8084                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8085                  * and the headphone jack.  Turn this on and rely on the
8086                  * standard mute methods whenever the user wants to turn
8087                  * these outputs off.
8088                  */
8089                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8090                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8091                 .dac_nids = alc883_dac_nids,
8092                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8093                 .channel_mode = alc883_3ST_2ch_modes,
8094                 .input_mux = &alc883_capture_source,
8095         },
8096         [ALC883_ACER_ASPIRE] = {
8097                 .mixers = { alc883_acer_aspire_mixer },
8098                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8099                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8100                 .dac_nids = alc883_dac_nids,
8101                 .dig_out_nid = ALC883_DIGOUT_NID,
8102                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8103                 .channel_mode = alc883_3ST_2ch_modes,
8104                 .input_mux = &alc883_capture_source,
8105                 .unsol_event = alc883_acer_aspire_unsol_event,
8106                 .init_hook = alc883_acer_aspire_automute,
8107         },
8108         [ALC883_MEDION] = {
8109                 .mixers = { alc883_fivestack_mixer,
8110                             alc883_chmode_mixer },
8111                 .init_verbs = { alc883_init_verbs,
8112                                 alc883_medion_eapd_verbs },
8113                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8114                 .dac_nids = alc883_dac_nids,
8115                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8116                 .channel_mode = alc883_sixstack_modes,
8117                 .input_mux = &alc883_capture_source,
8118         },
8119         [ALC883_MEDION_MD2] = {
8120                 .mixers = { alc883_medion_md2_mixer},
8121                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8122                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8123                 .dac_nids = alc883_dac_nids,
8124                 .dig_out_nid = ALC883_DIGOUT_NID,
8125                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8126                 .channel_mode = alc883_3ST_2ch_modes,
8127                 .input_mux = &alc883_capture_source,
8128                 .unsol_event = alc883_medion_md2_unsol_event,
8129                 .init_hook = alc883_medion_md2_automute,
8130         },
8131         [ALC883_LAPTOP_EAPD] = {
8132                 .mixers = { alc883_base_mixer },
8133                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8134                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8135                 .dac_nids = alc883_dac_nids,
8136                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8137                 .channel_mode = alc883_3ST_2ch_modes,
8138                 .input_mux = &alc883_capture_source,
8139         },
8140         [ALC883_CLEVO_M720] = {
8141                 .mixers = { alc883_clevo_m720_mixer },
8142                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8143                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8144                 .dac_nids = alc883_dac_nids,
8145                 .dig_out_nid = ALC883_DIGOUT_NID,
8146                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8147                 .channel_mode = alc883_3ST_2ch_modes,
8148                 .input_mux = &alc883_capture_source,
8149                 .unsol_event = alc883_clevo_m720_unsol_event,
8150                 .init_hook = alc883_clevo_m720_automute,
8151         },
8152         [ALC883_LENOVO_101E_2ch] = {
8153                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8154                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8155                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8156                 .dac_nids = alc883_dac_nids,
8157                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8158                 .channel_mode = alc883_3ST_2ch_modes,
8159                 .input_mux = &alc883_lenovo_101e_capture_source,
8160                 .unsol_event = alc883_lenovo_101e_unsol_event,
8161                 .init_hook = alc883_lenovo_101e_all_automute,
8162         },
8163         [ALC883_LENOVO_NB0763] = {
8164                 .mixers = { alc883_lenovo_nb0763_mixer },
8165                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8166                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8167                 .dac_nids = alc883_dac_nids,
8168                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8169                 .channel_mode = alc883_3ST_2ch_modes,
8170                 .need_dac_fix = 1,
8171                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8172                 .unsol_event = alc883_medion_md2_unsol_event,
8173                 .init_hook = alc883_medion_md2_automute,
8174         },
8175         [ALC888_LENOVO_MS7195_DIG] = {
8176                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8177                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8178                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8179                 .dac_nids = alc883_dac_nids,
8180                 .dig_out_nid = ALC883_DIGOUT_NID,
8181                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8182                 .channel_mode = alc883_3ST_6ch_modes,
8183                 .need_dac_fix = 1,
8184                 .input_mux = &alc883_capture_source,
8185                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8186                 .init_hook = alc888_lenovo_ms7195_front_automute,
8187         },
8188         [ALC883_HAIER_W66] = {
8189                 .mixers = { alc883_tagra_2ch_mixer},
8190                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8191                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8192                 .dac_nids = alc883_dac_nids,
8193                 .dig_out_nid = ALC883_DIGOUT_NID,
8194                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8195                 .channel_mode = alc883_3ST_2ch_modes,
8196                 .input_mux = &alc883_capture_source,
8197                 .unsol_event = alc883_haier_w66_unsol_event,
8198                 .init_hook = alc883_haier_w66_automute,
8199         },
8200         [ALC888_3ST_HP] = {
8201                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8202                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8203                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8204                 .dac_nids = alc883_dac_nids,
8205                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8206                 .channel_mode = alc888_3st_hp_modes,
8207                 .need_dac_fix = 1,
8208                 .input_mux = &alc883_capture_source,
8209         },
8210         [ALC888_6ST_DELL] = {
8211                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8212                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8213                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8214                 .dac_nids = alc883_dac_nids,
8215                 .dig_out_nid = ALC883_DIGOUT_NID,
8216                 .dig_in_nid = ALC883_DIGIN_NID,
8217                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8218                 .channel_mode = alc883_sixstack_modes,
8219                 .input_mux = &alc883_capture_source,
8220                 .unsol_event = alc888_6st_dell_unsol_event,
8221                 .init_hook = alc888_6st_dell_front_automute,
8222         },
8223         [ALC883_MITAC] = {
8224                 .mixers = { alc883_mitac_mixer },
8225                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8226                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8227                 .dac_nids = alc883_dac_nids,
8228                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8229                 .channel_mode = alc883_3ST_2ch_modes,
8230                 .input_mux = &alc883_capture_source,
8231                 .unsol_event = alc883_mitac_unsol_event,
8232                 .init_hook = alc883_mitac_automute,
8233         },
8234         [ALC883_FUJITSU_PI2515] = {
8235                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8236                 .init_verbs = { alc883_init_verbs,
8237                                 alc883_2ch_fujitsu_pi2515_verbs},
8238                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8239                 .dac_nids = alc883_dac_nids,
8240                 .dig_out_nid = ALC883_DIGOUT_NID,
8241                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8242                 .channel_mode = alc883_3ST_2ch_modes,
8243                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8244                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8245                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8246         },
8247 };
8248
8249
8250 /*
8251  * BIOS auto configuration
8252  */
8253 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8254                                               hda_nid_t nid, int pin_type,
8255                                               int dac_idx)
8256 {
8257         /* set as output */
8258         struct alc_spec *spec = codec->spec;
8259         int idx;
8260
8261         alc_set_pin_output(codec, nid, pin_type);
8262         if (spec->multiout.dac_nids[dac_idx] == 0x25)
8263                 idx = 4;
8264         else
8265                 idx = spec->multiout.dac_nids[dac_idx] - 2;
8266         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8267
8268 }
8269
8270 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8271 {
8272         struct alc_spec *spec = codec->spec;
8273         int i;
8274
8275         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8276         for (i = 0; i <= HDA_SIDE; i++) {
8277                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8278                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8279                 if (nid)
8280                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8281                                                           i);
8282         }
8283 }
8284
8285 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8286 {
8287         struct alc_spec *spec = codec->spec;
8288         hda_nid_t pin;
8289
8290         pin = spec->autocfg.hp_pins[0];
8291         if (pin) /* connect to front */
8292                 /* use dac 0 */
8293                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8294         pin = spec->autocfg.speaker_pins[0];
8295         if (pin)
8296                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8297 }
8298
8299 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
8300 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
8301
8302 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8303 {
8304         struct alc_spec *spec = codec->spec;
8305         int i;
8306
8307         for (i = 0; i < AUTO_PIN_LAST; i++) {
8308                 hda_nid_t nid = spec->autocfg.input_pins[i];
8309                 if (alc883_is_input_pin(nid)) {
8310                         snd_hda_codec_write(codec, nid, 0,
8311                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
8312                                             (i <= AUTO_PIN_FRONT_MIC ?
8313                                              PIN_VREF80 : PIN_IN));
8314                         if (nid != ALC883_PIN_CD_NID)
8315                                 snd_hda_codec_write(codec, nid, 0,
8316                                                     AC_VERB_SET_AMP_GAIN_MUTE,
8317                                                     AMP_OUT_MUTE);
8318                 }
8319         }
8320 }
8321
8322 #define alc883_auto_init_input_src      alc882_auto_init_input_src
8323
8324 /* almost identical with ALC880 parser... */
8325 static int alc883_parse_auto_config(struct hda_codec *codec)
8326 {
8327         struct alc_spec *spec = codec->spec;
8328         int err = alc880_parse_auto_config(codec);
8329
8330         if (err < 0)
8331                 return err;
8332         else if (!err)
8333                 return 0; /* no config found */
8334
8335         err = alc_auto_add_mic_boost(codec);
8336         if (err < 0)
8337                 return err;
8338
8339         /* hack - override the init verbs */
8340         spec->init_verbs[0] = alc883_auto_init_verbs;
8341         spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8342         spec->num_mixers++;
8343
8344         return 1; /* config found */
8345 }
8346
8347 /* additional initialization for auto-configuration model */
8348 static void alc883_auto_init(struct hda_codec *codec)
8349 {
8350         struct alc_spec *spec = codec->spec;
8351         alc883_auto_init_multi_out(codec);
8352         alc883_auto_init_hp_out(codec);
8353         alc883_auto_init_analog_input(codec);
8354         alc883_auto_init_input_src(codec);
8355         if (spec->unsol_event)
8356                 alc_sku_automute(codec);
8357 }
8358
8359 static int patch_alc883(struct hda_codec *codec)
8360 {
8361         struct alc_spec *spec;
8362         int err, board_config;
8363
8364         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8365         if (spec == NULL)
8366                 return -ENOMEM;
8367
8368         codec->spec = spec;
8369
8370         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8371
8372         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8373                                                   alc883_models,
8374                                                   alc883_cfg_tbl);
8375         if (board_config < 0) {
8376                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8377                        "trying auto-probe from BIOS...\n");
8378                 board_config = ALC883_AUTO;
8379         }
8380
8381         if (board_config == ALC883_AUTO) {
8382                 /* automatic parse from the BIOS config */
8383                 err = alc883_parse_auto_config(codec);
8384                 if (err < 0) {
8385                         alc_free(codec);
8386                         return err;
8387                 } else if (!err) {
8388                         printk(KERN_INFO
8389                                "hda_codec: Cannot set up configuration "
8390                                "from BIOS.  Using base mode...\n");
8391                         board_config = ALC883_3ST_2ch_DIG;
8392                 }
8393         }
8394
8395         if (board_config != ALC883_AUTO)
8396                 setup_preset(spec, &alc883_presets[board_config]);
8397
8398         switch (codec->vendor_id) {
8399         case 0x10ec0888:
8400                 spec->stream_name_analog = "ALC888 Analog";
8401                 spec->stream_name_digital = "ALC888 Digital";
8402                 break;
8403         case 0x10ec0889:
8404                 spec->stream_name_analog = "ALC889 Analog";
8405                 spec->stream_name_digital = "ALC889 Digital";
8406                 break;
8407         default:
8408                 spec->stream_name_analog = "ALC883 Analog";
8409                 spec->stream_name_digital = "ALC883 Digital";
8410                 break;
8411         }
8412
8413         spec->stream_analog_playback = &alc883_pcm_analog_playback;
8414         spec->stream_analog_capture = &alc883_pcm_analog_capture;
8415         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8416
8417         spec->stream_digital_playback = &alc883_pcm_digital_playback;
8418         spec->stream_digital_capture = &alc883_pcm_digital_capture;
8419
8420         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8421         spec->adc_nids = alc883_adc_nids;
8422         spec->capsrc_nids = alc883_capsrc_nids;
8423
8424         spec->vmaster_nid = 0x0c;
8425
8426         codec->patch_ops = alc_patch_ops;
8427         if (board_config == ALC883_AUTO)
8428                 spec->init_hook = alc883_auto_init;
8429         else if (codec->vendor_id == 0x10ec0888)
8430                 spec->init_hook = alc888_coef_init;
8431
8432 #ifdef CONFIG_SND_HDA_POWER_SAVE
8433         if (!spec->loopback.amplist)
8434                 spec->loopback.amplist = alc883_loopbacks;
8435 #endif
8436
8437         return 0;
8438 }
8439
8440 /*
8441  * ALC262 support
8442  */
8443
8444 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
8445 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
8446
8447 #define alc262_dac_nids         alc260_dac_nids
8448 #define alc262_adc_nids         alc882_adc_nids
8449 #define alc262_adc_nids_alt     alc882_adc_nids_alt
8450 #define alc262_capsrc_nids      alc882_capsrc_nids
8451 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
8452
8453 #define alc262_modes            alc260_modes
8454 #define alc262_capture_source   alc882_capture_source
8455
8456 static struct snd_kcontrol_new alc262_base_mixer[] = {
8457         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8458         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8459         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8460         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8461         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8462         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8463         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8464         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8465         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8466         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8467         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8468         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8469         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8470            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8471         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8472         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8473         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8474         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8475         { } /* end */
8476 };
8477
8478 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8479         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8480         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8481         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8482         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8483         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8484         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8485         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8486         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8487         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8488         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8489         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8490         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8491         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8492            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8493         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8494         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8495         { } /* end */
8496 };
8497
8498 /* update HP, line and mono-out pins according to the master switch */
8499 static void alc262_hp_master_update(struct hda_codec *codec)
8500 {
8501         struct alc_spec *spec = codec->spec;
8502         int val = spec->master_sw;
8503
8504         /* HP & line-out */
8505         snd_hda_codec_write_cache(codec, 0x1b, 0,
8506                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8507                                   val ? PIN_HP : 0);
8508         snd_hda_codec_write_cache(codec, 0x15, 0,
8509                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8510                                   val ? PIN_HP : 0);
8511         /* mono (speaker) depending on the HP jack sense */
8512         val = val && !spec->jack_present;
8513         snd_hda_codec_write_cache(codec, 0x16, 0,
8514                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8515                                   val ? PIN_OUT : 0);
8516 }
8517
8518 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8519 {
8520         struct alc_spec *spec = codec->spec;
8521         unsigned int presence;
8522         presence = snd_hda_codec_read(codec, 0x1b, 0,
8523                                       AC_VERB_GET_PIN_SENSE, 0);
8524         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8525         alc262_hp_master_update(codec);
8526 }
8527
8528 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8529 {
8530         if ((res >> 26) != ALC880_HP_EVENT)
8531                 return;
8532         alc262_hp_bpc_automute(codec);
8533 }
8534
8535 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8536 {
8537         struct alc_spec *spec = codec->spec;
8538         unsigned int presence;
8539         presence = snd_hda_codec_read(codec, 0x15, 0,
8540                                       AC_VERB_GET_PIN_SENSE, 0);
8541         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8542         alc262_hp_master_update(codec);
8543 }
8544
8545 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8546                                            unsigned int res)
8547 {
8548         if ((res >> 26) != ALC880_HP_EVENT)
8549                 return;
8550         alc262_hp_wildwest_automute(codec);
8551 }
8552
8553 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
8554                                    struct snd_ctl_elem_value *ucontrol)
8555 {
8556         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8557         struct alc_spec *spec = codec->spec;
8558         *ucontrol->value.integer.value = spec->master_sw;
8559         return 0;
8560 }
8561
8562 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
8563                                    struct snd_ctl_elem_value *ucontrol)
8564 {
8565         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8566         struct alc_spec *spec = codec->spec;
8567         int val = !!*ucontrol->value.integer.value;
8568
8569         if (val == spec->master_sw)
8570                 return 0;
8571         spec->master_sw = val;
8572         alc262_hp_master_update(codec);
8573         return 1;
8574 }
8575
8576 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
8577         {
8578                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8579                 .name = "Master Playback Switch",
8580                 .info = snd_ctl_boolean_mono_info,
8581                 .get = alc262_hp_master_sw_get,
8582                 .put = alc262_hp_master_sw_put,
8583         },
8584         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8585         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8586         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8587         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8588                               HDA_OUTPUT),
8589         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8590                             HDA_OUTPUT),
8591         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8592         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8593         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8594         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8595         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8596         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8597         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8598         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8599         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8600         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8601         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8602         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8603         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
8604         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
8605         { } /* end */
8606 };
8607
8608 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
8609         {
8610                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8611                 .name = "Master Playback Switch",
8612                 .info = snd_ctl_boolean_mono_info,
8613                 .get = alc262_hp_master_sw_get,
8614                 .put = alc262_hp_master_sw_put,
8615         },
8616         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8617         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8618         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8619         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8620         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8621                               HDA_OUTPUT),
8622         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8623                             HDA_OUTPUT),
8624         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
8625         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
8626         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
8627         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8628         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8629         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8630         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8631         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8632         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8633         { } /* end */
8634 };
8635
8636 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
8637         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8638         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8639         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
8640         { } /* end */
8641 };
8642
8643 /* mute/unmute internal speaker according to the hp jack and mute state */
8644 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
8645 {
8646         struct alc_spec *spec = codec->spec;
8647
8648         if (force || !spec->sense_updated) {
8649                 unsigned int present;
8650                 present = snd_hda_codec_read(codec, 0x15, 0,
8651                                              AC_VERB_GET_PIN_SENSE, 0);
8652                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
8653                 spec->sense_updated = 1;
8654         }
8655         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
8656                                  spec->jack_present ? HDA_AMP_MUTE : 0);
8657 }
8658
8659 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
8660                                         unsigned int res)
8661 {
8662         if ((res >> 26) != ALC880_HP_EVENT)
8663                 return;
8664         alc262_hp_t5735_automute(codec, 1);
8665 }
8666
8667 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
8668 {
8669         alc262_hp_t5735_automute(codec, 1);
8670 }
8671
8672 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
8673         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8674         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8675         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8676         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8677         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8678         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8679         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8680         { } /* end */
8681 };
8682
8683 static struct hda_verb alc262_hp_t5735_verbs[] = {
8684         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8685         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8686
8687         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8688         { }
8689 };
8690
8691 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
8692         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8693         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8694         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8695         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8696         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8697         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8698         { } /* end */
8699 };
8700
8701 static struct hda_verb alc262_hp_rp5700_verbs[] = {
8702         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8703         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8704         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8705         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8706         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8707         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8708         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8709         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8710         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8711         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8712         {}
8713 };
8714
8715 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
8716         .num_items = 1,
8717         .items = {
8718                 { "Line", 0x1 },
8719         },
8720 };
8721
8722 /* bind hp and internal speaker mute (with plug check) */
8723 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
8724                                      struct snd_ctl_elem_value *ucontrol)
8725 {
8726         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8727         long *valp = ucontrol->value.integer.value;
8728         int change;
8729
8730         /* change hp mute */
8731         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
8732                                           HDA_AMP_MUTE,
8733                                           valp[0] ? 0 : HDA_AMP_MUTE);
8734         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
8735                                            HDA_AMP_MUTE,
8736                                            valp[1] ? 0 : HDA_AMP_MUTE);
8737         if (change) {
8738                 /* change speaker according to HP jack state */
8739                 struct alc_spec *spec = codec->spec;
8740                 unsigned int mute;
8741                 if (spec->jack_present)
8742                         mute = HDA_AMP_MUTE;
8743                 else
8744                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
8745                                                       HDA_OUTPUT, 0);
8746                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8747                                          HDA_AMP_MUTE, mute);
8748         }
8749         return change;
8750 }
8751
8752 static struct snd_kcontrol_new alc262_sony_mixer[] = {
8753         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8754         {
8755                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8756                 .name = "Master Playback Switch",
8757                 .info = snd_hda_mixer_amp_switch_info,
8758                 .get = snd_hda_mixer_amp_switch_get,
8759                 .put = alc262_sony_master_sw_put,
8760                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
8761         },
8762         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8763         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8764         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8765         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8766         { } /* end */
8767 };
8768
8769 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
8770         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8771         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8772         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8773         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8774         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8775         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8776         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8777         { } /* end */
8778 };
8779
8780 #define alc262_capture_mixer            alc882_capture_mixer
8781 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
8782
8783 /*
8784  * generic initialization of ADC, input mixers and output mixers
8785  */
8786 static struct hda_verb alc262_init_verbs[] = {
8787         /*
8788          * Unmute ADC0-2 and set the default input to mic-in
8789          */
8790         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8791         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8792         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8793         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8794         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8795         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8796
8797         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8798          * mixer widget
8799          * Note: PASD motherboards uses the Line In 2 as the input for
8800          * front panel mic (mic 2)
8801          */
8802         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8803         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8804         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8805         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8806         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8807         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8808
8809         /*
8810          * Set up output mixers (0x0c - 0x0e)
8811          */
8812         /* set vol=0 to output mixers */
8813         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8814         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8815         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8816         /* set up input amps for analog loopback */
8817         /* Amp Indices: DAC = 0, mixer = 1 */
8818         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8819         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8820         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8821         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8822         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8823         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8824
8825         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8826         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8827         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8828         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8829         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8830         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8831
8832         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8833         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8834         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8835         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8836         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8837
8838         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8839         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8840
8841         /* FIXME: use matrix-type input source selection */
8842         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8843         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8844         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8845         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8846         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8847         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8848         /* Input mixer2 */
8849         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8850         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8851         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8852         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8853         /* Input mixer3 */
8854         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8855         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8856         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8857         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8858
8859         { }
8860 };
8861
8862 static struct hda_verb alc262_hippo_unsol_verbs[] = {
8863         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8864         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8865         {}
8866 };
8867
8868 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
8869         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8870         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8871         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8872
8873         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8874         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8875         {}
8876 };
8877
8878 static struct hda_verb alc262_sony_unsol_verbs[] = {
8879         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8880         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8881         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
8882
8883         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8884         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8885         {}
8886 };
8887
8888 /* mute/unmute internal speaker according to the hp jack and mute state */
8889 static void alc262_hippo_automute(struct hda_codec *codec)
8890 {
8891         struct alc_spec *spec = codec->spec;
8892         unsigned int mute;
8893         unsigned int present;
8894
8895         /* need to execute and sync at first */
8896         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
8897         present = snd_hda_codec_read(codec, 0x15, 0,
8898                                      AC_VERB_GET_PIN_SENSE, 0);
8899         spec->jack_present = (present & 0x80000000) != 0;
8900         if (spec->jack_present) {
8901                 /* mute internal speaker */
8902                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8903                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8904         } else {
8905                 /* unmute internal speaker if necessary */
8906                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
8907                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8908                                          HDA_AMP_MUTE, mute);
8909         }
8910 }
8911
8912 /* unsolicited event for HP jack sensing */
8913 static void alc262_hippo_unsol_event(struct hda_codec *codec,
8914                                        unsigned int res)
8915 {
8916         if ((res >> 26) != ALC880_HP_EVENT)
8917                 return;
8918         alc262_hippo_automute(codec);
8919 }
8920
8921 static void alc262_hippo1_automute(struct hda_codec *codec)
8922 {
8923         unsigned int mute;
8924         unsigned int present;
8925
8926         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8927         present = snd_hda_codec_read(codec, 0x1b, 0,
8928                                      AC_VERB_GET_PIN_SENSE, 0);
8929         present = (present & 0x80000000) != 0;
8930         if (present) {
8931                 /* mute internal speaker */
8932                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8933                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8934         } else {
8935                 /* unmute internal speaker if necessary */
8936                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8937                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8938                                          HDA_AMP_MUTE, mute);
8939         }
8940 }
8941
8942 /* unsolicited event for HP jack sensing */
8943 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
8944                                        unsigned int res)
8945 {
8946         if ((res >> 26) != ALC880_HP_EVENT)
8947                 return;
8948         alc262_hippo1_automute(codec);
8949 }
8950
8951 /*
8952  * fujitsu model
8953  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
8954  *  0x1b = port replicator headphone out
8955  */
8956
8957 #define ALC_HP_EVENT    0x37
8958
8959 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
8960         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8961         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8962         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8963         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8964         {}
8965 };
8966
8967 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
8968         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8969         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8970         {}
8971 };
8972
8973 static struct hda_input_mux alc262_fujitsu_capture_source = {
8974         .num_items = 3,
8975         .items = {
8976                 { "Mic", 0x0 },
8977                 { "Int Mic", 0x1 },
8978                 { "CD", 0x4 },
8979         },
8980 };
8981
8982 static struct hda_input_mux alc262_HP_capture_source = {
8983         .num_items = 5,
8984         .items = {
8985                 { "Mic", 0x0 },
8986                 { "Front Mic", 0x1 },
8987                 { "Line", 0x2 },
8988                 { "CD", 0x4 },
8989                 { "AUX IN", 0x6 },
8990         },
8991 };
8992
8993 static struct hda_input_mux alc262_HP_D7000_capture_source = {
8994         .num_items = 4,
8995         .items = {
8996                 { "Mic", 0x0 },
8997                 { "Front Mic", 0x2 },
8998                 { "Line", 0x1 },
8999                 { "CD", 0x4 },
9000         },
9001 };
9002
9003 /* mute/unmute internal speaker according to the hp jacks and mute state */
9004 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9005 {
9006         struct alc_spec *spec = codec->spec;
9007         unsigned int mute;
9008
9009         if (force || !spec->sense_updated) {
9010                 unsigned int present;
9011                 /* need to execute and sync at first */
9012                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9013                 /* check laptop HP jack */
9014                 present = snd_hda_codec_read(codec, 0x14, 0,
9015                                              AC_VERB_GET_PIN_SENSE, 0);
9016                 /* need to execute and sync at first */
9017                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9018                 /* check docking HP jack */
9019                 present |= snd_hda_codec_read(codec, 0x1b, 0,
9020                                               AC_VERB_GET_PIN_SENSE, 0);
9021                 if (present & AC_PINSENSE_PRESENCE)
9022                         spec->jack_present = 1;
9023                 else
9024                         spec->jack_present = 0;
9025                 spec->sense_updated = 1;
9026         }
9027         /* unmute internal speaker only if both HPs are unplugged and
9028          * master switch is on
9029          */
9030         if (spec->jack_present)
9031                 mute = HDA_AMP_MUTE;
9032         else
9033                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9034         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9035                                  HDA_AMP_MUTE, mute);
9036 }
9037
9038 /* unsolicited event for HP jack sensing */
9039 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9040                                        unsigned int res)
9041 {
9042         if ((res >> 26) != ALC_HP_EVENT)
9043                 return;
9044         alc262_fujitsu_automute(codec, 1);
9045 }
9046
9047 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9048 {
9049         alc262_fujitsu_automute(codec, 1);
9050 }
9051
9052 /* bind volumes of both NID 0x0c and 0x0d */
9053 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9054         .ops = &snd_hda_bind_vol,
9055         .values = {
9056                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9057                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9058                 0
9059         },
9060 };
9061
9062 /* mute/unmute internal speaker according to the hp jack and mute state */
9063 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9064 {
9065         struct alc_spec *spec = codec->spec;
9066         unsigned int mute;
9067
9068         if (force || !spec->sense_updated) {
9069                 unsigned int present_int_hp;
9070                 /* need to execute and sync at first */
9071                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9072                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9073                                         AC_VERB_GET_PIN_SENSE, 0);
9074                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9075                 spec->sense_updated = 1;
9076         }
9077         if (spec->jack_present) {
9078                 /* mute internal speaker */
9079                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9080                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9081                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9082                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9083         } else {
9084                 /* unmute internal speaker if necessary */
9085                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9086                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9087                                          HDA_AMP_MUTE, mute);
9088                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9089                                          HDA_AMP_MUTE, mute);
9090         }
9091 }
9092
9093 /* unsolicited event for HP jack sensing */
9094 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9095                                        unsigned int res)
9096 {
9097         if ((res >> 26) != ALC_HP_EVENT)
9098                 return;
9099         alc262_lenovo_3000_automute(codec, 1);
9100 }
9101
9102 /* bind hp and internal speaker mute (with plug check) */
9103 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9104                                          struct snd_ctl_elem_value *ucontrol)
9105 {
9106         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9107         long *valp = ucontrol->value.integer.value;
9108         int change;
9109
9110         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9111                                                  HDA_AMP_MUTE,
9112                                                  valp ? 0 : HDA_AMP_MUTE);
9113         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9114                                                  HDA_AMP_MUTE,
9115                                                  valp ? 0 : HDA_AMP_MUTE);
9116
9117         if (change)
9118                 alc262_fujitsu_automute(codec, 0);
9119         return change;
9120 }
9121
9122 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9123         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9124         {
9125                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9126                 .name = "Master Playback Switch",
9127                 .info = snd_hda_mixer_amp_switch_info,
9128                 .get = snd_hda_mixer_amp_switch_get,
9129                 .put = alc262_fujitsu_master_sw_put,
9130                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9131         },
9132         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9133         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9134         HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9135         HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9136         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9137         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9138         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9139         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9140         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9141         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9142         { } /* end */
9143 };
9144
9145 /* bind hp and internal speaker mute (with plug check) */
9146 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9147                                          struct snd_ctl_elem_value *ucontrol)
9148 {
9149         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9150         long *valp = ucontrol->value.integer.value;
9151         int change;
9152
9153         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9154                                                  HDA_AMP_MUTE,
9155                                                  valp ? 0 : HDA_AMP_MUTE);
9156
9157         if (change)
9158                 alc262_lenovo_3000_automute(codec, 0);
9159         return change;
9160 }
9161
9162 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9163         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9164         {
9165                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9166                 .name = "Master Playback Switch",
9167                 .info = snd_hda_mixer_amp_switch_info,
9168                 .get = snd_hda_mixer_amp_switch_get,
9169                 .put = alc262_lenovo_3000_master_sw_put,
9170                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9171         },
9172         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9173         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9174         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9175         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9176         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9177         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9178         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9179         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9180         { } /* end */
9181 };
9182
9183 /* additional init verbs for Benq laptops */
9184 static struct hda_verb alc262_EAPD_verbs[] = {
9185         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9186         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
9187         {}
9188 };
9189
9190 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9191         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9192         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9193
9194         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9195         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
9196         {}
9197 };
9198
9199 /* Samsung Q1 Ultra Vista model setup */
9200 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9201         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9202         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9203         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9204         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9205         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9206         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9207         { } /* end */
9208 };
9209
9210 static struct hda_verb alc262_ultra_verbs[] = {
9211         /* output mixer */
9212         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9213         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9214         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9215         /* speaker */
9216         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9217         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9218         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9219         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9220         /* HP */
9221         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9222         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9223         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9224         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9225         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9226         /* internal mic */
9227         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9228         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9229         /* ADC, choose mic */
9230         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9231         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9232         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9233         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9234         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9235         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9236         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9237         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9238         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9239         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9240         {}
9241 };
9242
9243 /* mute/unmute internal speaker according to the hp jack and mute state */
9244 static void alc262_ultra_automute(struct hda_codec *codec)
9245 {
9246         struct alc_spec *spec = codec->spec;
9247         unsigned int mute;
9248
9249         mute = 0;
9250         /* auto-mute only when HP is used as HP */
9251         if (!spec->cur_mux[0]) {
9252                 unsigned int present;
9253                 /* need to execute and sync at first */
9254                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9255                 present = snd_hda_codec_read(codec, 0x15, 0,
9256                                              AC_VERB_GET_PIN_SENSE, 0);
9257                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9258                 if (spec->jack_present)
9259                         mute = HDA_AMP_MUTE;
9260         }
9261         /* mute/unmute internal speaker */
9262         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9263                                  HDA_AMP_MUTE, mute);
9264         /* mute/unmute HP */
9265         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9266                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9267 }
9268
9269 /* unsolicited event for HP jack sensing */
9270 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9271                                        unsigned int res)
9272 {
9273         if ((res >> 26) != ALC880_HP_EVENT)
9274                 return;
9275         alc262_ultra_automute(codec);
9276 }
9277
9278 static struct hda_input_mux alc262_ultra_capture_source = {
9279         .num_items = 2,
9280         .items = {
9281                 { "Mic", 0x1 },
9282                 { "Headphone", 0x7 },
9283         },
9284 };
9285
9286 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9287                                      struct snd_ctl_elem_value *ucontrol)
9288 {
9289         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9290         struct alc_spec *spec = codec->spec;
9291         int ret;
9292
9293         ret = alc882_mux_enum_put(kcontrol, ucontrol);
9294         if (!ret)
9295                 return 0;
9296         /* reprogram the HP pin as mic or HP according to the input source */
9297         snd_hda_codec_write_cache(codec, 0x15, 0,
9298                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9299                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9300         alc262_ultra_automute(codec); /* mute/unmute HP */
9301         return ret;
9302 }
9303
9304 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9305         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9306         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9307         {
9308                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9309                 .name = "Capture Source",
9310                 .info = alc882_mux_enum_info,
9311                 .get = alc882_mux_enum_get,
9312                 .put = alc262_ultra_mux_enum_put,
9313         },
9314         { } /* end */
9315 };
9316
9317 /* add playback controls from the parsed DAC table */
9318 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9319                                              const struct auto_pin_cfg *cfg)
9320 {
9321         hda_nid_t nid;
9322         int err;
9323
9324         spec->multiout.num_dacs = 1;    /* only use one dac */
9325         spec->multiout.dac_nids = spec->private_dac_nids;
9326         spec->multiout.dac_nids[0] = 2;
9327
9328         nid = cfg->line_out_pins[0];
9329         if (nid) {
9330                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9331                                   "Front Playback Volume",
9332                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
9333                 if (err < 0)
9334                         return err;
9335                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9336                                   "Front Playback Switch",
9337                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9338                 if (err < 0)
9339                         return err;
9340         }
9341
9342         nid = cfg->speaker_pins[0];
9343         if (nid) {
9344                 if (nid == 0x16) {
9345                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9346                                           "Speaker Playback Volume",
9347                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9348                                                               HDA_OUTPUT));
9349                         if (err < 0)
9350                                 return err;
9351                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9352                                           "Speaker Playback Switch",
9353                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9354                                                               HDA_OUTPUT));
9355                         if (err < 0)
9356                                 return err;
9357                 } else {
9358                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9359                                           "Speaker Playback Switch",
9360                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9361                                                               HDA_OUTPUT));
9362                         if (err < 0)
9363                                 return err;
9364                 }
9365         }
9366         nid = cfg->hp_pins[0];
9367         if (nid) {
9368                 /* spec->multiout.hp_nid = 2; */
9369                 if (nid == 0x16) {
9370                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9371                                           "Headphone Playback Volume",
9372                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9373                                                               HDA_OUTPUT));
9374                         if (err < 0)
9375                                 return err;
9376                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9377                                           "Headphone Playback Switch",
9378                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9379                                                               HDA_OUTPUT));
9380                         if (err < 0)
9381                                 return err;
9382                 } else {
9383                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9384                                           "Headphone Playback Switch",
9385                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9386                                                               HDA_OUTPUT));
9387                         if (err < 0)
9388                                 return err;
9389                 }
9390         }
9391         return 0;
9392 }
9393
9394 /* identical with ALC880 */
9395 #define alc262_auto_create_analog_input_ctls \
9396         alc880_auto_create_analog_input_ctls
9397
9398 /*
9399  * generic initialization of ADC, input mixers and output mixers
9400  */
9401 static struct hda_verb alc262_volume_init_verbs[] = {
9402         /*
9403          * Unmute ADC0-2 and set the default input to mic-in
9404          */
9405         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9406         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9407         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9408         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9409         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9410         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9411
9412         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9413          * mixer widget
9414          * Note: PASD motherboards uses the Line In 2 as the input for
9415          * front panel mic (mic 2)
9416          */
9417         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9418         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9419         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9420         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9421         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9422         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9423
9424         /*
9425          * Set up output mixers (0x0c - 0x0f)
9426          */
9427         /* set vol=0 to output mixers */
9428         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9429         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9430         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9431
9432         /* set up input amps for analog loopback */
9433         /* Amp Indices: DAC = 0, mixer = 1 */
9434         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9435         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9436         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9437         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9438         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9439         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9440
9441         /* FIXME: use matrix-type input source selection */
9442         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9443         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9444         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9445         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9446         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9447         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9448         /* Input mixer2 */
9449         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9450         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9451         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9452         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9453         /* Input mixer3 */
9454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9455         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9456         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9457         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9458
9459         { }
9460 };
9461
9462 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
9463         /*
9464          * Unmute ADC0-2 and set the default input to mic-in
9465          */
9466         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9467         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9468         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9469         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9470         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9471         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9472
9473         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9474          * mixer widget
9475          * Note: PASD motherboards uses the Line In 2 as the input for
9476          * front panel mic (mic 2)
9477          */
9478         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9479         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9480         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9481         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9482         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9483         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9485         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9486
9487         /*
9488          * Set up output mixers (0x0c - 0x0e)
9489          */
9490         /* set vol=0 to output mixers */
9491         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9492         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9493         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9494
9495         /* set up input amps for analog loopback */
9496         /* Amp Indices: DAC = 0, mixer = 1 */
9497         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9498         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9499         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9500         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9501         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9502         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9503
9504         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9505         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9506         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9507
9508         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9509         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9510
9511         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9512         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9513
9514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9515         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9516         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9517         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9518         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9519
9520         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9521         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9522         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9523         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9524         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9525         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9526
9527
9528         /* FIXME: use matrix-type input source selection */
9529         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9530         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9531         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9532         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9533         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9534         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9535         /* Input mixer2 */
9536         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9537         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9538         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9539         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9540         /* Input mixer3 */
9541         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9542         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9543         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9544         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9545
9546         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9547
9548         { }
9549 };
9550
9551 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
9552         /*
9553          * Unmute ADC0-2 and set the default input to mic-in
9554          */
9555         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9556         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9557         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9558         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9559         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9560         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9561
9562         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9563          * mixer widget
9564          * Note: PASD motherboards uses the Line In 2 as the input for front
9565          * panel mic (mic 2)
9566          */
9567         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9569         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9570         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9571         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9572         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9573         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9574         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9575         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9576         /*
9577          * Set up output mixers (0x0c - 0x0e)
9578          */
9579         /* set vol=0 to output mixers */
9580         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9581         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9582         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9583
9584         /* set up input amps for analog loopback */
9585         /* Amp Indices: DAC = 0, mixer = 1 */
9586         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9587         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9588         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9589         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9590         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9591         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9592
9593
9594         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
9595         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
9596         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
9597         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
9598         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
9599         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
9600         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
9601
9602         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9603         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9604
9605         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9606         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9607
9608         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
9609         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9610         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9611         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9612         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9613         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9614
9615         /* FIXME: use matrix-type input source selection */
9616         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9617         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9618         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
9619         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
9620         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
9621         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
9622         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
9623         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
9624         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
9625         /* Input mixer2 */
9626         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9627         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9628         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9629         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9630         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9631         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9632         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9633         /* Input mixer3 */
9634         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9635         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9636         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9637         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9638         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9639         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9640         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9641
9642         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9643
9644         { }
9645 };
9646
9647 #ifdef CONFIG_SND_HDA_POWER_SAVE
9648 #define alc262_loopbacks        alc880_loopbacks
9649 #endif
9650
9651 /* pcm configuration: identiacal with ALC880 */
9652 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
9653 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
9654 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
9655 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
9656
9657 /*
9658  * BIOS auto configuration
9659  */
9660 static int alc262_parse_auto_config(struct hda_codec *codec)
9661 {
9662         struct alc_spec *spec = codec->spec;
9663         int err;
9664         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
9665
9666         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9667                                            alc262_ignore);
9668         if (err < 0)
9669                 return err;
9670         if (!spec->autocfg.line_outs)
9671                 return 0; /* can't find valid BIOS pin config */
9672         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
9673         if (err < 0)
9674                 return err;
9675         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
9676         if (err < 0)
9677                 return err;
9678
9679         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9680
9681         if (spec->autocfg.dig_out_pin)
9682                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
9683         if (spec->autocfg.dig_in_pin)
9684                 spec->dig_in_nid = ALC262_DIGIN_NID;
9685
9686         if (spec->kctl_alloc)
9687                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
9688
9689         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
9690         spec->num_mux_defs = 1;
9691         spec->input_mux = &spec->private_imux;
9692
9693         err = alc_auto_add_mic_boost(codec);
9694         if (err < 0)
9695                 return err;
9696
9697         return 1;
9698 }
9699
9700 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
9701 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
9702 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
9703 #define alc262_auto_init_input_src      alc882_auto_init_input_src
9704
9705
9706 /* init callback for auto-configuration model -- overriding the default init */
9707 static void alc262_auto_init(struct hda_codec *codec)
9708 {
9709         struct alc_spec *spec = codec->spec;
9710         alc262_auto_init_multi_out(codec);
9711         alc262_auto_init_hp_out(codec);
9712         alc262_auto_init_analog_input(codec);
9713         alc262_auto_init_input_src(codec);
9714         if (spec->unsol_event)
9715                 alc_sku_automute(codec);
9716 }
9717
9718 /*
9719  * configuration and preset
9720  */
9721 static const char *alc262_models[ALC262_MODEL_LAST] = {
9722         [ALC262_BASIC]          = "basic",
9723         [ALC262_HIPPO]          = "hippo",
9724         [ALC262_HIPPO_1]        = "hippo_1",
9725         [ALC262_FUJITSU]        = "fujitsu",
9726         [ALC262_HP_BPC]         = "hp-bpc",
9727         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
9728         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
9729         [ALC262_HP_RP5700]      = "hp-rp5700",
9730         [ALC262_BENQ_ED8]       = "benq",
9731         [ALC262_BENQ_T31]       = "benq-t31",
9732         [ALC262_SONY_ASSAMD]    = "sony-assamd",
9733         [ALC262_ULTRA]          = "ultra",
9734         [ALC262_LENOVO_3000]    = "lenovo-3000",
9735         [ALC262_AUTO]           = "auto",
9736 };
9737
9738 static struct snd_pci_quirk alc262_cfg_tbl[] = {
9739         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
9740         SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
9741         SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
9742         SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
9743         SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
9744         SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
9745         SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
9746         SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
9747         SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
9748         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
9749         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
9750         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
9751         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
9752         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
9753         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
9754         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
9755         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
9756         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
9757         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
9758         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
9759         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
9760                       ALC262_HP_TC_T5735),
9761         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
9762         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9763         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
9764         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9765         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9766         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
9767         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
9768                       ALC262_SONY_ASSAMD),
9769         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
9770         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
9771         SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
9772         SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
9773         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
9774         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
9775         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
9776         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
9777         {}
9778 };
9779
9780 static struct alc_config_preset alc262_presets[] = {
9781         [ALC262_BASIC] = {
9782                 .mixers = { alc262_base_mixer },
9783                 .init_verbs = { alc262_init_verbs },
9784                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9785                 .dac_nids = alc262_dac_nids,
9786                 .hp_nid = 0x03,
9787                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9788                 .channel_mode = alc262_modes,
9789                 .input_mux = &alc262_capture_source,
9790         },
9791         [ALC262_HIPPO] = {
9792                 .mixers = { alc262_base_mixer },
9793                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
9794                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9795                 .dac_nids = alc262_dac_nids,
9796                 .hp_nid = 0x03,
9797                 .dig_out_nid = ALC262_DIGOUT_NID,
9798                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9799                 .channel_mode = alc262_modes,
9800                 .input_mux = &alc262_capture_source,
9801                 .unsol_event = alc262_hippo_unsol_event,
9802                 .init_hook = alc262_hippo_automute,
9803         },
9804         [ALC262_HIPPO_1] = {
9805                 .mixers = { alc262_hippo1_mixer },
9806                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
9807                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9808                 .dac_nids = alc262_dac_nids,
9809                 .hp_nid = 0x02,
9810                 .dig_out_nid = ALC262_DIGOUT_NID,
9811                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9812                 .channel_mode = alc262_modes,
9813                 .input_mux = &alc262_capture_source,
9814                 .unsol_event = alc262_hippo1_unsol_event,
9815                 .init_hook = alc262_hippo1_automute,
9816         },
9817         [ALC262_FUJITSU] = {
9818                 .mixers = { alc262_fujitsu_mixer },
9819                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9820                                 alc262_fujitsu_unsol_verbs },
9821                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9822                 .dac_nids = alc262_dac_nids,
9823                 .hp_nid = 0x03,
9824                 .dig_out_nid = ALC262_DIGOUT_NID,
9825                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9826                 .channel_mode = alc262_modes,
9827                 .input_mux = &alc262_fujitsu_capture_source,
9828                 .unsol_event = alc262_fujitsu_unsol_event,
9829                 .init_hook = alc262_fujitsu_init_hook,
9830         },
9831         [ALC262_HP_BPC] = {
9832                 .mixers = { alc262_HP_BPC_mixer },
9833                 .init_verbs = { alc262_HP_BPC_init_verbs },
9834                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9835                 .dac_nids = alc262_dac_nids,
9836                 .hp_nid = 0x03,
9837                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9838                 .channel_mode = alc262_modes,
9839                 .input_mux = &alc262_HP_capture_source,
9840                 .unsol_event = alc262_hp_bpc_unsol_event,
9841                 .init_hook = alc262_hp_bpc_automute,
9842         },
9843         [ALC262_HP_BPC_D7000_WF] = {
9844                 .mixers = { alc262_HP_BPC_WildWest_mixer },
9845                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9846                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9847                 .dac_nids = alc262_dac_nids,
9848                 .hp_nid = 0x03,
9849                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9850                 .channel_mode = alc262_modes,
9851                 .input_mux = &alc262_HP_D7000_capture_source,
9852                 .unsol_event = alc262_hp_wildwest_unsol_event,
9853                 .init_hook = alc262_hp_wildwest_automute,
9854         },
9855         [ALC262_HP_BPC_D7000_WL] = {
9856                 .mixers = { alc262_HP_BPC_WildWest_mixer,
9857                             alc262_HP_BPC_WildWest_option_mixer },
9858                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9859                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9860                 .dac_nids = alc262_dac_nids,
9861                 .hp_nid = 0x03,
9862                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9863                 .channel_mode = alc262_modes,
9864                 .input_mux = &alc262_HP_D7000_capture_source,
9865                 .unsol_event = alc262_hp_wildwest_unsol_event,
9866                 .init_hook = alc262_hp_wildwest_automute,
9867         },
9868         [ALC262_HP_TC_T5735] = {
9869                 .mixers = { alc262_hp_t5735_mixer },
9870                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
9871                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9872                 .dac_nids = alc262_dac_nids,
9873                 .hp_nid = 0x03,
9874                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9875                 .channel_mode = alc262_modes,
9876                 .input_mux = &alc262_capture_source,
9877                 .unsol_event = alc262_hp_t5735_unsol_event,
9878                 .init_hook = alc262_hp_t5735_init_hook,
9879         },
9880         [ALC262_HP_RP5700] = {
9881                 .mixers = { alc262_hp_rp5700_mixer },
9882                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
9883                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9884                 .dac_nids = alc262_dac_nids,
9885                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9886                 .channel_mode = alc262_modes,
9887                 .input_mux = &alc262_hp_rp5700_capture_source,
9888         },
9889         [ALC262_BENQ_ED8] = {
9890                 .mixers = { alc262_base_mixer },
9891                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
9892                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9893                 .dac_nids = alc262_dac_nids,
9894                 .hp_nid = 0x03,
9895                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9896                 .channel_mode = alc262_modes,
9897                 .input_mux = &alc262_capture_source,
9898         },
9899         [ALC262_SONY_ASSAMD] = {
9900                 .mixers = { alc262_sony_mixer },
9901                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
9902                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9903                 .dac_nids = alc262_dac_nids,
9904                 .hp_nid = 0x02,
9905                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9906                 .channel_mode = alc262_modes,
9907                 .input_mux = &alc262_capture_source,
9908                 .unsol_event = alc262_hippo_unsol_event,
9909                 .init_hook = alc262_hippo_automute,
9910         },
9911         [ALC262_BENQ_T31] = {
9912                 .mixers = { alc262_benq_t31_mixer },
9913                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
9914                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9915                 .dac_nids = alc262_dac_nids,
9916                 .hp_nid = 0x03,
9917                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9918                 .channel_mode = alc262_modes,
9919                 .input_mux = &alc262_capture_source,
9920                 .unsol_event = alc262_hippo_unsol_event,
9921                 .init_hook = alc262_hippo_automute,
9922         },
9923         [ALC262_ULTRA] = {
9924                 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
9925                 .init_verbs = { alc262_ultra_verbs },
9926                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9927                 .dac_nids = alc262_dac_nids,
9928                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9929                 .channel_mode = alc262_modes,
9930                 .input_mux = &alc262_ultra_capture_source,
9931                 .adc_nids = alc262_adc_nids, /* ADC0 */
9932                 .capsrc_nids = alc262_capsrc_nids,
9933                 .num_adc_nids = 1, /* single ADC */
9934                 .unsol_event = alc262_ultra_unsol_event,
9935                 .init_hook = alc262_ultra_automute,
9936         },
9937         [ALC262_LENOVO_3000] = {
9938                 .mixers = { alc262_lenovo_3000_mixer },
9939                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9940                                 alc262_lenovo_3000_unsol_verbs },
9941                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9942                 .dac_nids = alc262_dac_nids,
9943                 .hp_nid = 0x03,
9944                 .dig_out_nid = ALC262_DIGOUT_NID,
9945                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9946                 .channel_mode = alc262_modes,
9947                 .input_mux = &alc262_fujitsu_capture_source,
9948                 .unsol_event = alc262_lenovo_3000_unsol_event,
9949         },
9950 };
9951
9952 static int patch_alc262(struct hda_codec *codec)
9953 {
9954         struct alc_spec *spec;
9955         int board_config;
9956         int err;
9957
9958         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9959         if (spec == NULL)
9960                 return -ENOMEM;
9961
9962         codec->spec = spec;
9963 #if 0
9964         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
9965          * under-run
9966          */
9967         {
9968         int tmp;
9969         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9970         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
9971         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9972         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
9973         }
9974 #endif
9975
9976         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9977
9978         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
9979                                                   alc262_models,
9980                                                   alc262_cfg_tbl);
9981
9982         if (board_config < 0) {
9983                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
9984                        "trying auto-probe from BIOS...\n");
9985                 board_config = ALC262_AUTO;
9986         }
9987
9988         if (board_config == ALC262_AUTO) {
9989                 /* automatic parse from the BIOS config */
9990                 err = alc262_parse_auto_config(codec);
9991                 if (err < 0) {
9992                         alc_free(codec);
9993                         return err;
9994                 } else if (!err) {
9995                         printk(KERN_INFO
9996                                "hda_codec: Cannot set up configuration "
9997                                "from BIOS.  Using base mode...\n");
9998                         board_config = ALC262_BASIC;
9999                 }
10000         }
10001
10002         if (board_config != ALC262_AUTO)
10003                 setup_preset(spec, &alc262_presets[board_config]);
10004
10005         spec->stream_name_analog = "ALC262 Analog";
10006         spec->stream_analog_playback = &alc262_pcm_analog_playback;
10007         spec->stream_analog_capture = &alc262_pcm_analog_capture;
10008
10009         spec->stream_name_digital = "ALC262 Digital";
10010         spec->stream_digital_playback = &alc262_pcm_digital_playback;
10011         spec->stream_digital_capture = &alc262_pcm_digital_capture;
10012
10013         if (!spec->adc_nids && spec->input_mux) {
10014                 /* check whether NID 0x07 is valid */
10015                 unsigned int wcap = get_wcaps(codec, 0x07);
10016
10017                 /* get type */
10018                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10019                 if (wcap != AC_WID_AUD_IN) {
10020                         spec->adc_nids = alc262_adc_nids_alt;
10021                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
10022                         spec->capsrc_nids = alc262_capsrc_nids_alt;
10023                         spec->mixers[spec->num_mixers] =
10024                                 alc262_capture_alt_mixer;
10025                         spec->num_mixers++;
10026                 } else {
10027                         spec->adc_nids = alc262_adc_nids;
10028                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
10029                         spec->capsrc_nids = alc262_capsrc_nids;
10030                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
10031                         spec->num_mixers++;
10032                 }
10033         }
10034
10035         spec->vmaster_nid = 0x0c;
10036
10037         codec->patch_ops = alc_patch_ops;
10038         if (board_config == ALC262_AUTO)
10039                 spec->init_hook = alc262_auto_init;
10040 #ifdef CONFIG_SND_HDA_POWER_SAVE
10041         if (!spec->loopback.amplist)
10042                 spec->loopback.amplist = alc262_loopbacks;
10043 #endif
10044
10045         return 0;
10046 }
10047
10048 /*
10049  *  ALC268 channel source setting (2 channel)
10050  */
10051 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
10052 #define alc268_modes            alc260_modes
10053
10054 static hda_nid_t alc268_dac_nids[2] = {
10055         /* front, hp */
10056         0x02, 0x03
10057 };
10058
10059 static hda_nid_t alc268_adc_nids[2] = {
10060         /* ADC0-1 */
10061         0x08, 0x07
10062 };
10063
10064 static hda_nid_t alc268_adc_nids_alt[1] = {
10065         /* ADC0 */
10066         0x08
10067 };
10068
10069 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10070
10071 static struct snd_kcontrol_new alc268_base_mixer[] = {
10072         /* output mixer control */
10073         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10074         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10075         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10076         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10077         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10078         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10079         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10080         { }
10081 };
10082
10083 /* bind Beep switches of both NID 0x0f and 0x10 */
10084 static struct hda_bind_ctls alc268_bind_beep_sw = {
10085         .ops = &snd_hda_bind_sw,
10086         .values = {
10087                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10088                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10089                 0
10090         },
10091 };
10092
10093 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10094         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10095         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10096         { }
10097 };
10098
10099 static struct hda_verb alc268_eapd_verbs[] = {
10100         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10101         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10102         { }
10103 };
10104
10105 /* Toshiba specific */
10106 #define alc268_toshiba_automute alc262_hippo_automute
10107
10108 static struct hda_verb alc268_toshiba_verbs[] = {
10109         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10110         { } /* end */
10111 };
10112
10113 /* Acer specific */
10114 /* bind volumes of both NID 0x02 and 0x03 */
10115 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10116         .ops = &snd_hda_bind_vol,
10117         .values = {
10118                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10119                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10120                 0
10121         },
10122 };
10123
10124 /* mute/unmute internal speaker according to the hp jack and mute state */
10125 static void alc268_acer_automute(struct hda_codec *codec, int force)
10126 {
10127         struct alc_spec *spec = codec->spec;
10128         unsigned int mute;
10129
10130         if (force || !spec->sense_updated) {
10131                 unsigned int present;
10132                 present = snd_hda_codec_read(codec, 0x14, 0,
10133                                          AC_VERB_GET_PIN_SENSE, 0);
10134                 spec->jack_present = (present & 0x80000000) != 0;
10135                 spec->sense_updated = 1;
10136         }
10137         if (spec->jack_present)
10138                 mute = HDA_AMP_MUTE; /* mute internal speaker */
10139         else /* unmute internal speaker if necessary */
10140                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10141         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10142                                  HDA_AMP_MUTE, mute);
10143 }
10144
10145
10146 /* bind hp and internal speaker mute (with plug check) */
10147 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10148                                      struct snd_ctl_elem_value *ucontrol)
10149 {
10150         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10151         long *valp = ucontrol->value.integer.value;
10152         int change;
10153
10154         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10155                                           HDA_AMP_MUTE,
10156                                           valp[0] ? 0 : HDA_AMP_MUTE);
10157         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10158                                            HDA_AMP_MUTE,
10159                                            valp[1] ? 0 : HDA_AMP_MUTE);
10160         if (change)
10161                 alc268_acer_automute(codec, 0);
10162         return change;
10163 }
10164
10165 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10166         /* output mixer control */
10167         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10168         {
10169                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10170                 .name = "Master Playback Switch",
10171                 .info = snd_hda_mixer_amp_switch_info,
10172                 .get = snd_hda_mixer_amp_switch_get,
10173                 .put = alc268_acer_master_sw_put,
10174                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10175         },
10176         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10177         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10178         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10179         { }
10180 };
10181
10182 static struct hda_verb alc268_acer_verbs[] = {
10183         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10184         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10185         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10186         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10187         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10188         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10189
10190         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10191         { }
10192 };
10193
10194 /* unsolicited event for HP jack sensing */
10195 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10196                                        unsigned int res)
10197 {
10198         if ((res >> 26) != ALC880_HP_EVENT)
10199                 return;
10200         alc268_toshiba_automute(codec);
10201 }
10202
10203 static void alc268_acer_unsol_event(struct hda_codec *codec,
10204                                        unsigned int res)
10205 {
10206         if ((res >> 26) != ALC880_HP_EVENT)
10207                 return;
10208         alc268_acer_automute(codec, 1);
10209 }
10210
10211 static void alc268_acer_init_hook(struct hda_codec *codec)
10212 {
10213         alc268_acer_automute(codec, 1);
10214 }
10215
10216 static struct snd_kcontrol_new alc268_dell_mixer[] = {
10217         /* output mixer control */
10218         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10219         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10220         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10221         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10222         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10223         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10224         { }
10225 };
10226
10227 static struct hda_verb alc268_dell_verbs[] = {
10228         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10229         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10230         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10231         { }
10232 };
10233
10234 /* mute/unmute internal speaker according to the hp jack and mute state */
10235 static void alc268_dell_automute(struct hda_codec *codec)
10236 {
10237         unsigned int present;
10238         unsigned int mute;
10239
10240         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
10241         if (present & 0x80000000)
10242                 mute = HDA_AMP_MUTE;
10243         else
10244                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
10245         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10246                                  HDA_AMP_MUTE, mute);
10247 }
10248
10249 static void alc268_dell_unsol_event(struct hda_codec *codec,
10250                                     unsigned int res)
10251 {
10252         if ((res >> 26) != ALC880_HP_EVENT)
10253                 return;
10254         alc268_dell_automute(codec);
10255 }
10256
10257 #define alc268_dell_init_hook   alc268_dell_automute
10258
10259 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
10260         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10261         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10262         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10263         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10264         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10265         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
10266         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
10267         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10268         { }
10269 };
10270
10271 static struct hda_verb alc267_quanta_il1_verbs[] = {
10272         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10273         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
10274         { }
10275 };
10276
10277 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
10278 {
10279         unsigned int present;
10280
10281         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
10282                 & AC_PINSENSE_PRESENCE;
10283         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
10284                             present ? 0 : PIN_OUT);
10285 }
10286
10287 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
10288 {
10289         unsigned int present;
10290
10291         present = snd_hda_codec_read(codec, 0x18, 0,
10292                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10293         snd_hda_codec_write(codec, 0x23, 0,
10294                             AC_VERB_SET_CONNECT_SEL,
10295                             present ? 0x00 : 0x01);
10296 }
10297
10298 static void alc267_quanta_il1_automute(struct hda_codec *codec)
10299 {
10300         alc267_quanta_il1_hp_automute(codec);
10301         alc267_quanta_il1_mic_automute(codec);
10302 }
10303
10304 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
10305                                            unsigned int res)
10306 {
10307         switch (res >> 26) {
10308         case ALC880_HP_EVENT:
10309                 alc267_quanta_il1_hp_automute(codec);
10310                 break;
10311         case ALC880_MIC_EVENT:
10312                 alc267_quanta_il1_mic_automute(codec);
10313                 break;
10314         }
10315 }
10316
10317 /*
10318  * generic initialization of ADC, input mixers and output mixers
10319  */
10320 static struct hda_verb alc268_base_init_verbs[] = {
10321         /* Unmute DAC0-1 and set vol = 0 */
10322         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10323         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10324         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10325         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10326         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10327         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10328
10329         /*
10330          * Set up output mixers (0x0c - 0x0e)
10331          */
10332         /* set vol=0 to output mixers */
10333         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10334         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10335         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10336         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
10337
10338         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10339         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10340
10341         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10342         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10343         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10344         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10345         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10346         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10347         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10348         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10349
10350         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10351         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10352         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10353         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10354         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10355         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10356         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10357
10358         /* set PCBEEP vol = 0, mute connections */
10359         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10360         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10361         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10362
10363         /* Unmute Selector 23h,24h and set the default input to mic-in */
10364
10365         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
10366         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10367         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
10368         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10369
10370         { }
10371 };
10372
10373 /*
10374  * generic initialization of ADC, input mixers and output mixers
10375  */
10376 static struct hda_verb alc268_volume_init_verbs[] = {
10377         /* set output DAC */
10378         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10379         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10380         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10381         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10382
10383         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10384         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10385         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10386         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10387         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10388
10389         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10390         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10391         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10392         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10393         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10394
10395         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10396         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10397         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10398         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10399
10400         /* set PCBEEP vol = 0, mute connections */
10401         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10402         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10403         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10404
10405         { }
10406 };
10407
10408 #define alc268_mux_enum_info alc_mux_enum_info
10409 #define alc268_mux_enum_get alc_mux_enum_get
10410 #define alc268_mux_enum_put alc_mux_enum_put
10411
10412 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
10413         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10414         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
10415         {
10416                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10417                 /* The multiple "Capture Source" controls confuse alsamixer
10418                  * So call somewhat different..
10419                  */
10420                 /* .name = "Capture Source", */
10421                 .name = "Input Source",
10422                 .count = 1,
10423                 .info = alc268_mux_enum_info,
10424                 .get = alc268_mux_enum_get,
10425                 .put = alc268_mux_enum_put,
10426         },
10427         { } /* end */
10428 };
10429
10430 static struct snd_kcontrol_new alc268_capture_mixer[] = {
10431         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10432         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
10433         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
10434         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
10435         {
10436                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10437                 /* The multiple "Capture Source" controls confuse alsamixer
10438                  * So call somewhat different..
10439                  */
10440                 /* .name = "Capture Source", */
10441                 .name = "Input Source",
10442                 .count = 2,
10443                 .info = alc268_mux_enum_info,
10444                 .get = alc268_mux_enum_get,
10445                 .put = alc268_mux_enum_put,
10446         },
10447         { } /* end */
10448 };
10449
10450 static struct hda_input_mux alc268_capture_source = {
10451         .num_items = 4,
10452         .items = {
10453                 { "Mic", 0x0 },
10454                 { "Front Mic", 0x1 },
10455                 { "Line", 0x2 },
10456                 { "CD", 0x3 },
10457         },
10458 };
10459
10460 static struct hda_input_mux alc268_acer_capture_source = {
10461         .num_items = 3,
10462         .items = {
10463                 { "Mic", 0x0 },
10464                 { "Internal Mic", 0x6 },
10465                 { "Line", 0x2 },
10466         },
10467 };
10468
10469 #ifdef CONFIG_SND_DEBUG
10470 static struct snd_kcontrol_new alc268_test_mixer[] = {
10471         /* Volume widgets */
10472         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10473         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10474         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
10475         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
10476         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
10477         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
10478         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
10479         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
10480         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
10481         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
10482         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
10483         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
10484         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
10485         /* The below appears problematic on some hardwares */
10486         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
10487         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10488         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
10489         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
10490         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
10491
10492         /* Modes for retasking pin widgets */
10493         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
10494         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
10495         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
10496         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
10497
10498         /* Controls for GPIO pins, assuming they are configured as outputs */
10499         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
10500         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
10501         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
10502         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
10503
10504         /* Switches to allow the digital SPDIF output pin to be enabled.
10505          * The ALC268 does not have an SPDIF input.
10506          */
10507         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
10508
10509         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
10510          * this output to turn on an external amplifier.
10511          */
10512         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
10513         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
10514
10515         { } /* end */
10516 };
10517 #endif
10518
10519 /* create input playback/capture controls for the given pin */
10520 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
10521                                     const char *ctlname, int idx)
10522 {
10523         char name[32];
10524         int err;
10525
10526         sprintf(name, "%s Playback Volume", ctlname);
10527         if (nid == 0x14) {
10528                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
10529                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
10530                                                       HDA_OUTPUT));
10531                 if (err < 0)
10532                         return err;
10533         } else if (nid == 0x15) {
10534                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
10535                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
10536                                                       HDA_OUTPUT));
10537                 if (err < 0)
10538                         return err;
10539         } else
10540                 return -1;
10541         sprintf(name, "%s Playback Switch", ctlname);
10542         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
10543                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
10544         if (err < 0)
10545                 return err;
10546         return 0;
10547 }
10548
10549 /* add playback controls from the parsed DAC table */
10550 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
10551                                              const struct auto_pin_cfg *cfg)
10552 {
10553         hda_nid_t nid;
10554         int err;
10555
10556         spec->multiout.num_dacs = 2;    /* only use one dac */
10557         spec->multiout.dac_nids = spec->private_dac_nids;
10558         spec->multiout.dac_nids[0] = 2;
10559         spec->multiout.dac_nids[1] = 3;
10560
10561         nid = cfg->line_out_pins[0];
10562         if (nid)
10563                 alc268_new_analog_output(spec, nid, "Front", 0);
10564
10565         nid = cfg->speaker_pins[0];
10566         if (nid == 0x1d) {
10567                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10568                                   "Speaker Playback Volume",
10569                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10570                 if (err < 0)
10571                         return err;
10572         }
10573         nid = cfg->hp_pins[0];
10574         if (nid)
10575                 alc268_new_analog_output(spec, nid, "Headphone", 0);
10576
10577         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
10578         if (nid == 0x16) {
10579                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10580                                   "Mono Playback Switch",
10581                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
10582                 if (err < 0)
10583                         return err;
10584         }
10585         return 0;
10586 }
10587
10588 /* create playback/capture controls for input pins */
10589 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
10590                                                 const struct auto_pin_cfg *cfg)
10591 {
10592         struct hda_input_mux *imux = &spec->private_imux;
10593         int i, idx1;
10594
10595         for (i = 0; i < AUTO_PIN_LAST; i++) {
10596                 switch(cfg->input_pins[i]) {
10597                 case 0x18:
10598                         idx1 = 0;       /* Mic 1 */
10599                         break;
10600                 case 0x19:
10601                         idx1 = 1;       /* Mic 2 */
10602                         break;
10603                 case 0x1a:
10604                         idx1 = 2;       /* Line In */
10605                         break;
10606                 case 0x1c:
10607                         idx1 = 3;       /* CD */
10608                         break;
10609                 case 0x12:
10610                 case 0x13:
10611                         idx1 = 6;       /* digital mics */
10612                         break;
10613                 default:
10614                         continue;
10615                 }
10616                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
10617                 imux->items[imux->num_items].index = idx1;
10618                 imux->num_items++;
10619         }
10620         return 0;
10621 }
10622
10623 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
10624 {
10625         struct alc_spec *spec = codec->spec;
10626         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10627         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10628         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10629         unsigned int    dac_vol1, dac_vol2;
10630
10631         if (speaker_nid) {
10632                 snd_hda_codec_write(codec, speaker_nid, 0,
10633                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
10634                 snd_hda_codec_write(codec, 0x0f, 0,
10635                                     AC_VERB_SET_AMP_GAIN_MUTE,
10636                                     AMP_IN_UNMUTE(1));
10637                 snd_hda_codec_write(codec, 0x10, 0,
10638                                     AC_VERB_SET_AMP_GAIN_MUTE,
10639                                     AMP_IN_UNMUTE(1));
10640         } else {
10641                 snd_hda_codec_write(codec, 0x0f, 0,
10642                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
10643                 snd_hda_codec_write(codec, 0x10, 0,
10644                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
10645         }
10646
10647         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
10648         if (line_nid == 0x14)
10649                 dac_vol2 = AMP_OUT_ZERO;
10650         else if (line_nid == 0x15)
10651                 dac_vol1 = AMP_OUT_ZERO;
10652         if (hp_nid == 0x14)
10653                 dac_vol2 = AMP_OUT_ZERO;
10654         else if (hp_nid == 0x15)
10655                 dac_vol1 = AMP_OUT_ZERO;
10656         if (line_nid != 0x16 || hp_nid != 0x16 ||
10657             spec->autocfg.line_out_pins[1] != 0x16 ||
10658             spec->autocfg.line_out_pins[2] != 0x16)
10659                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
10660
10661         snd_hda_codec_write(codec, 0x02, 0,
10662                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
10663         snd_hda_codec_write(codec, 0x03, 0,
10664                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
10665 }
10666
10667 /* pcm configuration: identiacal with ALC880 */
10668 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
10669 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
10670 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
10671 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
10672
10673 /*
10674  * BIOS auto configuration
10675  */
10676 static int alc268_parse_auto_config(struct hda_codec *codec)
10677 {
10678         struct alc_spec *spec = codec->spec;
10679         int err;
10680         static hda_nid_t alc268_ignore[] = { 0 };
10681
10682         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10683                                            alc268_ignore);
10684         if (err < 0)
10685                 return err;
10686         if (!spec->autocfg.line_outs)
10687                 return 0; /* can't find valid BIOS pin config */
10688
10689         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
10690         if (err < 0)
10691                 return err;
10692         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
10693         if (err < 0)
10694                 return err;
10695
10696         spec->multiout.max_channels = 2;
10697
10698         /* digital only support output */
10699         if (spec->autocfg.dig_out_pin)
10700                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
10701
10702         if (spec->kctl_alloc)
10703                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10704
10705         if (spec->autocfg.speaker_pins[0] != 0x1d)
10706                 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
10707
10708         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
10709         spec->num_mux_defs = 1;
10710         spec->input_mux = &spec->private_imux;
10711
10712         err = alc_auto_add_mic_boost(codec);
10713         if (err < 0)
10714                 return err;
10715
10716         return 1;
10717 }
10718
10719 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
10720 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
10721 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
10722
10723 /* init callback for auto-configuration model -- overriding the default init */
10724 static void alc268_auto_init(struct hda_codec *codec)
10725 {
10726         struct alc_spec *spec = codec->spec;
10727         alc268_auto_init_multi_out(codec);
10728         alc268_auto_init_hp_out(codec);
10729         alc268_auto_init_mono_speaker_out(codec);
10730         alc268_auto_init_analog_input(codec);
10731         if (spec->unsol_event)
10732                 alc_sku_automute(codec);
10733 }
10734
10735 /*
10736  * configuration and preset
10737  */
10738 static const char *alc268_models[ALC268_MODEL_LAST] = {
10739         [ALC267_QUANTA_IL1]     = "quanta-il1",
10740         [ALC268_3ST]            = "3stack",
10741         [ALC268_TOSHIBA]        = "toshiba",
10742         [ALC268_ACER]           = "acer",
10743         [ALC268_DELL]           = "dell",
10744         [ALC268_ZEPTO]          = "zepto",
10745 #ifdef CONFIG_SND_DEBUG
10746         [ALC268_TEST]           = "test",
10747 #endif
10748         [ALC268_AUTO]           = "auto",
10749 };
10750
10751 static struct snd_pci_quirk alc268_cfg_tbl[] = {
10752         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
10753         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
10754         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
10755         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
10756         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
10757         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
10758         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
10759         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
10760         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
10761         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
10762         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
10763         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
10764         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
10765         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
10766         {}
10767 };
10768
10769 static struct alc_config_preset alc268_presets[] = {
10770         [ALC267_QUANTA_IL1] = {
10771                 .mixers = { alc267_quanta_il1_mixer },
10772                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10773                                 alc267_quanta_il1_verbs },
10774                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10775                 .dac_nids = alc268_dac_nids,
10776                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10777                 .adc_nids = alc268_adc_nids_alt,
10778                 .hp_nid = 0x03,
10779                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10780                 .channel_mode = alc268_modes,
10781                 .input_mux = &alc268_capture_source,
10782                 .unsol_event = alc267_quanta_il1_unsol_event,
10783                 .init_hook = alc267_quanta_il1_automute,
10784         },
10785         [ALC268_3ST] = {
10786                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10787                             alc268_beep_mixer },
10788                 .init_verbs = { alc268_base_init_verbs },
10789                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10790                 .dac_nids = alc268_dac_nids,
10791                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10792                 .adc_nids = alc268_adc_nids_alt,
10793                 .capsrc_nids = alc268_capsrc_nids,
10794                 .hp_nid = 0x03,
10795                 .dig_out_nid = ALC268_DIGOUT_NID,
10796                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10797                 .channel_mode = alc268_modes,
10798                 .input_mux = &alc268_capture_source,
10799         },
10800         [ALC268_TOSHIBA] = {
10801                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10802                             alc268_beep_mixer },
10803                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10804                                 alc268_toshiba_verbs },
10805                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10806                 .dac_nids = alc268_dac_nids,
10807                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10808                 .adc_nids = alc268_adc_nids_alt,
10809                 .capsrc_nids = alc268_capsrc_nids,
10810                 .hp_nid = 0x03,
10811                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10812                 .channel_mode = alc268_modes,
10813                 .input_mux = &alc268_capture_source,
10814                 .unsol_event = alc268_toshiba_unsol_event,
10815                 .init_hook = alc268_toshiba_automute,
10816         },
10817         [ALC268_ACER] = {
10818                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
10819                             alc268_beep_mixer },
10820                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10821                                 alc268_acer_verbs },
10822                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10823                 .dac_nids = alc268_dac_nids,
10824                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10825                 .adc_nids = alc268_adc_nids_alt,
10826                 .capsrc_nids = alc268_capsrc_nids,
10827                 .hp_nid = 0x02,
10828                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10829                 .channel_mode = alc268_modes,
10830                 .input_mux = &alc268_acer_capture_source,
10831                 .unsol_event = alc268_acer_unsol_event,
10832                 .init_hook = alc268_acer_init_hook,
10833         },
10834         [ALC268_DELL] = {
10835                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
10836                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10837                                 alc268_dell_verbs },
10838                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10839                 .dac_nids = alc268_dac_nids,
10840                 .hp_nid = 0x02,
10841                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10842                 .channel_mode = alc268_modes,
10843                 .unsol_event = alc268_dell_unsol_event,
10844                 .init_hook = alc268_dell_init_hook,
10845                 .input_mux = &alc268_capture_source,
10846         },
10847         [ALC268_ZEPTO] = {
10848                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10849                             alc268_beep_mixer },
10850                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10851                                 alc268_toshiba_verbs },
10852                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10853                 .dac_nids = alc268_dac_nids,
10854                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10855                 .adc_nids = alc268_adc_nids_alt,
10856                 .capsrc_nids = alc268_capsrc_nids,
10857                 .hp_nid = 0x03,
10858                 .dig_out_nid = ALC268_DIGOUT_NID,
10859                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10860                 .channel_mode = alc268_modes,
10861                 .input_mux = &alc268_capture_source,
10862                 .unsol_event = alc268_toshiba_unsol_event,
10863                 .init_hook = alc268_toshiba_automute
10864         },
10865 #ifdef CONFIG_SND_DEBUG
10866         [ALC268_TEST] = {
10867                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
10868                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10869                                 alc268_volume_init_verbs },
10870                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10871                 .dac_nids = alc268_dac_nids,
10872                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10873                 .adc_nids = alc268_adc_nids_alt,
10874                 .capsrc_nids = alc268_capsrc_nids,
10875                 .hp_nid = 0x03,
10876                 .dig_out_nid = ALC268_DIGOUT_NID,
10877                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10878                 .channel_mode = alc268_modes,
10879                 .input_mux = &alc268_capture_source,
10880         },
10881 #endif
10882 };
10883
10884 static int patch_alc268(struct hda_codec *codec)
10885 {
10886         struct alc_spec *spec;
10887         int board_config;
10888         int err;
10889
10890         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
10891         if (spec == NULL)
10892                 return -ENOMEM;
10893
10894         codec->spec = spec;
10895
10896         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
10897                                                   alc268_models,
10898                                                   alc268_cfg_tbl);
10899
10900         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
10901                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
10902                        "trying auto-probe from BIOS...\n");
10903                 board_config = ALC268_AUTO;
10904         }
10905
10906         if (board_config == ALC268_AUTO) {
10907                 /* automatic parse from the BIOS config */
10908                 err = alc268_parse_auto_config(codec);
10909                 if (err < 0) {
10910                         alc_free(codec);
10911                         return err;
10912                 } else if (!err) {
10913                         printk(KERN_INFO
10914                                "hda_codec: Cannot set up configuration "
10915                                "from BIOS.  Using base mode...\n");
10916                         board_config = ALC268_3ST;
10917                 }
10918         }
10919
10920         if (board_config != ALC268_AUTO)
10921                 setup_preset(spec, &alc268_presets[board_config]);
10922
10923         if (codec->vendor_id == 0x10ec0267) {
10924                 spec->stream_name_analog = "ALC267 Analog";
10925                 spec->stream_name_digital = "ALC267 Digital";
10926         } else {
10927                 spec->stream_name_analog = "ALC268 Analog";
10928                 spec->stream_name_digital = "ALC268 Digital";
10929         }
10930
10931         spec->stream_analog_playback = &alc268_pcm_analog_playback;
10932         spec->stream_analog_capture = &alc268_pcm_analog_capture;
10933         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
10934
10935         spec->stream_digital_playback = &alc268_pcm_digital_playback;
10936
10937         if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
10938                 /* override the amp caps for beep generator */
10939                 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
10940                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
10941                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
10942                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
10943                                           (0 << AC_AMPCAP_MUTE_SHIFT));
10944
10945         if (!spec->adc_nids && spec->input_mux) {
10946                 /* check whether NID 0x07 is valid */
10947                 unsigned int wcap = get_wcaps(codec, 0x07);
10948                 int i;
10949
10950                 /* get type */
10951                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10952                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
10953                         spec->adc_nids = alc268_adc_nids_alt;
10954                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
10955                         spec->mixers[spec->num_mixers] =
10956                                         alc268_capture_alt_mixer;
10957                         spec->num_mixers++;
10958                 } else {
10959                         spec->adc_nids = alc268_adc_nids;
10960                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
10961                         spec->mixers[spec->num_mixers] =
10962                                 alc268_capture_mixer;
10963                         spec->num_mixers++;
10964                 }
10965                 spec->capsrc_nids = alc268_capsrc_nids;
10966                 /* set default input source */
10967                 for (i = 0; i < spec->num_adc_nids; i++)
10968                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
10969                                 0, AC_VERB_SET_CONNECT_SEL,
10970                                 spec->input_mux->items[0].index);
10971         }
10972
10973         spec->vmaster_nid = 0x02;
10974
10975         codec->patch_ops = alc_patch_ops;
10976         if (board_config == ALC268_AUTO)
10977                 spec->init_hook = alc268_auto_init;
10978
10979         return 0;
10980 }
10981
10982 /*
10983  *  ALC269 channel source setting (2 channel)
10984  */
10985 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
10986
10987 #define alc269_dac_nids         alc260_dac_nids
10988
10989 static hda_nid_t alc269_adc_nids[1] = {
10990         /* ADC1 */
10991         0x08,
10992 };
10993
10994 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
10995         .num_items = 2,
10996         .items = {
10997                 { "i-Mic", 0x5 },
10998                 { "e-Mic", 0x0 },
10999         },
11000 };
11001
11002 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
11003         .num_items = 2,
11004         .items = {
11005                 { "i-Mic", 0x1 },
11006                 { "e-Mic", 0x0 },
11007         },
11008 };
11009
11010 #define alc269_modes            alc260_modes
11011 #define alc269_capture_source   alc880_lg_lw_capture_source
11012
11013 static struct snd_kcontrol_new alc269_base_mixer[] = {
11014         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11015         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11016         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11017         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11018         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11019         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11020         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11021         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11022         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11023         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11024         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11025         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11026         { } /* end */
11027 };
11028
11029 /* bind volumes of both NID 0x0c and 0x0d */
11030 static struct hda_bind_ctls alc269_epc_bind_vol = {
11031         .ops = &snd_hda_bind_vol,
11032         .values = {
11033                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11034                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11035                 0
11036         },
11037 };
11038
11039 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11040         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11041         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11042         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11043         { } /* end */
11044 };
11045
11046 /* capture mixer elements */
11047 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11048         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11049         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11050         {
11051                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11052                 /* The multiple "Capture Source" controls confuse alsamixer
11053                  * So call somewhat different..
11054                  */
11055                 /* .name = "Capture Source", */
11056                 .name = "Input Source",
11057                 .count = 1,
11058                 .info = alc_mux_enum_info,
11059                 .get = alc_mux_enum_get,
11060                 .put = alc_mux_enum_put,
11061         },
11062         { } /* end */
11063 };
11064
11065 /* capture mixer elements */
11066 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11067         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11068         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11069         { } /* end */
11070 };
11071
11072 /*
11073  * generic initialization of ADC, input mixers and output mixers
11074  */
11075 static struct hda_verb alc269_init_verbs[] = {
11076         /*
11077          * Unmute ADC0 and set the default input to mic-in
11078          */
11079         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11080
11081         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
11082          * analog-loopback mixer widget
11083          * Note: PASD motherboards uses the Line In 2 as the input for
11084          * front panel mic (mic 2)
11085          */
11086         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11087         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11088         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11089         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11090         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11091         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11092
11093         /*
11094          * Set up output mixers (0x0c - 0x0e)
11095          */
11096         /* set vol=0 to output mixers */
11097         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11098         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11099
11100         /* set up input amps for analog loopback */
11101         /* Amp Indices: DAC = 0, mixer = 1 */
11102         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11103         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11104         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11105         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11106         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11107         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11108
11109         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11110         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11111         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11112         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11113         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11114         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11115         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11116
11117         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11118         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11119         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11120         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11121         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11122         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11123         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11124
11125         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11126         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11127
11128         /* FIXME: use matrix-type input source selection */
11129         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
11130         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11131         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11132         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11133         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11134         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11135
11136         /* set EAPD */
11137         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11138         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11139         { }
11140 };
11141
11142 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
11143         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11144         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
11145         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
11147         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11148         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11149         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11150         {}
11151 };
11152
11153 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
11154         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11155         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
11156         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11157         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
11158         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11159         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11160         {}
11161 };
11162
11163 /* toggle speaker-output according to the hp-jack state */
11164 static void alc269_speaker_automute(struct hda_codec *codec)
11165 {
11166         unsigned int present;
11167         unsigned int bits;
11168
11169         present = snd_hda_codec_read(codec, 0x15, 0,
11170                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11171         bits = present ? AMP_IN_MUTE(0) : 0;
11172         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11173                                  AMP_IN_MUTE(0), bits);
11174         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11175                                  AMP_IN_MUTE(0), bits);
11176 }
11177
11178 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
11179 {
11180         unsigned int present;
11181
11182         present = snd_hda_codec_read(codec, 0x18, 0, AC_VERB_GET_PIN_SENSE, 0)
11183                 & AC_PINSENSE_PRESENCE;
11184         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11185                             present ? 0 : 5);
11186 }
11187
11188 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
11189 {
11190         unsigned int present;
11191
11192         present = snd_hda_codec_read(codec, 0x18, 0, AC_VERB_GET_PIN_SENSE, 0)
11193                 & AC_PINSENSE_PRESENCE;
11194         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11195                             present ? AMP_IN_UNMUTE(0) : AMP_IN_MUTE(0));
11196         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11197                             present ? AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1));
11198 }
11199
11200 /* unsolicited event for HP jack sensing */
11201 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
11202                                           unsigned int res)
11203 {
11204         if ((res >> 26) == ALC880_HP_EVENT)
11205                 alc269_speaker_automute(codec);
11206
11207         if ((res >> 26) == ALC880_MIC_EVENT)
11208                 alc269_eeepc_dmic_automute(codec);
11209 }
11210
11211 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
11212 {
11213         alc269_speaker_automute(codec);
11214         alc269_eeepc_dmic_automute(codec);
11215 }
11216
11217 /* unsolicited event for HP jack sensing */
11218 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
11219                                           unsigned int res)
11220 {
11221         if ((res >> 26) == ALC880_HP_EVENT)
11222                 alc269_speaker_automute(codec);
11223
11224         if ((res >> 26) == ALC880_MIC_EVENT)
11225                 alc269_eeepc_amic_automute(codec);
11226 }
11227
11228 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
11229 {
11230         alc269_speaker_automute(codec);
11231         alc269_eeepc_amic_automute(codec);
11232 }
11233
11234 /* add playback controls from the parsed DAC table */
11235 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
11236                                              const struct auto_pin_cfg *cfg)
11237 {
11238         hda_nid_t nid;
11239         int err;
11240
11241         spec->multiout.num_dacs = 1;    /* only use one dac */
11242         spec->multiout.dac_nids = spec->private_dac_nids;
11243         spec->multiout.dac_nids[0] = 2;
11244
11245         nid = cfg->line_out_pins[0];
11246         if (nid) {
11247                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11248                                   "Front Playback Volume",
11249                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
11250                 if (err < 0)
11251                         return err;
11252                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11253                                   "Front Playback Switch",
11254                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
11255                 if (err < 0)
11256                         return err;
11257         }
11258
11259         nid = cfg->speaker_pins[0];
11260         if (nid) {
11261                 if (!cfg->line_out_pins[0]) {
11262                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
11263                                           "Speaker Playback Volume",
11264                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
11265                                                               HDA_OUTPUT));
11266                         if (err < 0)
11267                                 return err;
11268                 }
11269                 if (nid == 0x16) {
11270                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11271                                           "Speaker Playback Switch",
11272                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11273                                                               HDA_OUTPUT));
11274                         if (err < 0)
11275                                 return err;
11276                 } else {
11277                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11278                                           "Speaker Playback Switch",
11279                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11280                                                               HDA_OUTPUT));
11281                         if (err < 0)
11282                                 return err;
11283                 }
11284         }
11285         nid = cfg->hp_pins[0];
11286         if (nid) {
11287                 /* spec->multiout.hp_nid = 2; */
11288                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
11289                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
11290                                           "Headphone Playback Volume",
11291                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
11292                                                               HDA_OUTPUT));
11293                         if (err < 0)
11294                                 return err;
11295                 }
11296                 if (nid == 0x16) {
11297                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11298                                           "Headphone Playback Switch",
11299                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11300                                                               HDA_OUTPUT));
11301                         if (err < 0)
11302                                 return err;
11303                 } else {
11304                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11305                                           "Headphone Playback Switch",
11306                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11307                                                               HDA_OUTPUT));
11308                         if (err < 0)
11309                                 return err;
11310                 }
11311         }
11312         return 0;
11313 }
11314
11315 #define alc269_auto_create_analog_input_ctls \
11316         alc880_auto_create_analog_input_ctls
11317
11318 #ifdef CONFIG_SND_HDA_POWER_SAVE
11319 #define alc269_loopbacks        alc880_loopbacks
11320 #endif
11321
11322 /* pcm configuration: identiacal with ALC880 */
11323 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
11324 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
11325 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
11326 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
11327
11328 /*
11329  * BIOS auto configuration
11330  */
11331 static int alc269_parse_auto_config(struct hda_codec *codec)
11332 {
11333         struct alc_spec *spec = codec->spec;
11334         int err;
11335         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
11336
11337         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11338                                            alc269_ignore);
11339         if (err < 0)
11340                 return err;
11341
11342         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
11343         if (err < 0)
11344                 return err;
11345         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
11346         if (err < 0)
11347                 return err;
11348
11349         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11350
11351         if (spec->autocfg.dig_out_pin)
11352                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
11353
11354         if (spec->kctl_alloc)
11355                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11356
11357         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
11358         spec->num_mux_defs = 1;
11359         spec->input_mux = &spec->private_imux;
11360
11361         err = alc_auto_add_mic_boost(codec);
11362         if (err < 0)
11363                 return err;
11364
11365         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
11366         spec->num_mixers++;
11367
11368         return 1;
11369 }
11370
11371 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
11372 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
11373 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
11374
11375
11376 /* init callback for auto-configuration model -- overriding the default init */
11377 static void alc269_auto_init(struct hda_codec *codec)
11378 {
11379         struct alc_spec *spec = codec->spec;
11380         alc269_auto_init_multi_out(codec);
11381         alc269_auto_init_hp_out(codec);
11382         alc269_auto_init_analog_input(codec);
11383         if (spec->unsol_event)
11384                 alc_sku_automute(codec);
11385 }
11386
11387 /*
11388  * configuration and preset
11389  */
11390 static const char *alc269_models[ALC269_MODEL_LAST] = {
11391         [ALC269_BASIC]          = "basic",
11392 };
11393
11394 static struct snd_pci_quirk alc269_cfg_tbl[] = {
11395         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
11396                       ALC269_ASUS_EEEPC_P703),
11397         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
11398                       ALC269_ASUS_EEEPC_P901),
11399         {}
11400 };
11401
11402 static struct alc_config_preset alc269_presets[] = {
11403         [ALC269_BASIC] = {
11404                 .mixers = { alc269_base_mixer, alc269_capture_mixer },
11405                 .init_verbs = { alc269_init_verbs },
11406                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11407                 .dac_nids = alc269_dac_nids,
11408                 .hp_nid = 0x03,
11409                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11410                 .channel_mode = alc269_modes,
11411                 .input_mux = &alc269_capture_source,
11412         },
11413         [ALC269_ASUS_EEEPC_P703] = {
11414                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
11415                 .init_verbs = { alc269_init_verbs,
11416                                 alc269_eeepc_amic_init_verbs },
11417                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11418                 .dac_nids = alc269_dac_nids,
11419                 .hp_nid = 0x03,
11420                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11421                 .channel_mode = alc269_modes,
11422                 .input_mux = &alc269_eeepc_amic_capture_source,
11423                 .unsol_event = alc269_eeepc_amic_unsol_event,
11424                 .init_hook = alc269_eeepc_amic_inithook,
11425         },
11426         [ALC269_ASUS_EEEPC_P901] = {
11427                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
11428                 .init_verbs = { alc269_init_verbs,
11429                                 alc269_eeepc_dmic_init_verbs },
11430                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11431                 .dac_nids = alc269_dac_nids,
11432                 .hp_nid = 0x03,
11433                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11434                 .channel_mode = alc269_modes,
11435                 .input_mux = &alc269_eeepc_dmic_capture_source,
11436                 .unsol_event = alc269_eeepc_dmic_unsol_event,
11437                 .init_hook = alc269_eeepc_dmic_inithook,
11438         },
11439 };
11440
11441 static int patch_alc269(struct hda_codec *codec)
11442 {
11443         struct alc_spec *spec;
11444         int board_config;
11445         int err;
11446
11447         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11448         if (spec == NULL)
11449                 return -ENOMEM;
11450
11451         codec->spec = spec;
11452
11453         alc_fix_pll_init(codec, 0x20, 0x04, 15);
11454
11455         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
11456                                                   alc269_models,
11457                                                   alc269_cfg_tbl);
11458
11459         if (board_config < 0) {
11460                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
11461                        "trying auto-probe from BIOS...\n");
11462                 board_config = ALC269_AUTO;
11463         }
11464
11465         if (board_config == ALC269_AUTO) {
11466                 /* automatic parse from the BIOS config */
11467                 err = alc269_parse_auto_config(codec);
11468                 if (err < 0) {
11469                         alc_free(codec);
11470                         return err;
11471                 } else if (!err) {
11472                         printk(KERN_INFO
11473                                "hda_codec: Cannot set up configuration "
11474                                "from BIOS.  Using base mode...\n");
11475                         board_config = ALC269_BASIC;
11476                 }
11477         }
11478
11479         if (board_config != ALC269_AUTO)
11480                 setup_preset(spec, &alc269_presets[board_config]);
11481
11482         spec->stream_name_analog = "ALC269 Analog";
11483         spec->stream_analog_playback = &alc269_pcm_analog_playback;
11484         spec->stream_analog_capture = &alc269_pcm_analog_capture;
11485
11486         spec->stream_name_digital = "ALC269 Digital";
11487         spec->stream_digital_playback = &alc269_pcm_digital_playback;
11488         spec->stream_digital_capture = &alc269_pcm_digital_capture;
11489
11490         spec->adc_nids = alc269_adc_nids;
11491         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
11492
11493         codec->patch_ops = alc_patch_ops;
11494         if (board_config == ALC269_AUTO)
11495                 spec->init_hook = alc269_auto_init;
11496 #ifdef CONFIG_SND_HDA_POWER_SAVE
11497         if (!spec->loopback.amplist)
11498                 spec->loopback.amplist = alc269_loopbacks;
11499 #endif
11500
11501         return 0;
11502 }
11503
11504 /*
11505  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
11506  */
11507
11508 /*
11509  * set the path ways for 2 channel output
11510  * need to set the codec line out and mic 1 pin widgets to inputs
11511  */
11512 static struct hda_verb alc861_threestack_ch2_init[] = {
11513         /* set pin widget 1Ah (line in) for input */
11514         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11515         /* set pin widget 18h (mic1/2) for input, for mic also enable
11516          * the vref
11517          */
11518         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11519
11520         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
11521 #if 0
11522         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11523         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
11524 #endif
11525         { } /* end */
11526 };
11527 /*
11528  * 6ch mode
11529  * need to set the codec line out and mic 1 pin widgets to outputs
11530  */
11531 static struct hda_verb alc861_threestack_ch6_init[] = {
11532         /* set pin widget 1Ah (line in) for output (Back Surround)*/
11533         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11534         /* set pin widget 18h (mic1) for output (CLFE)*/
11535         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11536
11537         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
11538         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
11539
11540         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
11541 #if 0
11542         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11543         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
11544 #endif
11545         { } /* end */
11546 };
11547
11548 static struct hda_channel_mode alc861_threestack_modes[2] = {
11549         { 2, alc861_threestack_ch2_init },
11550         { 6, alc861_threestack_ch6_init },
11551 };
11552 /* Set mic1 as input and unmute the mixer */
11553 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
11554         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11555         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11556         { } /* end */
11557 };
11558 /* Set mic1 as output and mute mixer */
11559 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
11560         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11561         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11562         { } /* end */
11563 };
11564
11565 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
11566         { 2, alc861_uniwill_m31_ch2_init },
11567         { 4, alc861_uniwill_m31_ch4_init },
11568 };
11569
11570 /* Set mic1 and line-in as input and unmute the mixer */
11571 static struct hda_verb alc861_asus_ch2_init[] = {
11572         /* set pin widget 1Ah (line in) for input */
11573         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11574         /* set pin widget 18h (mic1/2) for input, for mic also enable
11575          * the vref
11576          */
11577         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11578
11579         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
11580 #if 0
11581         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11582         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
11583 #endif
11584         { } /* end */
11585 };
11586 /* Set mic1 nad line-in as output and mute mixer */
11587 static struct hda_verb alc861_asus_ch6_init[] = {
11588         /* set pin widget 1Ah (line in) for output (Back Surround)*/
11589         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11590         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
11591         /* set pin widget 18h (mic1) for output (CLFE)*/
11592         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11593         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
11594         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
11595         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
11596
11597         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
11598 #if 0
11599         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11600         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
11601 #endif
11602         { } /* end */
11603 };
11604
11605 static struct hda_channel_mode alc861_asus_modes[2] = {
11606         { 2, alc861_asus_ch2_init },
11607         { 6, alc861_asus_ch6_init },
11608 };
11609
11610 /* patch-ALC861 */
11611
11612 static struct snd_kcontrol_new alc861_base_mixer[] = {
11613         /* output mixer control */
11614         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11615         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11616         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11617         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11618         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
11619
11620         /*Input mixer control */
11621         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11622            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11623         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11624         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11625         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11626         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11627         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11628         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11629         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11630         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11631
11632         /* Capture mixer control */
11633         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11634         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11635         {
11636                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11637                 .name = "Capture Source",
11638                 .count = 1,
11639                 .info = alc_mux_enum_info,
11640                 .get = alc_mux_enum_get,
11641                 .put = alc_mux_enum_put,
11642         },
11643         { } /* end */
11644 };
11645
11646 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
11647         /* output mixer control */
11648         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11649         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11650         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11651         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11652         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
11653
11654         /* Input mixer control */
11655         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11656            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11657         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11658         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11659         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11660         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11661         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11662         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11663         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11664         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11665
11666         /* Capture mixer control */
11667         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11668         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11669         {
11670                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11671                 .name = "Capture Source",
11672                 .count = 1,
11673                 .info = alc_mux_enum_info,
11674                 .get = alc_mux_enum_get,
11675                 .put = alc_mux_enum_put,
11676         },
11677         {
11678                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11679                 .name = "Channel Mode",
11680                 .info = alc_ch_mode_info,
11681                 .get = alc_ch_mode_get,
11682                 .put = alc_ch_mode_put,
11683                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
11684         },
11685         { } /* end */
11686 };
11687
11688 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
11689         /* output mixer control */
11690         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11691         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11692         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11693
11694         /*Capture mixer control */
11695         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11696         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11697         {
11698                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11699                 .name = "Capture Source",
11700                 .count = 1,
11701                 .info = alc_mux_enum_info,
11702                 .get = alc_mux_enum_get,
11703                 .put = alc_mux_enum_put,
11704         },
11705
11706         { } /* end */
11707 };
11708
11709 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
11710         /* output mixer control */
11711         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11712         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11713         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11714         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11715         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
11716
11717         /* Input mixer control */
11718         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11719            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11720         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11721         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11722         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11723         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11724         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11725         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11726         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11727         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11728
11729         /* Capture mixer control */
11730         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11731         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11732         {
11733                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11734                 .name = "Capture Source",
11735                 .count = 1,
11736                 .info = alc_mux_enum_info,
11737                 .get = alc_mux_enum_get,
11738                 .put = alc_mux_enum_put,
11739         },
11740         {
11741                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11742                 .name = "Channel Mode",
11743                 .info = alc_ch_mode_info,
11744                 .get = alc_ch_mode_get,
11745                 .put = alc_ch_mode_put,
11746                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
11747         },
11748         { } /* end */
11749 };
11750
11751 static struct snd_kcontrol_new alc861_asus_mixer[] = {
11752         /* output mixer control */
11753         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11754         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11755         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11756         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11757         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
11758
11759         /* Input mixer control */
11760         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11761         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11762         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11763         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11764         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11765         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11766         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11767         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11768         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11769         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
11770
11771         /* Capture mixer control */
11772         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11773         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11774         {
11775                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11776                 .name = "Capture Source",
11777                 .count = 1,
11778                 .info = alc_mux_enum_info,
11779                 .get = alc_mux_enum_get,
11780                 .put = alc_mux_enum_put,
11781         },
11782         {
11783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11784                 .name = "Channel Mode",
11785                 .info = alc_ch_mode_info,
11786                 .get = alc_ch_mode_get,
11787                 .put = alc_ch_mode_put,
11788                 .private_value = ARRAY_SIZE(alc861_asus_modes),
11789         },
11790         { }
11791 };
11792
11793 /* additional mixer */
11794 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
11795         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11796         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11797         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
11798         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
11799         { }
11800 };
11801
11802 /*
11803  * generic initialization of ADC, input mixers and output mixers
11804  */
11805 static struct hda_verb alc861_base_init_verbs[] = {
11806         /*
11807          * Unmute ADC0 and set the default input to mic-in
11808          */
11809         /* port-A for surround (rear panel) */
11810         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11811         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
11812         /* port-B for mic-in (rear panel) with vref */
11813         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11814         /* port-C for line-in (rear panel) */
11815         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11816         /* port-D for Front */
11817         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11818         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11819         /* port-E for HP out (front panel) */
11820         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
11821         /* route front PCM to HP */
11822         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11823         /* port-F for mic-in (front panel) with vref */
11824         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11825         /* port-G for CLFE (rear panel) */
11826         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11827         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11828         /* port-H for side (rear panel) */
11829         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11830         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
11831         /* CD-in */
11832         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11833         /* route front mic to ADC1*/
11834         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11835         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11836
11837         /* Unmute DAC0~3 & spdif out*/
11838         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11839         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11840         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11841         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11842         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11843
11844         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11845         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11846         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11847         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11848         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11849
11850         /* Unmute Stereo Mixer 15 */
11851         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11852         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11853         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11855
11856         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11857         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11858         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11859         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11860         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11861         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11862         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11863         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11864         /* hp used DAC 3 (Front) */
11865         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11866         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11867
11868         { }
11869 };
11870
11871 static struct hda_verb alc861_threestack_init_verbs[] = {
11872         /*
11873          * Unmute ADC0 and set the default input to mic-in
11874          */
11875         /* port-A for surround (rear panel) */
11876         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11877         /* port-B for mic-in (rear panel) with vref */
11878         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11879         /* port-C for line-in (rear panel) */
11880         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11881         /* port-D for Front */
11882         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11883         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11884         /* port-E for HP out (front panel) */
11885         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
11886         /* route front PCM to HP */
11887         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11888         /* port-F for mic-in (front panel) with vref */
11889         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11890         /* port-G for CLFE (rear panel) */
11891         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11892         /* port-H for side (rear panel) */
11893         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11894         /* CD-in */
11895         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11896         /* route front mic to ADC1*/
11897         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11898         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11899         /* Unmute DAC0~3 & spdif out*/
11900         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11901         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11902         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11903         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11904         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11905
11906         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11907         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11908         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11909         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11910         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11911
11912         /* Unmute Stereo Mixer 15 */
11913         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11914         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11915         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11916         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11917
11918         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11919         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11920         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11921         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11922         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11923         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11924         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11925         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11926         /* hp used DAC 3 (Front) */
11927         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11928         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11929         { }
11930 };
11931
11932 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
11933         /*
11934          * Unmute ADC0 and set the default input to mic-in
11935          */
11936         /* port-A for surround (rear panel) */
11937         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11938         /* port-B for mic-in (rear panel) with vref */
11939         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11940         /* port-C for line-in (rear panel) */
11941         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11942         /* port-D for Front */
11943         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11944         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11945         /* port-E for HP out (front panel) */
11946         /* this has to be set to VREF80 */
11947         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11948         /* route front PCM to HP */
11949         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11950         /* port-F for mic-in (front panel) with vref */
11951         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11952         /* port-G for CLFE (rear panel) */
11953         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11954         /* port-H for side (rear panel) */
11955         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11956         /* CD-in */
11957         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11958         /* route front mic to ADC1*/
11959         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11960         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11961         /* Unmute DAC0~3 & spdif out*/
11962         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11963         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11964         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11965         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11966         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11967
11968         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11969         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11970         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11971         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11972         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11973
11974         /* Unmute Stereo Mixer 15 */
11975         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11976         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11977         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11978         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11979
11980         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11981         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11982         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11983         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11984         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11985         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11986         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11987         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11988         /* hp used DAC 3 (Front) */
11989         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11990         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11991         { }
11992 };
11993
11994 static struct hda_verb alc861_asus_init_verbs[] = {
11995         /*
11996          * Unmute ADC0 and set the default input to mic-in
11997          */
11998         /* port-A for surround (rear panel)
11999          * according to codec#0 this is the HP jack
12000          */
12001         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
12002         /* route front PCM to HP */
12003         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
12004         /* port-B for mic-in (rear panel) with vref */
12005         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12006         /* port-C for line-in (rear panel) */
12007         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12008         /* port-D for Front */
12009         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12010         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12011         /* port-E for HP out (front panel) */
12012         /* this has to be set to VREF80 */
12013         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12014         /* route front PCM to HP */
12015         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12016         /* port-F for mic-in (front panel) with vref */
12017         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12018         /* port-G for CLFE (rear panel) */
12019         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12020         /* port-H for side (rear panel) */
12021         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12022         /* CD-in */
12023         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12024         /* route front mic to ADC1*/
12025         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12026         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12027         /* Unmute DAC0~3 & spdif out*/
12028         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12029         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12030         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12031         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12032         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12033         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12034         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12035         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12036         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12037         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12038
12039         /* Unmute Stereo Mixer 15 */
12040         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12041         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12042         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12043         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12044
12045         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12046         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12047         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12048         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12049         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12050         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12051         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12052         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12053         /* hp used DAC 3 (Front) */
12054         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12055         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12056         { }
12057 };
12058
12059 /* additional init verbs for ASUS laptops */
12060 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
12061         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
12062         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
12063         { }
12064 };
12065
12066 /*
12067  * generic initialization of ADC, input mixers and output mixers
12068  */
12069 static struct hda_verb alc861_auto_init_verbs[] = {
12070         /*
12071          * Unmute ADC0 and set the default input to mic-in
12072          */
12073         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
12074         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12075
12076         /* Unmute DAC0~3 & spdif out*/
12077         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12078         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12079         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12080         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12081         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12082
12083         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12084         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12085         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12086         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12087         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12088
12089         /* Unmute Stereo Mixer 15 */
12090         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12091         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12092         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12093         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
12094
12095         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12096         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12097         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12098         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12099         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12100         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12101         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12102         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12103
12104         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12105         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12106         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12107         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12108         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12109         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12110         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12111         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12112
12113         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
12114
12115         { }
12116 };
12117
12118 static struct hda_verb alc861_toshiba_init_verbs[] = {
12119         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12120
12121         { }
12122 };
12123
12124 /* toggle speaker-output according to the hp-jack state */
12125 static void alc861_toshiba_automute(struct hda_codec *codec)
12126 {
12127         unsigned int present;
12128
12129         present = snd_hda_codec_read(codec, 0x0f, 0,
12130                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12131         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
12132                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
12133         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
12134                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
12135 }
12136
12137 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
12138                                        unsigned int res)
12139 {
12140         if ((res >> 26) == ALC880_HP_EVENT)
12141                 alc861_toshiba_automute(codec);
12142 }
12143
12144 /* pcm configuration: identiacal with ALC880 */
12145 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
12146 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
12147 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
12148 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
12149
12150
12151 #define ALC861_DIGOUT_NID       0x07
12152
12153 static struct hda_channel_mode alc861_8ch_modes[1] = {
12154         { 8, NULL }
12155 };
12156
12157 static hda_nid_t alc861_dac_nids[4] = {
12158         /* front, surround, clfe, side */
12159         0x03, 0x06, 0x05, 0x04
12160 };
12161
12162 static hda_nid_t alc660_dac_nids[3] = {
12163         /* front, clfe, surround */
12164         0x03, 0x05, 0x06
12165 };
12166
12167 static hda_nid_t alc861_adc_nids[1] = {
12168         /* ADC0-2 */
12169         0x08,
12170 };
12171
12172 static struct hda_input_mux alc861_capture_source = {
12173         .num_items = 5,
12174         .items = {
12175                 { "Mic", 0x0 },
12176                 { "Front Mic", 0x3 },
12177                 { "Line", 0x1 },
12178                 { "CD", 0x4 },
12179                 { "Mixer", 0x5 },
12180         },
12181 };
12182
12183 /* fill in the dac_nids table from the parsed pin configuration */
12184 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
12185                                      const struct auto_pin_cfg *cfg)
12186 {
12187         int i;
12188         hda_nid_t nid;
12189
12190         spec->multiout.dac_nids = spec->private_dac_nids;
12191         for (i = 0; i < cfg->line_outs; i++) {
12192                 nid = cfg->line_out_pins[i];
12193                 if (nid) {
12194                         if (i >= ARRAY_SIZE(alc861_dac_nids))
12195                                 continue;
12196                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
12197                 }
12198         }
12199         spec->multiout.num_dacs = cfg->line_outs;
12200         return 0;
12201 }
12202
12203 /* add playback controls from the parsed DAC table */
12204 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
12205                                              const struct auto_pin_cfg *cfg)
12206 {
12207         char name[32];
12208         static const char *chname[4] = {
12209                 "Front", "Surround", NULL /*CLFE*/, "Side"
12210         };
12211         hda_nid_t nid;
12212         int i, idx, err;
12213
12214         for (i = 0; i < cfg->line_outs; i++) {
12215                 nid = spec->multiout.dac_nids[i];
12216                 if (!nid)
12217                         continue;
12218                 if (nid == 0x05) {
12219                         /* Center/LFE */
12220                         err = add_control(spec, ALC_CTL_BIND_MUTE,
12221                                           "Center Playback Switch",
12222                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
12223                                                               HDA_OUTPUT));
12224                         if (err < 0)
12225                                 return err;
12226                         err = add_control(spec, ALC_CTL_BIND_MUTE,
12227                                           "LFE Playback Switch",
12228                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12229                                                               HDA_OUTPUT));
12230                         if (err < 0)
12231                                 return err;
12232                 } else {
12233                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
12234                              idx++)
12235                                 if (nid == alc861_dac_nids[idx])
12236                                         break;
12237                         sprintf(name, "%s Playback Switch", chname[idx]);
12238                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
12239                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12240                                                               HDA_OUTPUT));
12241                         if (err < 0)
12242                                 return err;
12243                 }
12244         }
12245         return 0;
12246 }
12247
12248 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
12249 {
12250         int err;
12251         hda_nid_t nid;
12252
12253         if (!pin)
12254                 return 0;
12255
12256         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
12257                 nid = 0x03;
12258                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12259                                   "Headphone Playback Switch",
12260                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12261                 if (err < 0)
12262                         return err;
12263                 spec->multiout.hp_nid = nid;
12264         }
12265         return 0;
12266 }
12267
12268 /* create playback/capture controls for input pins */
12269 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
12270                                                 const struct auto_pin_cfg *cfg)
12271 {
12272         struct hda_input_mux *imux = &spec->private_imux;
12273         int i, err, idx, idx1;
12274
12275         for (i = 0; i < AUTO_PIN_LAST; i++) {
12276                 switch (cfg->input_pins[i]) {
12277                 case 0x0c:
12278                         idx1 = 1;
12279                         idx = 2;        /* Line In */
12280                         break;
12281                 case 0x0f:
12282                         idx1 = 2;
12283                         idx = 2;        /* Line In */
12284                         break;
12285                 case 0x0d:
12286                         idx1 = 0;
12287                         idx = 1;        /* Mic In */
12288                         break;
12289                 case 0x10:
12290                         idx1 = 3;
12291                         idx = 1;        /* Mic In */
12292                         break;
12293                 case 0x11:
12294                         idx1 = 4;
12295                         idx = 0;        /* CD */
12296                         break;
12297                 default:
12298                         continue;
12299                 }
12300
12301                 err = new_analog_input(spec, cfg->input_pins[i],
12302                                        auto_pin_cfg_labels[i], idx, 0x15);
12303                 if (err < 0)
12304                         return err;
12305
12306                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
12307                 imux->items[imux->num_items].index = idx1;
12308                 imux->num_items++;
12309         }
12310         return 0;
12311 }
12312
12313 static struct snd_kcontrol_new alc861_capture_mixer[] = {
12314         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12315         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12316
12317         {
12318                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12319                 /* The multiple "Capture Source" controls confuse alsamixer
12320                  * So call somewhat different..
12321                  */
12322                 /* .name = "Capture Source", */
12323                 .name = "Input Source",
12324                 .count = 1,
12325                 .info = alc_mux_enum_info,
12326                 .get = alc_mux_enum_get,
12327                 .put = alc_mux_enum_put,
12328         },
12329         { } /* end */
12330 };
12331
12332 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
12333                                               hda_nid_t nid,
12334                                               int pin_type, int dac_idx)
12335 {
12336         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
12337                             pin_type);
12338         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12339                             AMP_OUT_UNMUTE);
12340 }
12341
12342 static void alc861_auto_init_multi_out(struct hda_codec *codec)
12343 {
12344         struct alc_spec *spec = codec->spec;
12345         int i;
12346
12347         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
12348         for (i = 0; i < spec->autocfg.line_outs; i++) {
12349                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
12350                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12351                 if (nid)
12352                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
12353                                                           spec->multiout.dac_nids[i]);
12354         }
12355 }
12356
12357 static void alc861_auto_init_hp_out(struct hda_codec *codec)
12358 {
12359         struct alc_spec *spec = codec->spec;
12360         hda_nid_t pin;
12361
12362         pin = spec->autocfg.hp_pins[0];
12363         if (pin) /* connect to front */
12364                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
12365                                                   spec->multiout.dac_nids[0]);
12366         pin = spec->autocfg.speaker_pins[0];
12367         if (pin)
12368                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
12369 }
12370
12371 static void alc861_auto_init_analog_input(struct hda_codec *codec)
12372 {
12373         struct alc_spec *spec = codec->spec;
12374         int i;
12375
12376         for (i = 0; i < AUTO_PIN_LAST; i++) {
12377                 hda_nid_t nid = spec->autocfg.input_pins[i];
12378                 if (nid >= 0x0c && nid <= 0x11) {
12379                         snd_hda_codec_write(codec, nid, 0,
12380                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
12381                                             i <= AUTO_PIN_FRONT_MIC ?
12382                                             PIN_VREF80 : PIN_IN);
12383                 }
12384         }
12385 }
12386
12387 /* parse the BIOS configuration and set up the alc_spec */
12388 /* return 1 if successful, 0 if the proper config is not found,
12389  * or a negative error code
12390  */
12391 static int alc861_parse_auto_config(struct hda_codec *codec)
12392 {
12393         struct alc_spec *spec = codec->spec;
12394         int err;
12395         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
12396
12397         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12398                                            alc861_ignore);
12399         if (err < 0)
12400                 return err;
12401         if (!spec->autocfg.line_outs)
12402                 return 0; /* can't find valid BIOS pin config */
12403
12404         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
12405         if (err < 0)
12406                 return err;
12407         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
12408         if (err < 0)
12409                 return err;
12410         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
12411         if (err < 0)
12412                 return err;
12413         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
12414         if (err < 0)
12415                 return err;
12416
12417         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12418
12419         if (spec->autocfg.dig_out_pin)
12420                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
12421
12422         if (spec->kctl_alloc)
12423                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12424
12425         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
12426
12427         spec->num_mux_defs = 1;
12428         spec->input_mux = &spec->private_imux;
12429
12430         spec->adc_nids = alc861_adc_nids;
12431         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
12432         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
12433         spec->num_mixers++;
12434
12435         return 1;
12436 }
12437
12438 /* additional initialization for auto-configuration model */
12439 static void alc861_auto_init(struct hda_codec *codec)
12440 {
12441         struct alc_spec *spec = codec->spec;
12442         alc861_auto_init_multi_out(codec);
12443         alc861_auto_init_hp_out(codec);
12444         alc861_auto_init_analog_input(codec);
12445         if (spec->unsol_event)
12446                 alc_sku_automute(codec);
12447 }
12448
12449 #ifdef CONFIG_SND_HDA_POWER_SAVE
12450 static struct hda_amp_list alc861_loopbacks[] = {
12451         { 0x15, HDA_INPUT, 0 },
12452         { 0x15, HDA_INPUT, 1 },
12453         { 0x15, HDA_INPUT, 2 },
12454         { 0x15, HDA_INPUT, 3 },
12455         { } /* end */
12456 };
12457 #endif
12458
12459
12460 /*
12461  * configuration and preset
12462  */
12463 static const char *alc861_models[ALC861_MODEL_LAST] = {
12464         [ALC861_3ST]            = "3stack",
12465         [ALC660_3ST]            = "3stack-660",
12466         [ALC861_3ST_DIG]        = "3stack-dig",
12467         [ALC861_6ST_DIG]        = "6stack-dig",
12468         [ALC861_UNIWILL_M31]    = "uniwill-m31",
12469         [ALC861_TOSHIBA]        = "toshiba",
12470         [ALC861_ASUS]           = "asus",
12471         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
12472         [ALC861_AUTO]           = "auto",
12473 };
12474
12475 static struct snd_pci_quirk alc861_cfg_tbl[] = {
12476         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
12477         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
12478         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
12479         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
12480         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
12481         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
12482         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
12483         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
12484          *        Any other models that need this preset?
12485          */
12486         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
12487         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
12488         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
12489         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
12490         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
12491         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
12492         /* FIXME: the below seems conflict */
12493         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
12494         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
12495         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
12496         {}
12497 };
12498
12499 static struct alc_config_preset alc861_presets[] = {
12500         [ALC861_3ST] = {
12501                 .mixers = { alc861_3ST_mixer },
12502                 .init_verbs = { alc861_threestack_init_verbs },
12503                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12504                 .dac_nids = alc861_dac_nids,
12505                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12506                 .channel_mode = alc861_threestack_modes,
12507                 .need_dac_fix = 1,
12508                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12509                 .adc_nids = alc861_adc_nids,
12510                 .input_mux = &alc861_capture_source,
12511         },
12512         [ALC861_3ST_DIG] = {
12513                 .mixers = { alc861_base_mixer },
12514                 .init_verbs = { alc861_threestack_init_verbs },
12515                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12516                 .dac_nids = alc861_dac_nids,
12517                 .dig_out_nid = ALC861_DIGOUT_NID,
12518                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12519                 .channel_mode = alc861_threestack_modes,
12520                 .need_dac_fix = 1,
12521                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12522                 .adc_nids = alc861_adc_nids,
12523                 .input_mux = &alc861_capture_source,
12524         },
12525         [ALC861_6ST_DIG] = {
12526                 .mixers = { alc861_base_mixer },
12527                 .init_verbs = { alc861_base_init_verbs },
12528                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12529                 .dac_nids = alc861_dac_nids,
12530                 .dig_out_nid = ALC861_DIGOUT_NID,
12531                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
12532                 .channel_mode = alc861_8ch_modes,
12533                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12534                 .adc_nids = alc861_adc_nids,
12535                 .input_mux = &alc861_capture_source,
12536         },
12537         [ALC660_3ST] = {
12538                 .mixers = { alc861_3ST_mixer },
12539                 .init_verbs = { alc861_threestack_init_verbs },
12540                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
12541                 .dac_nids = alc660_dac_nids,
12542                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12543                 .channel_mode = alc861_threestack_modes,
12544                 .need_dac_fix = 1,
12545                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12546                 .adc_nids = alc861_adc_nids,
12547                 .input_mux = &alc861_capture_source,
12548         },
12549         [ALC861_UNIWILL_M31] = {
12550                 .mixers = { alc861_uniwill_m31_mixer },
12551                 .init_verbs = { alc861_uniwill_m31_init_verbs },
12552                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12553                 .dac_nids = alc861_dac_nids,
12554                 .dig_out_nid = ALC861_DIGOUT_NID,
12555                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
12556                 .channel_mode = alc861_uniwill_m31_modes,
12557                 .need_dac_fix = 1,
12558                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12559                 .adc_nids = alc861_adc_nids,
12560                 .input_mux = &alc861_capture_source,
12561         },
12562         [ALC861_TOSHIBA] = {
12563                 .mixers = { alc861_toshiba_mixer },
12564                 .init_verbs = { alc861_base_init_verbs,
12565                                 alc861_toshiba_init_verbs },
12566                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12567                 .dac_nids = alc861_dac_nids,
12568                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
12569                 .channel_mode = alc883_3ST_2ch_modes,
12570                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12571                 .adc_nids = alc861_adc_nids,
12572                 .input_mux = &alc861_capture_source,
12573                 .unsol_event = alc861_toshiba_unsol_event,
12574                 .init_hook = alc861_toshiba_automute,
12575         },
12576         [ALC861_ASUS] = {
12577                 .mixers = { alc861_asus_mixer },
12578                 .init_verbs = { alc861_asus_init_verbs },
12579                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12580                 .dac_nids = alc861_dac_nids,
12581                 .dig_out_nid = ALC861_DIGOUT_NID,
12582                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
12583                 .channel_mode = alc861_asus_modes,
12584                 .need_dac_fix = 1,
12585                 .hp_nid = 0x06,
12586                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12587                 .adc_nids = alc861_adc_nids,
12588                 .input_mux = &alc861_capture_source,
12589         },
12590         [ALC861_ASUS_LAPTOP] = {
12591                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
12592                 .init_verbs = { alc861_asus_init_verbs,
12593                                 alc861_asus_laptop_init_verbs },
12594                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12595                 .dac_nids = alc861_dac_nids,
12596                 .dig_out_nid = ALC861_DIGOUT_NID,
12597                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
12598                 .channel_mode = alc883_3ST_2ch_modes,
12599                 .need_dac_fix = 1,
12600                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12601                 .adc_nids = alc861_adc_nids,
12602                 .input_mux = &alc861_capture_source,
12603         },
12604 };
12605
12606
12607 static int patch_alc861(struct hda_codec *codec)
12608 {
12609         struct alc_spec *spec;
12610         int board_config;
12611         int err;
12612
12613         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12614         if (spec == NULL)
12615                 return -ENOMEM;
12616
12617         codec->spec = spec;
12618
12619         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
12620                                                   alc861_models,
12621                                                   alc861_cfg_tbl);
12622
12623         if (board_config < 0) {
12624                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
12625                        "trying auto-probe from BIOS...\n");
12626                 board_config = ALC861_AUTO;
12627         }
12628
12629         if (board_config == ALC861_AUTO) {
12630                 /* automatic parse from the BIOS config */
12631                 err = alc861_parse_auto_config(codec);
12632                 if (err < 0) {
12633                         alc_free(codec);
12634                         return err;
12635                 } else if (!err) {
12636                         printk(KERN_INFO
12637                                "hda_codec: Cannot set up configuration "
12638                                "from BIOS.  Using base mode...\n");
12639                    board_config = ALC861_3ST_DIG;
12640                 }
12641         }
12642
12643         if (board_config != ALC861_AUTO)
12644                 setup_preset(spec, &alc861_presets[board_config]);
12645
12646         spec->stream_name_analog = "ALC861 Analog";
12647         spec->stream_analog_playback = &alc861_pcm_analog_playback;
12648         spec->stream_analog_capture = &alc861_pcm_analog_capture;
12649
12650         spec->stream_name_digital = "ALC861 Digital";
12651         spec->stream_digital_playback = &alc861_pcm_digital_playback;
12652         spec->stream_digital_capture = &alc861_pcm_digital_capture;
12653
12654         spec->vmaster_nid = 0x03;
12655
12656         codec->patch_ops = alc_patch_ops;
12657         if (board_config == ALC861_AUTO)
12658                 spec->init_hook = alc861_auto_init;
12659 #ifdef CONFIG_SND_HDA_POWER_SAVE
12660         if (!spec->loopback.amplist)
12661                 spec->loopback.amplist = alc861_loopbacks;
12662 #endif
12663
12664         return 0;
12665 }
12666
12667 /*
12668  * ALC861-VD support
12669  *
12670  * Based on ALC882
12671  *
12672  * In addition, an independent DAC
12673  */
12674 #define ALC861VD_DIGOUT_NID     0x06
12675
12676 static hda_nid_t alc861vd_dac_nids[4] = {
12677         /* front, surr, clfe, side surr */
12678         0x02, 0x03, 0x04, 0x05
12679 };
12680
12681 /* dac_nids for ALC660vd are in a different order - according to
12682  * Realtek's driver.
12683  * This should probably tesult in a different mixer for 6stack models
12684  * of ALC660vd codecs, but for now there is only 3stack mixer
12685  * - and it is the same as in 861vd.
12686  * adc_nids in ALC660vd are (is) the same as in 861vd
12687  */
12688 static hda_nid_t alc660vd_dac_nids[3] = {
12689         /* front, rear, clfe, rear_surr */
12690         0x02, 0x04, 0x03
12691 };
12692
12693 static hda_nid_t alc861vd_adc_nids[1] = {
12694         /* ADC0 */
12695         0x09,
12696 };
12697
12698 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
12699
12700 /* input MUX */
12701 /* FIXME: should be a matrix-type input source selection */
12702 static struct hda_input_mux alc861vd_capture_source = {
12703         .num_items = 4,
12704         .items = {
12705                 { "Mic", 0x0 },
12706                 { "Front Mic", 0x1 },
12707                 { "Line", 0x2 },
12708                 { "CD", 0x4 },
12709         },
12710 };
12711
12712 static struct hda_input_mux alc861vd_dallas_capture_source = {
12713         .num_items = 2,
12714         .items = {
12715                 { "Ext Mic", 0x0 },
12716                 { "Int Mic", 0x1 },
12717         },
12718 };
12719
12720 static struct hda_input_mux alc861vd_hp_capture_source = {
12721         .num_items = 2,
12722         .items = {
12723                 { "Front Mic", 0x0 },
12724                 { "ATAPI Mic", 0x1 },
12725         },
12726 };
12727
12728 #define alc861vd_mux_enum_info alc_mux_enum_info
12729 #define alc861vd_mux_enum_get alc_mux_enum_get
12730 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
12731 #define alc861vd_mux_enum_put alc882_mux_enum_put
12732
12733 /*
12734  * 2ch mode
12735  */
12736 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
12737         { 2, NULL }
12738 };
12739
12740 /*
12741  * 6ch mode
12742  */
12743 static struct hda_verb alc861vd_6stack_ch6_init[] = {
12744         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12745         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12746         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12747         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12748         { } /* end */
12749 };
12750
12751 /*
12752  * 8ch mode
12753  */
12754 static struct hda_verb alc861vd_6stack_ch8_init[] = {
12755         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12756         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12757         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12758         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12759         { } /* end */
12760 };
12761
12762 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
12763         { 6, alc861vd_6stack_ch6_init },
12764         { 8, alc861vd_6stack_ch8_init },
12765 };
12766
12767 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
12768         {
12769                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12770                 .name = "Channel Mode",
12771                 .info = alc_ch_mode_info,
12772                 .get = alc_ch_mode_get,
12773                 .put = alc_ch_mode_put,
12774         },
12775         { } /* end */
12776 };
12777
12778 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
12779         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
12780         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
12781
12782         {
12783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12784                 /* The multiple "Capture Source" controls confuse alsamixer
12785                  * So call somewhat different..
12786                  */
12787                 /* .name = "Capture Source", */
12788                 .name = "Input Source",
12789                 .count = 1,
12790                 .info = alc861vd_mux_enum_info,
12791                 .get = alc861vd_mux_enum_get,
12792                 .put = alc861vd_mux_enum_put,
12793         },
12794         { } /* end */
12795 };
12796
12797 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
12798  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
12799  */
12800 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
12801         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12802         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12803
12804         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12805         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
12806
12807         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
12808                                 HDA_OUTPUT),
12809         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
12810                                 HDA_OUTPUT),
12811         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12812         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
12813
12814         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
12815         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
12816
12817         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12818
12819         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12822
12823         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12824         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12825         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12826
12827         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12828         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12829
12830         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12831         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12832
12833         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12834         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12835
12836         { } /* end */
12837 };
12838
12839 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
12840         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12841         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12842
12843         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12844
12845         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12846         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12847         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12848
12849         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12850         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12851         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12852
12853         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12854         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12855
12856         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12857         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12858
12859         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12860         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12861
12862         { } /* end */
12863 };
12864
12865 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
12866         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12867         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
12868         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12869
12870         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12871
12872         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12873         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12874         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12875
12876         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12877         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12878         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12879
12880         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12881         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12882
12883         { } /* end */
12884 };
12885
12886 /* Pin assignment: Speaker=0x14, HP = 0x15,
12887  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
12888  */
12889 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
12890         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12891         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
12892         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12893         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12894         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12895         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12896         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12897         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12898         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12899         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12900         HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
12901         HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
12902         { } /* end */
12903 };
12904
12905 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
12906  *                 Front Mic=0x18, ATAPI Mic = 0x19,
12907  */
12908 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
12909         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12910         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12911         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12912         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12913         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12914         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12915         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12916         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12917
12918         { } /* end */
12919 };
12920
12921 /*
12922  * generic initialization of ADC, input mixers and output mixers
12923  */
12924 static struct hda_verb alc861vd_volume_init_verbs[] = {
12925         /*
12926          * Unmute ADC0 and set the default input to mic-in
12927          */
12928         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12929         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12930
12931         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
12932          * the analog-loopback mixer widget
12933          */
12934         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12935         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12936         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12937         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12938         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12939         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12940
12941         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
12942         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12943         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12944         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12945         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
12946
12947         /*
12948          * Set up output mixers (0x02 - 0x05)
12949          */
12950         /* set vol=0 to output mixers */
12951         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12952         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12953         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12954         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12955
12956         /* set up input amps for analog loopback */
12957         /* Amp Indices: DAC = 0, mixer = 1 */
12958         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12959         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12960         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12961         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12962         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12963         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12964         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12965         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12966
12967         { }
12968 };
12969
12970 /*
12971  * 3-stack pin configuration:
12972  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
12973  */
12974 static struct hda_verb alc861vd_3stack_init_verbs[] = {
12975         /*
12976          * Set pin mode and muting
12977          */
12978         /* set front pin widgets 0x14 for output */
12979         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12980         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12981         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12982
12983         /* Mic (rear) pin: input vref at 80% */
12984         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12985         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12986         /* Front Mic pin: input vref at 80% */
12987         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12988         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12989         /* Line In pin: input */
12990         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12991         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12992         /* Line-2 In: Headphone output (output 0 - 0x0c) */
12993         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12994         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12995         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12996         /* CD pin widget for input */
12997         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12998
12999         { }
13000 };
13001
13002 /*
13003  * 6-stack pin configuration:
13004  */
13005 static struct hda_verb alc861vd_6stack_init_verbs[] = {
13006         /*
13007          * Set pin mode and muting
13008          */
13009         /* set front pin widgets 0x14 for output */
13010         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13011         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13012         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13013
13014         /* Rear Pin: output 1 (0x0d) */
13015         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13016         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13017         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13018         /* CLFE Pin: output 2 (0x0e) */
13019         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13020         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13021         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
13022         /* Side Pin: output 3 (0x0f) */
13023         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13024         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13025         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
13026
13027         /* Mic (rear) pin: input vref at 80% */
13028         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13029         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13030         /* Front Mic pin: input vref at 80% */
13031         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13032         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13033         /* Line In pin: input */
13034         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13035         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13036         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13037         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13038         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13039         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13040         /* CD pin widget for input */
13041         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13042
13043         { }
13044 };
13045
13046 static struct hda_verb alc861vd_eapd_verbs[] = {
13047         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13048         { }
13049 };
13050
13051 static struct hda_verb alc660vd_eapd_verbs[] = {
13052         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13053         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13054         { }
13055 };
13056
13057 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
13058         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13059         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13060         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
13061         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13062         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13063         {}
13064 };
13065
13066 /* toggle speaker-output according to the hp-jack state */
13067 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
13068 {
13069         unsigned int present;
13070         unsigned char bits;
13071
13072         present = snd_hda_codec_read(codec, 0x1b, 0,
13073                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13074         bits = present ? HDA_AMP_MUTE : 0;
13075         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13076                                  HDA_AMP_MUTE, bits);
13077 }
13078
13079 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
13080 {
13081         unsigned int present;
13082         unsigned char bits;
13083
13084         present = snd_hda_codec_read(codec, 0x18, 0,
13085                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13086         bits = present ? HDA_AMP_MUTE : 0;
13087         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
13088                                  HDA_AMP_MUTE, bits);
13089 }
13090
13091 static void alc861vd_lenovo_automute(struct hda_codec *codec)
13092 {
13093         alc861vd_lenovo_hp_automute(codec);
13094         alc861vd_lenovo_mic_automute(codec);
13095 }
13096
13097 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
13098                                         unsigned int res)
13099 {
13100         switch (res >> 26) {
13101         case ALC880_HP_EVENT:
13102                 alc861vd_lenovo_hp_automute(codec);
13103                 break;
13104         case ALC880_MIC_EVENT:
13105                 alc861vd_lenovo_mic_automute(codec);
13106                 break;
13107         }
13108 }
13109
13110 static struct hda_verb alc861vd_dallas_verbs[] = {
13111         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13112         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13113         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13114         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13115
13116         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13117         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13118         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13119         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13120         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13121         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13122         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13123         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13124
13125         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13126         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13127         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13128         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13129         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13130         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13131         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13132         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13133
13134         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
13135         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13136         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
13137         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13138         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13139         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13140         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13141         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13142
13143         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13144         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13145         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13146         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13147
13148         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13149         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13150         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13151
13152         { } /* end */
13153 };
13154
13155 /* toggle speaker-output according to the hp-jack state */
13156 static void alc861vd_dallas_automute(struct hda_codec *codec)
13157 {
13158         unsigned int present;
13159
13160         present = snd_hda_codec_read(codec, 0x15, 0,
13161                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13162         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13163                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13164 }
13165
13166 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
13167 {
13168         if ((res >> 26) == ALC880_HP_EVENT)
13169                 alc861vd_dallas_automute(codec);
13170 }
13171
13172 #ifdef CONFIG_SND_HDA_POWER_SAVE
13173 #define alc861vd_loopbacks      alc880_loopbacks
13174 #endif
13175
13176 /* pcm configuration: identiacal with ALC880 */
13177 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
13178 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
13179 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
13180 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
13181
13182 /*
13183  * configuration and preset
13184  */
13185 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
13186         [ALC660VD_3ST]          = "3stack-660",
13187         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
13188         [ALC861VD_3ST]          = "3stack",
13189         [ALC861VD_3ST_DIG]      = "3stack-digout",
13190         [ALC861VD_6ST_DIG]      = "6stack-digout",
13191         [ALC861VD_LENOVO]       = "lenovo",
13192         [ALC861VD_DALLAS]       = "dallas",
13193         [ALC861VD_HP]           = "hp",
13194         [ALC861VD_AUTO]         = "auto",
13195 };
13196
13197 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
13198         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
13199         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
13200         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
13201         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
13202         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
13203         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
13204         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
13205         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
13206         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
13207         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
13208         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
13209         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
13210         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
13211         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
13212         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
13213         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
13214         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
13215         {}
13216 };
13217
13218 static struct alc_config_preset alc861vd_presets[] = {
13219         [ALC660VD_3ST] = {
13220                 .mixers = { alc861vd_3st_mixer },
13221                 .init_verbs = { alc861vd_volume_init_verbs,
13222                                  alc861vd_3stack_init_verbs },
13223                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13224                 .dac_nids = alc660vd_dac_nids,
13225                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13226                 .channel_mode = alc861vd_3stack_2ch_modes,
13227                 .input_mux = &alc861vd_capture_source,
13228         },
13229         [ALC660VD_3ST_DIG] = {
13230                 .mixers = { alc861vd_3st_mixer },
13231                 .init_verbs = { alc861vd_volume_init_verbs,
13232                                  alc861vd_3stack_init_verbs },
13233                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13234                 .dac_nids = alc660vd_dac_nids,
13235                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13236                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13237                 .channel_mode = alc861vd_3stack_2ch_modes,
13238                 .input_mux = &alc861vd_capture_source,
13239         },
13240         [ALC861VD_3ST] = {
13241                 .mixers = { alc861vd_3st_mixer },
13242                 .init_verbs = { alc861vd_volume_init_verbs,
13243                                  alc861vd_3stack_init_verbs },
13244                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13245                 .dac_nids = alc861vd_dac_nids,
13246                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13247                 .channel_mode = alc861vd_3stack_2ch_modes,
13248                 .input_mux = &alc861vd_capture_source,
13249         },
13250         [ALC861VD_3ST_DIG] = {
13251                 .mixers = { alc861vd_3st_mixer },
13252                 .init_verbs = { alc861vd_volume_init_verbs,
13253                                  alc861vd_3stack_init_verbs },
13254                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13255                 .dac_nids = alc861vd_dac_nids,
13256                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13257                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13258                 .channel_mode = alc861vd_3stack_2ch_modes,
13259                 .input_mux = &alc861vd_capture_source,
13260         },
13261         [ALC861VD_6ST_DIG] = {
13262                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
13263                 .init_verbs = { alc861vd_volume_init_verbs,
13264                                 alc861vd_6stack_init_verbs },
13265                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13266                 .dac_nids = alc861vd_dac_nids,
13267                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13268                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
13269                 .channel_mode = alc861vd_6stack_modes,
13270                 .input_mux = &alc861vd_capture_source,
13271         },
13272         [ALC861VD_LENOVO] = {
13273                 .mixers = { alc861vd_lenovo_mixer },
13274                 .init_verbs = { alc861vd_volume_init_verbs,
13275                                 alc861vd_3stack_init_verbs,
13276                                 alc861vd_eapd_verbs,
13277                                 alc861vd_lenovo_unsol_verbs },
13278                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13279                 .dac_nids = alc660vd_dac_nids,
13280                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13281                 .channel_mode = alc861vd_3stack_2ch_modes,
13282                 .input_mux = &alc861vd_capture_source,
13283                 .unsol_event = alc861vd_lenovo_unsol_event,
13284                 .init_hook = alc861vd_lenovo_automute,
13285         },
13286         [ALC861VD_DALLAS] = {
13287                 .mixers = { alc861vd_dallas_mixer },
13288                 .init_verbs = { alc861vd_dallas_verbs },
13289                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13290                 .dac_nids = alc861vd_dac_nids,
13291                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13292                 .channel_mode = alc861vd_3stack_2ch_modes,
13293                 .input_mux = &alc861vd_dallas_capture_source,
13294                 .unsol_event = alc861vd_dallas_unsol_event,
13295                 .init_hook = alc861vd_dallas_automute,
13296         },
13297         [ALC861VD_HP] = {
13298                 .mixers = { alc861vd_hp_mixer },
13299                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
13300                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13301                 .dac_nids = alc861vd_dac_nids,
13302                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13303                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13304                 .channel_mode = alc861vd_3stack_2ch_modes,
13305                 .input_mux = &alc861vd_hp_capture_source,
13306                 .unsol_event = alc861vd_dallas_unsol_event,
13307                 .init_hook = alc861vd_dallas_automute,
13308         },
13309 };
13310
13311 /*
13312  * BIOS auto configuration
13313  */
13314 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
13315                                 hda_nid_t nid, int pin_type, int dac_idx)
13316 {
13317         alc_set_pin_output(codec, nid, pin_type);
13318 }
13319
13320 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
13321 {
13322         struct alc_spec *spec = codec->spec;
13323         int i;
13324
13325         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
13326         for (i = 0; i <= HDA_SIDE; i++) {
13327                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13328                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13329                 if (nid)
13330                         alc861vd_auto_set_output_and_unmute(codec, nid,
13331                                                             pin_type, i);
13332         }
13333 }
13334
13335
13336 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
13337 {
13338         struct alc_spec *spec = codec->spec;
13339         hda_nid_t pin;
13340
13341         pin = spec->autocfg.hp_pins[0];
13342         if (pin) /* connect to front and  use dac 0 */
13343                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
13344         pin = spec->autocfg.speaker_pins[0];
13345         if (pin)
13346                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13347 }
13348
13349 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
13350 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
13351
13352 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
13353 {
13354         struct alc_spec *spec = codec->spec;
13355         int i;
13356
13357         for (i = 0; i < AUTO_PIN_LAST; i++) {
13358                 hda_nid_t nid = spec->autocfg.input_pins[i];
13359                 if (alc861vd_is_input_pin(nid)) {
13360                         snd_hda_codec_write(codec, nid, 0,
13361                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
13362                                         i <= AUTO_PIN_FRONT_MIC ?
13363                                                         PIN_VREF80 : PIN_IN);
13364                         if (nid != ALC861VD_PIN_CD_NID)
13365                                 snd_hda_codec_write(codec, nid, 0,
13366                                                 AC_VERB_SET_AMP_GAIN_MUTE,
13367                                                 AMP_OUT_MUTE);
13368                 }
13369         }
13370 }
13371
13372 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
13373
13374 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
13375 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
13376
13377 /* add playback controls from the parsed DAC table */
13378 /* Based on ALC880 version. But ALC861VD has separate,
13379  * different NIDs for mute/unmute switch and volume control */
13380 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
13381                                              const struct auto_pin_cfg *cfg)
13382 {
13383         char name[32];
13384         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
13385         hda_nid_t nid_v, nid_s;
13386         int i, err;
13387
13388         for (i = 0; i < cfg->line_outs; i++) {
13389                 if (!spec->multiout.dac_nids[i])
13390                         continue;
13391                 nid_v = alc861vd_idx_to_mixer_vol(
13392                                 alc880_dac_to_idx(
13393                                         spec->multiout.dac_nids[i]));
13394                 nid_s = alc861vd_idx_to_mixer_switch(
13395                                 alc880_dac_to_idx(
13396                                         spec->multiout.dac_nids[i]));
13397
13398                 if (i == 2) {
13399                         /* Center/LFE */
13400                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13401                                           "Center Playback Volume",
13402                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
13403                                                               HDA_OUTPUT));
13404                         if (err < 0)
13405                                 return err;
13406                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13407                                           "LFE Playback Volume",
13408                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
13409                                                               HDA_OUTPUT));
13410                         if (err < 0)
13411                                 return err;
13412                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13413                                           "Center Playback Switch",
13414                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
13415                                                               HDA_INPUT));
13416                         if (err < 0)
13417                                 return err;
13418                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13419                                           "LFE Playback Switch",
13420                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
13421                                                               HDA_INPUT));
13422                         if (err < 0)
13423                                 return err;
13424                 } else {
13425                         sprintf(name, "%s Playback Volume", chname[i]);
13426                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13427                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
13428                                                               HDA_OUTPUT));
13429                         if (err < 0)
13430                                 return err;
13431                         sprintf(name, "%s Playback Switch", chname[i]);
13432                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13433                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
13434                                                               HDA_INPUT));
13435                         if (err < 0)
13436                                 return err;
13437                 }
13438         }
13439         return 0;
13440 }
13441
13442 /* add playback controls for speaker and HP outputs */
13443 /* Based on ALC880 version. But ALC861VD has separate,
13444  * different NIDs for mute/unmute switch and volume control */
13445 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
13446                                         hda_nid_t pin, const char *pfx)
13447 {
13448         hda_nid_t nid_v, nid_s;
13449         int err;
13450         char name[32];
13451
13452         if (!pin)
13453                 return 0;
13454
13455         if (alc880_is_fixed_pin(pin)) {
13456                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
13457                 /* specify the DAC as the extra output */
13458                 if (!spec->multiout.hp_nid)
13459                         spec->multiout.hp_nid = nid_v;
13460                 else
13461                         spec->multiout.extra_out_nid[0] = nid_v;
13462                 /* control HP volume/switch on the output mixer amp */
13463                 nid_v = alc861vd_idx_to_mixer_vol(
13464                                 alc880_fixed_pin_idx(pin));
13465                 nid_s = alc861vd_idx_to_mixer_switch(
13466                                 alc880_fixed_pin_idx(pin));
13467
13468                 sprintf(name, "%s Playback Volume", pfx);
13469                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13470                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
13471                 if (err < 0)
13472                         return err;
13473                 sprintf(name, "%s Playback Switch", pfx);
13474                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13475                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
13476                 if (err < 0)
13477                         return err;
13478         } else if (alc880_is_multi_pin(pin)) {
13479                 /* set manual connection */
13480                 /* we have only a switch on HP-out PIN */
13481                 sprintf(name, "%s Playback Switch", pfx);
13482                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
13483                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
13484                 if (err < 0)
13485                         return err;
13486         }
13487         return 0;
13488 }
13489
13490 /* parse the BIOS configuration and set up the alc_spec
13491  * return 1 if successful, 0 if the proper config is not found,
13492  * or a negative error code
13493  * Based on ALC880 version - had to change it to override
13494  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
13495 static int alc861vd_parse_auto_config(struct hda_codec *codec)
13496 {
13497         struct alc_spec *spec = codec->spec;
13498         int err;
13499         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
13500
13501         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13502                                            alc861vd_ignore);
13503         if (err < 0)
13504                 return err;
13505         if (!spec->autocfg.line_outs)
13506                 return 0; /* can't find valid BIOS pin config */
13507
13508         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
13509         if (err < 0)
13510                 return err;
13511         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
13512         if (err < 0)
13513                 return err;
13514         err = alc861vd_auto_create_extra_out(spec,
13515                                              spec->autocfg.speaker_pins[0],
13516                                              "Speaker");
13517         if (err < 0)
13518                 return err;
13519         err = alc861vd_auto_create_extra_out(spec,
13520                                              spec->autocfg.hp_pins[0],
13521                                              "Headphone");
13522         if (err < 0)
13523                 return err;
13524         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
13525         if (err < 0)
13526                 return err;
13527
13528         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13529
13530         if (spec->autocfg.dig_out_pin)
13531                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
13532
13533         if (spec->kctl_alloc)
13534                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13535
13536         spec->init_verbs[spec->num_init_verbs++]
13537                 = alc861vd_volume_init_verbs;
13538
13539         spec->num_mux_defs = 1;
13540         spec->input_mux = &spec->private_imux;
13541
13542         err = alc_auto_add_mic_boost(codec);
13543         if (err < 0)
13544                 return err;
13545
13546         return 1;
13547 }
13548
13549 /* additional initialization for auto-configuration model */
13550 static void alc861vd_auto_init(struct hda_codec *codec)
13551 {
13552         struct alc_spec *spec = codec->spec;
13553         alc861vd_auto_init_multi_out(codec);
13554         alc861vd_auto_init_hp_out(codec);
13555         alc861vd_auto_init_analog_input(codec);
13556         alc861vd_auto_init_input_src(codec);
13557         if (spec->unsol_event)
13558                 alc_sku_automute(codec);
13559 }
13560
13561 static int patch_alc861vd(struct hda_codec *codec)
13562 {
13563         struct alc_spec *spec;
13564         int err, board_config;
13565
13566         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13567         if (spec == NULL)
13568                 return -ENOMEM;
13569
13570         codec->spec = spec;
13571
13572         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
13573                                                   alc861vd_models,
13574                                                   alc861vd_cfg_tbl);
13575
13576         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
13577                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
13578                         "ALC861VD, trying auto-probe from BIOS...\n");
13579                 board_config = ALC861VD_AUTO;
13580         }
13581
13582         if (board_config == ALC861VD_AUTO) {
13583                 /* automatic parse from the BIOS config */
13584                 err = alc861vd_parse_auto_config(codec);
13585                 if (err < 0) {
13586                         alc_free(codec);
13587                         return err;
13588                 } else if (!err) {
13589                         printk(KERN_INFO
13590                                "hda_codec: Cannot set up configuration "
13591                                "from BIOS.  Using base mode...\n");
13592                         board_config = ALC861VD_3ST;
13593                 }
13594         }
13595
13596         if (board_config != ALC861VD_AUTO)
13597                 setup_preset(spec, &alc861vd_presets[board_config]);
13598
13599         if (codec->vendor_id == 0x10ec0660) {
13600                 spec->stream_name_analog = "ALC660-VD Analog";
13601                 spec->stream_name_digital = "ALC660-VD Digital";
13602                 /* always turn on EAPD */
13603                 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
13604         } else {
13605                 spec->stream_name_analog = "ALC861VD Analog";
13606                 spec->stream_name_digital = "ALC861VD Digital";
13607         }
13608
13609         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
13610         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
13611
13612         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
13613         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
13614
13615         spec->adc_nids = alc861vd_adc_nids;
13616         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
13617         spec->capsrc_nids = alc861vd_capsrc_nids;
13618
13619         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
13620         spec->num_mixers++;
13621
13622         spec->vmaster_nid = 0x02;
13623
13624         codec->patch_ops = alc_patch_ops;
13625
13626         if (board_config == ALC861VD_AUTO)
13627                 spec->init_hook = alc861vd_auto_init;
13628 #ifdef CONFIG_SND_HDA_POWER_SAVE
13629         if (!spec->loopback.amplist)
13630                 spec->loopback.amplist = alc861vd_loopbacks;
13631 #endif
13632
13633         return 0;
13634 }
13635
13636 /*
13637  * ALC662 support
13638  *
13639  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
13640  * configuration.  Each pin widget can choose any input DACs and a mixer.
13641  * Each ADC is connected from a mixer of all inputs.  This makes possible
13642  * 6-channel independent captures.
13643  *
13644  * In addition, an independent DAC for the multi-playback (not used in this
13645  * driver yet).
13646  */
13647 #define ALC662_DIGOUT_NID       0x06
13648 #define ALC662_DIGIN_NID        0x0a
13649
13650 static hda_nid_t alc662_dac_nids[4] = {
13651         /* front, rear, clfe, rear_surr */
13652         0x02, 0x03, 0x04
13653 };
13654
13655 static hda_nid_t alc662_adc_nids[1] = {
13656         /* ADC1-2 */
13657         0x09,
13658 };
13659
13660 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
13661
13662 /* input MUX */
13663 /* FIXME: should be a matrix-type input source selection */
13664 static struct hda_input_mux alc662_capture_source = {
13665         .num_items = 4,
13666         .items = {
13667                 { "Mic", 0x0 },
13668                 { "Front Mic", 0x1 },
13669                 { "Line", 0x2 },
13670                 { "CD", 0x4 },
13671         },
13672 };
13673
13674 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
13675         .num_items = 2,
13676         .items = {
13677                 { "Mic", 0x1 },
13678                 { "Line", 0x2 },
13679         },
13680 };
13681
13682 static struct hda_input_mux alc662_eeepc_capture_source = {
13683         .num_items = 2,
13684         .items = {
13685                 { "i-Mic", 0x1 },
13686                 { "e-Mic", 0x0 },
13687         },
13688 };
13689
13690 static struct hda_input_mux alc663_capture_source = {
13691         .num_items = 3,
13692         .items = {
13693                 { "Mic", 0x0 },
13694                 { "Front Mic", 0x1 },
13695                 { "Line", 0x2 },
13696         },
13697 };
13698
13699 static struct hda_input_mux alc663_m51va_capture_source = {
13700         .num_items = 2,
13701         .items = {
13702                 { "Ext-Mic", 0x0 },
13703                 { "D-Mic", 0x9 },
13704         },
13705 };
13706
13707 #define alc662_mux_enum_info alc_mux_enum_info
13708 #define alc662_mux_enum_get alc_mux_enum_get
13709 #define alc662_mux_enum_put alc882_mux_enum_put
13710
13711 /*
13712  * 2ch mode
13713  */
13714 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
13715         { 2, NULL }
13716 };
13717
13718 /*
13719  * 2ch mode
13720  */
13721 static struct hda_verb alc662_3ST_ch2_init[] = {
13722         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
13723         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
13724         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
13725         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
13726         { } /* end */
13727 };
13728
13729 /*
13730  * 6ch mode
13731  */
13732 static struct hda_verb alc662_3ST_ch6_init[] = {
13733         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13734         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
13735         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
13736         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13737         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
13738         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
13739         { } /* end */
13740 };
13741
13742 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
13743         { 2, alc662_3ST_ch2_init },
13744         { 6, alc662_3ST_ch6_init },
13745 };
13746
13747 /*
13748  * 2ch mode
13749  */
13750 static struct hda_verb alc662_sixstack_ch6_init[] = {
13751         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13752         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13753         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13754         { } /* end */
13755 };
13756
13757 /*
13758  * 6ch mode
13759  */
13760 static struct hda_verb alc662_sixstack_ch8_init[] = {
13761         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13762         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13763         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13764         { } /* end */
13765 };
13766
13767 static struct hda_channel_mode alc662_5stack_modes[2] = {
13768         { 2, alc662_sixstack_ch6_init },
13769         { 6, alc662_sixstack_ch8_init },
13770 };
13771
13772 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13773  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13774  */
13775
13776 static struct snd_kcontrol_new alc662_base_mixer[] = {
13777         /* output mixer control */
13778         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13779         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13780         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13781         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
13782         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13783         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13784         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
13785         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
13786         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13787
13788         /*Input mixer control */
13789         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
13790         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
13791         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
13792         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
13793         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
13794         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
13795         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
13796         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
13797         { } /* end */
13798 };
13799
13800 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
13801         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13802         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13803         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13804         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13805         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13806         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13807         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13808         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13809         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13810         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13811         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13812         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13813         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13814         { } /* end */
13815 };
13816
13817 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
13818         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13819         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13820         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13821         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
13822         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13823         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13824         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
13825         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
13826         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13827         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13828         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13829         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13830         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13831         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13832         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13833         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13834         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13835         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13836         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13837         { } /* end */
13838 };
13839
13840 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
13841         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13842         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
13843         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13844         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
13845         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13846         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13847         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13848         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13849         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13850         { } /* end */
13851 };
13852
13853 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
13854         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13855
13856         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13857         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13858
13859         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
13860         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13861         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13862
13863         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
13864         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13865         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13866         { } /* end */
13867 };
13868
13869 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
13870         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13871         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13872         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13873         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
13874         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13875         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13876         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
13877         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
13878         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13879         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
13880         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13881         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13882         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13883         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13884         { } /* end */
13885 };
13886
13887 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
13888         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13889         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13890         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13893         HDA_CODEC_MUTE("DMic Playback Switch", 0x23, 0x9, HDA_INPUT),
13894         { } /* end */
13895 };
13896
13897 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
13898         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13899         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13900         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13901         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13902         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13903
13904         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13905         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13906         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13907         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13908         { } /* end */
13909 };
13910
13911 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
13912         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13913         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13914         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13915
13916         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13917         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13918         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13919         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13920         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13921         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13922         { } /* end */
13923 };
13924
13925 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
13926         {
13927                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13928                 .name = "Channel Mode",
13929                 .info = alc_ch_mode_info,
13930                 .get = alc_ch_mode_get,
13931                 .put = alc_ch_mode_put,
13932         },
13933         { } /* end */
13934 };
13935
13936 static struct hda_verb alc662_init_verbs[] = {
13937         /* ADC: mute amp left and right */
13938         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13939         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13940         /* Front mixer: unmute input/output amp left and right (volume = 0) */
13941
13942         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13943         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13944         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13945         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13946         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13947
13948         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13949         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13950         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13951         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13952         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13953         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13954
13955         /* Front Pin: output 0 (0x0c) */
13956         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13957         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13958
13959         /* Rear Pin: output 1 (0x0d) */
13960         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13961         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13962
13963         /* CLFE Pin: output 2 (0x0e) */
13964         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13965         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13966
13967         /* Mic (rear) pin: input vref at 80% */
13968         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13969         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13970         /* Front Mic pin: input vref at 80% */
13971         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13972         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13973         /* Line In pin: input */
13974         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13975         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13976         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13977         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13978         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13979         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13980         /* CD pin widget for input */
13981         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13982
13983         /* FIXME: use matrix-type input source selection */
13984         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
13985         /* Input mixer */
13986         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13987         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13988         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13989         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13990
13991         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13992         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13993         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13994         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13995
13996         /* always trun on EAPD */
13997         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13998         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13999
14000         { }
14001 };
14002
14003 static struct hda_verb alc662_sue_init_verbs[] = {
14004         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
14005         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
14006         {}
14007 };
14008
14009 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
14010         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14011         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14012         {}
14013 };
14014
14015 /* Set Unsolicited Event*/
14016 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
14017         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14018         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14019         {}
14020 };
14021
14022 /*
14023  * generic initialization of ADC, input mixers and output mixers
14024  */
14025 static struct hda_verb alc662_auto_init_verbs[] = {
14026         /*
14027          * Unmute ADC and set the default input to mic-in
14028          */
14029         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14030         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14031
14032         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
14033          * mixer widget
14034          * Note: PASD motherboards uses the Line In 2 as the input for front
14035          * panel mic (mic 2)
14036          */
14037         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14038         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14039         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14040         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14041         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14042         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14043
14044         /*
14045          * Set up output mixers (0x0c - 0x0f)
14046          */
14047         /* set vol=0 to output mixers */
14048         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14049         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14050         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14051
14052         /* set up input amps for analog loopback */
14053         /* Amp Indices: DAC = 0, mixer = 1 */
14054         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14055         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14056         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14057         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14058         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14059         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14060
14061
14062         /* FIXME: use matrix-type input source selection */
14063         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
14064         /* Input mixer */
14065         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14066         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14067         { }
14068 };
14069
14070 static struct hda_verb alc663_m51va_init_verbs[] = {
14071         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14072         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14073         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
14074
14075         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
14076
14077         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14078         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14079         {}
14080 };
14081
14082 static struct hda_verb alc663_g71v_init_verbs[] = {
14083         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14084         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
14085         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
14086
14087         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14088         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14089         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
14090
14091         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
14092         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
14093         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
14094         {}
14095 };
14096
14097 static struct hda_verb alc663_g50v_init_verbs[] = {
14098         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14099         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14100         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
14101
14102         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14103         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14104         {}
14105 };
14106
14107 /* capture mixer elements */
14108 static struct snd_kcontrol_new alc662_capture_mixer[] = {
14109         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14110         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14111         {
14112                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14113                 /* The multiple "Capture Source" controls confuse alsamixer
14114                  * So call somewhat different..
14115                  */
14116                 /* .name = "Capture Source", */
14117                 .name = "Input Source",
14118                 .count = 1,
14119                 .info = alc662_mux_enum_info,
14120                 .get = alc662_mux_enum_get,
14121                 .put = alc662_mux_enum_put,
14122         },
14123         { } /* end */
14124 };
14125
14126 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
14127 {
14128         unsigned int present;
14129         unsigned char bits;
14130
14131         present = snd_hda_codec_read(codec, 0x14, 0,
14132                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14133         bits = present ? HDA_AMP_MUTE : 0;
14134         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14135                                  HDA_AMP_MUTE, bits);
14136 }
14137
14138 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
14139 {
14140         unsigned int present;
14141         unsigned char bits;
14142
14143         present = snd_hda_codec_read(codec, 0x1b, 0,
14144                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14145         bits = present ? HDA_AMP_MUTE : 0;
14146         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14147                                  HDA_AMP_MUTE, bits);
14148         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14149                                  HDA_AMP_MUTE, bits);
14150 }
14151
14152 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
14153                                            unsigned int res)
14154 {
14155         if ((res >> 26) == ALC880_HP_EVENT)
14156                 alc662_lenovo_101e_all_automute(codec);
14157         if ((res >> 26) == ALC880_FRONT_EVENT)
14158                 alc662_lenovo_101e_ispeaker_automute(codec);
14159 }
14160
14161 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
14162 {
14163         unsigned int present;
14164
14165         present = snd_hda_codec_read(codec, 0x18, 0,
14166                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14167         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14168                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14169         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14170                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14171         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14172                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
14173         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14174                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
14175 }
14176
14177 /* unsolicited event for HP jack sensing */
14178 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
14179                                      unsigned int res)
14180 {
14181         if ((res >> 26) == ALC880_HP_EVENT)
14182                 alc262_hippo1_automute( codec );
14183
14184         if ((res >> 26) == ALC880_MIC_EVENT)
14185                 alc662_eeepc_mic_automute(codec);
14186 }
14187
14188 static void alc662_eeepc_inithook(struct hda_codec *codec)
14189 {
14190         alc262_hippo1_automute( codec );
14191         alc662_eeepc_mic_automute(codec);
14192 }
14193
14194 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
14195 {
14196         unsigned int mute;
14197         unsigned int present;
14198
14199         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
14200         present = snd_hda_codec_read(codec, 0x14, 0,
14201                                      AC_VERB_GET_PIN_SENSE, 0);
14202         present = (present & 0x80000000) != 0;
14203         if (present) {
14204                 /* mute internal speaker */
14205                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
14206                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
14207         } else {
14208                 /* unmute internal speaker if necessary */
14209                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
14210                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
14211                                          HDA_AMP_MUTE, mute);
14212         }
14213 }
14214
14215 /* unsolicited event for HP jack sensing */
14216 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
14217                                           unsigned int res)
14218 {
14219         if ((res >> 26) == ALC880_HP_EVENT)
14220                 alc662_eeepc_ep20_automute(codec);
14221 }
14222
14223 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
14224 {
14225         alc662_eeepc_ep20_automute(codec);
14226 }
14227
14228 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
14229 {
14230         unsigned int present;
14231         unsigned char bits;
14232
14233         present = snd_hda_codec_read(codec, 0x21, 0,
14234                                      AC_VERB_GET_PIN_SENSE, 0)
14235                 & AC_PINSENSE_PRESENCE;
14236         bits = present ? HDA_AMP_MUTE : 0;
14237         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14238                                  HDA_AMP_MUTE, bits);
14239 }
14240
14241 static void alc663_m51va_mic_automute(struct hda_codec *codec)
14242 {
14243         unsigned int present;
14244
14245         present = snd_hda_codec_read(codec, 0x18, 0,
14246                                      AC_VERB_GET_PIN_SENSE, 0)
14247                 & AC_PINSENSE_PRESENCE;
14248         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14249                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14250         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14251                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14252         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14253                             0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
14254         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14255                             0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
14256 }
14257
14258 static void alc663_m51va_unsol_event(struct hda_codec *codec,
14259                                            unsigned int res)
14260 {
14261         switch (res >> 26) {
14262         case ALC880_HP_EVENT:
14263                 alc663_m51va_speaker_automute(codec);
14264                 break;
14265         case ALC880_MIC_EVENT:
14266                 alc663_m51va_mic_automute(codec);
14267                 break;
14268         }
14269 }
14270
14271 static void alc663_m51va_inithook(struct hda_codec *codec)
14272 {
14273         alc663_m51va_speaker_automute(codec);
14274         alc663_m51va_mic_automute(codec);
14275 }
14276
14277 static void alc663_g71v_hp_automute(struct hda_codec *codec)
14278 {
14279         unsigned int present;
14280         unsigned char bits;
14281
14282         present = snd_hda_codec_read(codec, 0x21, 0,
14283                                      AC_VERB_GET_PIN_SENSE, 0)
14284                 & AC_PINSENSE_PRESENCE;
14285         bits = present ? HDA_AMP_MUTE : 0;
14286         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14287                                  HDA_AMP_MUTE, bits);
14288         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14289                                  HDA_AMP_MUTE, bits);
14290 }
14291
14292 static void alc663_g71v_front_automute(struct hda_codec *codec)
14293 {
14294         unsigned int present;
14295         unsigned char bits;
14296
14297         present = snd_hda_codec_read(codec, 0x15, 0,
14298                                      AC_VERB_GET_PIN_SENSE, 0)
14299                 & AC_PINSENSE_PRESENCE;
14300         bits = present ? HDA_AMP_MUTE : 0;
14301         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14302                                  HDA_AMP_MUTE, bits);
14303 }
14304
14305 static void alc663_g71v_unsol_event(struct hda_codec *codec,
14306                                            unsigned int res)
14307 {
14308         switch (res >> 26) {
14309         case ALC880_HP_EVENT:
14310                 alc663_g71v_hp_automute(codec);
14311                 break;
14312         case ALC880_FRONT_EVENT:
14313                 alc663_g71v_front_automute(codec);
14314                 break;
14315         case ALC880_MIC_EVENT:
14316                 alc662_eeepc_mic_automute(codec);
14317                 break;
14318         }
14319 }
14320
14321 static void alc663_g71v_inithook(struct hda_codec *codec)
14322 {
14323         alc663_g71v_front_automute(codec);
14324         alc663_g71v_hp_automute(codec);
14325         alc662_eeepc_mic_automute(codec);
14326 }
14327
14328 static void alc663_g50v_unsol_event(struct hda_codec *codec,
14329                                            unsigned int res)
14330 {
14331         switch (res >> 26) {
14332         case ALC880_HP_EVENT:
14333                 alc663_m51va_speaker_automute(codec);
14334                 break;
14335         case ALC880_MIC_EVENT:
14336                 alc662_eeepc_mic_automute(codec);
14337                 break;
14338         }
14339 }
14340
14341 static void alc663_g50v_inithook(struct hda_codec *codec)
14342 {
14343         alc663_m51va_speaker_automute(codec);
14344         alc662_eeepc_mic_automute(codec);
14345 }
14346
14347 #ifdef CONFIG_SND_HDA_POWER_SAVE
14348 #define alc662_loopbacks        alc880_loopbacks
14349 #endif
14350
14351
14352 /* pcm configuration: identiacal with ALC880 */
14353 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
14354 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
14355 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
14356 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
14357
14358 /*
14359  * configuration and preset
14360  */
14361 static const char *alc662_models[ALC662_MODEL_LAST] = {
14362         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
14363         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
14364         [ALC662_3ST_6ch]        = "3stack-6ch",
14365         [ALC662_5ST_DIG]        = "6stack-dig",
14366         [ALC662_LENOVO_101E]    = "lenovo-101e",
14367         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
14368         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
14369         [ALC663_ASUS_M51VA] = "m51va",
14370         [ALC663_ASUS_G71V] = "g71v",
14371         [ALC663_ASUS_H13] = "h13",
14372         [ALC663_ASUS_G50V] = "g50v",
14373         [ALC662_AUTO]           = "auto",
14374 };
14375
14376 static struct snd_pci_quirk alc662_cfg_tbl[] = {
14377         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS G71V", ALC663_ASUS_G71V),
14378         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
14379         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS M51VA", ALC663_ASUS_G50V),
14380         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
14381         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
14382         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
14383         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
14384         SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
14385         SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
14386         SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
14387         {}
14388 };
14389
14390 static struct alc_config_preset alc662_presets[] = {
14391         [ALC662_3ST_2ch_DIG] = {
14392                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
14393                 .init_verbs = { alc662_init_verbs },
14394                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14395                 .dac_nids = alc662_dac_nids,
14396                 .dig_out_nid = ALC662_DIGOUT_NID,
14397                 .dig_in_nid = ALC662_DIGIN_NID,
14398                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14399                 .channel_mode = alc662_3ST_2ch_modes,
14400                 .input_mux = &alc662_capture_source,
14401         },
14402         [ALC662_3ST_6ch_DIG] = {
14403                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
14404                             alc662_capture_mixer },
14405                 .init_verbs = { alc662_init_verbs },
14406                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14407                 .dac_nids = alc662_dac_nids,
14408                 .dig_out_nid = ALC662_DIGOUT_NID,
14409                 .dig_in_nid = ALC662_DIGIN_NID,
14410                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14411                 .channel_mode = alc662_3ST_6ch_modes,
14412                 .need_dac_fix = 1,
14413                 .input_mux = &alc662_capture_source,
14414         },
14415         [ALC662_3ST_6ch] = {
14416                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
14417                             alc662_capture_mixer },
14418                 .init_verbs = { alc662_init_verbs },
14419                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14420                 .dac_nids = alc662_dac_nids,
14421                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14422                 .channel_mode = alc662_3ST_6ch_modes,
14423                 .need_dac_fix = 1,
14424                 .input_mux = &alc662_capture_source,
14425         },
14426         [ALC662_5ST_DIG] = {
14427                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
14428                             alc662_capture_mixer },
14429                 .init_verbs = { alc662_init_verbs },
14430                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14431                 .dac_nids = alc662_dac_nids,
14432                 .dig_out_nid = ALC662_DIGOUT_NID,
14433                 .dig_in_nid = ALC662_DIGIN_NID,
14434                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
14435                 .channel_mode = alc662_5stack_modes,
14436                 .input_mux = &alc662_capture_source,
14437         },
14438         [ALC662_LENOVO_101E] = {
14439                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
14440                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
14441                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14442                 .dac_nids = alc662_dac_nids,
14443                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14444                 .channel_mode = alc662_3ST_2ch_modes,
14445                 .input_mux = &alc662_lenovo_101e_capture_source,
14446                 .unsol_event = alc662_lenovo_101e_unsol_event,
14447                 .init_hook = alc662_lenovo_101e_all_automute,
14448         },
14449         [ALC662_ASUS_EEEPC_P701] = {
14450                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
14451                 .init_verbs = { alc662_init_verbs,
14452                                 alc662_eeepc_sue_init_verbs },
14453                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14454                 .dac_nids = alc662_dac_nids,
14455                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14456                 .channel_mode = alc662_3ST_2ch_modes,
14457                 .input_mux = &alc662_eeepc_capture_source,
14458                 .unsol_event = alc662_eeepc_unsol_event,
14459                 .init_hook = alc662_eeepc_inithook,
14460         },
14461         [ALC662_ASUS_EEEPC_EP20] = {
14462                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
14463                             alc662_chmode_mixer },
14464                 .init_verbs = { alc662_init_verbs,
14465                                 alc662_eeepc_ep20_sue_init_verbs },
14466                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14467                 .dac_nids = alc662_dac_nids,
14468                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14469                 .channel_mode = alc662_3ST_6ch_modes,
14470                 .input_mux = &alc662_lenovo_101e_capture_source,
14471                 .unsol_event = alc662_eeepc_ep20_unsol_event,
14472                 .init_hook = alc662_eeepc_ep20_inithook,
14473         },
14474         [ALC663_ASUS_M51VA] = {
14475                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
14476                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
14477                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14478                 .dac_nids = alc662_dac_nids,
14479                 .dig_out_nid = ALC662_DIGOUT_NID,
14480                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14481                 .channel_mode = alc662_3ST_2ch_modes,
14482                 .input_mux = &alc663_m51va_capture_source,
14483                 .unsol_event = alc663_m51va_unsol_event,
14484                 .init_hook = alc663_m51va_inithook,
14485         },
14486         [ALC663_ASUS_G71V] = {
14487                 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
14488                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
14489                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14490                 .dac_nids = alc662_dac_nids,
14491                 .dig_out_nid = ALC662_DIGOUT_NID,
14492                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14493                 .channel_mode = alc662_3ST_2ch_modes,
14494                 .input_mux = &alc662_eeepc_capture_source,
14495                 .unsol_event = alc663_g71v_unsol_event,
14496                 .init_hook = alc663_g71v_inithook,
14497         },
14498         [ALC663_ASUS_H13] = {
14499                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
14500                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
14501                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14502                 .dac_nids = alc662_dac_nids,
14503                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14504                 .channel_mode = alc662_3ST_2ch_modes,
14505                 .input_mux = &alc663_m51va_capture_source,
14506                 .unsol_event = alc663_m51va_unsol_event,
14507                 .init_hook = alc663_m51va_inithook,
14508         },
14509         [ALC663_ASUS_G50V] = {
14510                 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
14511                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
14512                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14513                 .dac_nids = alc662_dac_nids,
14514                 .dig_out_nid = ALC662_DIGOUT_NID,
14515                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14516                 .channel_mode = alc662_3ST_6ch_modes,
14517                 .input_mux = &alc663_capture_source,
14518                 .unsol_event = alc663_g50v_unsol_event,
14519                 .init_hook = alc663_g50v_inithook,
14520         },
14521 };
14522
14523
14524 /*
14525  * BIOS auto configuration
14526  */
14527
14528 /* add playback controls from the parsed DAC table */
14529 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
14530                                              const struct auto_pin_cfg *cfg)
14531 {
14532         char name[32];
14533         static const char *chname[4] = {
14534                 "Front", "Surround", NULL /*CLFE*/, "Side"
14535         };
14536         hda_nid_t nid;
14537         int i, err;
14538
14539         for (i = 0; i < cfg->line_outs; i++) {
14540                 if (!spec->multiout.dac_nids[i])
14541                         continue;
14542                 nid = alc880_idx_to_dac(i);
14543                 if (i == 2) {
14544                         /* Center/LFE */
14545                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14546                                           "Center Playback Volume",
14547                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
14548                                                               HDA_OUTPUT));
14549                         if (err < 0)
14550                                 return err;
14551                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14552                                           "LFE Playback Volume",
14553                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
14554                                                               HDA_OUTPUT));
14555                         if (err < 0)
14556                                 return err;
14557                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14558                                           "Center Playback Switch",
14559                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
14560                                                               HDA_INPUT));
14561                         if (err < 0)
14562                                 return err;
14563                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14564                                           "LFE Playback Switch",
14565                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
14566                                                               HDA_INPUT));
14567                         if (err < 0)
14568                                 return err;
14569                 } else {
14570                         sprintf(name, "%s Playback Volume", chname[i]);
14571                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14572                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
14573                                                               HDA_OUTPUT));
14574                         if (err < 0)
14575                                 return err;
14576                         sprintf(name, "%s Playback Switch", chname[i]);
14577                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14578                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
14579                                                               HDA_INPUT));
14580                         if (err < 0)
14581                                 return err;
14582                 }
14583         }
14584         return 0;
14585 }
14586
14587 /* add playback controls for speaker and HP outputs */
14588 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
14589                                         const char *pfx)
14590 {
14591         hda_nid_t nid;
14592         int err;
14593         char name[32];
14594
14595         if (!pin)
14596                 return 0;
14597
14598         if (alc880_is_fixed_pin(pin)) {
14599                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14600                 /* printk("DAC nid=%x\n",nid); */
14601                 /* specify the DAC as the extra output */
14602                 if (!spec->multiout.hp_nid)
14603                         spec->multiout.hp_nid = nid;
14604                 else
14605                         spec->multiout.extra_out_nid[0] = nid;
14606                 /* control HP volume/switch on the output mixer amp */
14607                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14608                 sprintf(name, "%s Playback Volume", pfx);
14609                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14610                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
14611                 if (err < 0)
14612                         return err;
14613                 sprintf(name, "%s Playback Switch", pfx);
14614                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14615                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
14616                 if (err < 0)
14617                         return err;
14618         } else if (alc880_is_multi_pin(pin)) {
14619                 /* set manual connection */
14620                 /* we have only a switch on HP-out PIN */
14621                 sprintf(name, "%s Playback Switch", pfx);
14622                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14623                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14624                 if (err < 0)
14625                         return err;
14626         }
14627         return 0;
14628 }
14629
14630 /* create playback/capture controls for input pins */
14631 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
14632                                                 const struct auto_pin_cfg *cfg)
14633 {
14634         struct hda_input_mux *imux = &spec->private_imux;
14635         int i, err, idx;
14636
14637         for (i = 0; i < AUTO_PIN_LAST; i++) {
14638                 if (alc880_is_input_pin(cfg->input_pins[i])) {
14639                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
14640                         err = new_analog_input(spec, cfg->input_pins[i],
14641                                                auto_pin_cfg_labels[i],
14642                                                idx, 0x0b);
14643                         if (err < 0)
14644                                 return err;
14645                         imux->items[imux->num_items].label =
14646                                 auto_pin_cfg_labels[i];
14647                         imux->items[imux->num_items].index =
14648                                 alc880_input_pin_idx(cfg->input_pins[i]);
14649                         imux->num_items++;
14650                 }
14651         }
14652         return 0;
14653 }
14654
14655 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
14656                                               hda_nid_t nid, int pin_type,
14657                                               int dac_idx)
14658 {
14659         alc_set_pin_output(codec, nid, pin_type);
14660         /* need the manual connection? */
14661         if (alc880_is_multi_pin(nid)) {
14662                 struct alc_spec *spec = codec->spec;
14663                 int idx = alc880_multi_pin_idx(nid);
14664                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
14665                                     AC_VERB_SET_CONNECT_SEL,
14666                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
14667         }
14668 }
14669
14670 static void alc662_auto_init_multi_out(struct hda_codec *codec)
14671 {
14672         struct alc_spec *spec = codec->spec;
14673         int i;
14674
14675         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14676         for (i = 0; i <= HDA_SIDE; i++) {
14677                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14678                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14679                 if (nid)
14680                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
14681                                                           i);
14682         }
14683 }
14684
14685 static void alc662_auto_init_hp_out(struct hda_codec *codec)
14686 {
14687         struct alc_spec *spec = codec->spec;
14688         hda_nid_t pin;
14689
14690         pin = spec->autocfg.hp_pins[0];
14691         if (pin) /* connect to front */
14692                 /* use dac 0 */
14693                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14694         pin = spec->autocfg.speaker_pins[0];
14695         if (pin)
14696                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14697 }
14698
14699 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
14700 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
14701
14702 static void alc662_auto_init_analog_input(struct hda_codec *codec)
14703 {
14704         struct alc_spec *spec = codec->spec;
14705         int i;
14706
14707         for (i = 0; i < AUTO_PIN_LAST; i++) {
14708                 hda_nid_t nid = spec->autocfg.input_pins[i];
14709                 if (alc662_is_input_pin(nid)) {
14710                         snd_hda_codec_write(codec, nid, 0,
14711                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
14712                                             (i <= AUTO_PIN_FRONT_MIC ?
14713                                              PIN_VREF80 : PIN_IN));
14714                         if (nid != ALC662_PIN_CD_NID)
14715                                 snd_hda_codec_write(codec, nid, 0,
14716                                                     AC_VERB_SET_AMP_GAIN_MUTE,
14717                                                     AMP_OUT_MUTE);
14718                 }
14719         }
14720 }
14721
14722 #define alc662_auto_init_input_src      alc882_auto_init_input_src
14723
14724 static int alc662_parse_auto_config(struct hda_codec *codec)
14725 {
14726         struct alc_spec *spec = codec->spec;
14727         int err;
14728         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
14729
14730         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14731                                            alc662_ignore);
14732         if (err < 0)
14733                 return err;
14734         if (!spec->autocfg.line_outs)
14735                 return 0; /* can't find valid BIOS pin config */
14736
14737         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14738         if (err < 0)
14739                 return err;
14740         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
14741         if (err < 0)
14742                 return err;
14743         err = alc662_auto_create_extra_out(spec,
14744                                            spec->autocfg.speaker_pins[0],
14745                                            "Speaker");
14746         if (err < 0)
14747                 return err;
14748         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
14749                                            "Headphone");
14750         if (err < 0)
14751                 return err;
14752         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
14753         if (err < 0)
14754                 return err;
14755
14756         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14757
14758         if (spec->autocfg.dig_out_pin)
14759                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
14760
14761         if (spec->kctl_alloc)
14762                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14763
14764         spec->num_mux_defs = 1;
14765         spec->input_mux = &spec->private_imux;
14766
14767         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
14768         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
14769         spec->num_mixers++;
14770         return 1;
14771 }
14772
14773 /* additional initialization for auto-configuration model */
14774 static void alc662_auto_init(struct hda_codec *codec)
14775 {
14776         struct alc_spec *spec = codec->spec;
14777         alc662_auto_init_multi_out(codec);
14778         alc662_auto_init_hp_out(codec);
14779         alc662_auto_init_analog_input(codec);
14780         alc662_auto_init_input_src(codec);
14781         if (spec->unsol_event)
14782                 alc_sku_automute(codec);
14783 }
14784
14785 static int patch_alc662(struct hda_codec *codec)
14786 {
14787         struct alc_spec *spec;
14788         int err, board_config;
14789
14790         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14791         if (!spec)
14792                 return -ENOMEM;
14793
14794         codec->spec = spec;
14795
14796         alc_fix_pll_init(codec, 0x20, 0x04, 15);
14797
14798         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
14799                                                   alc662_models,
14800                                                   alc662_cfg_tbl);
14801         if (board_config < 0) {
14802                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
14803                        "trying auto-probe from BIOS...\n");
14804                 board_config = ALC662_AUTO;
14805         }
14806
14807         if (board_config == ALC662_AUTO) {
14808                 /* automatic parse from the BIOS config */
14809                 err = alc662_parse_auto_config(codec);
14810                 if (err < 0) {
14811                         alc_free(codec);
14812                         return err;
14813                 } else if (!err) {
14814                         printk(KERN_INFO
14815                                "hda_codec: Cannot set up configuration "
14816                                "from BIOS.  Using base mode...\n");
14817                         board_config = ALC662_3ST_2ch_DIG;
14818                 }
14819         }
14820
14821         if (board_config != ALC662_AUTO)
14822                 setup_preset(spec, &alc662_presets[board_config]);
14823
14824         if (codec->vendor_id == 0x10ec0663) {
14825                 spec->stream_name_analog = "ALC663 Analog";
14826                 spec->stream_name_digital = "ALC663 Digital";
14827         } else {
14828                 spec->stream_name_analog = "ALC662 Analog";
14829                 spec->stream_name_digital = "ALC662 Digital";
14830         }
14831
14832         spec->stream_analog_playback = &alc662_pcm_analog_playback;
14833         spec->stream_analog_capture = &alc662_pcm_analog_capture;
14834
14835         spec->stream_digital_playback = &alc662_pcm_digital_playback;
14836         spec->stream_digital_capture = &alc662_pcm_digital_capture;
14837
14838         spec->adc_nids = alc662_adc_nids;
14839         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
14840         spec->capsrc_nids = alc662_capsrc_nids;
14841
14842         spec->vmaster_nid = 0x02;
14843
14844         codec->patch_ops = alc_patch_ops;
14845         if (board_config == ALC662_AUTO)
14846                 spec->init_hook = alc662_auto_init;
14847 #ifdef CONFIG_SND_HDA_POWER_SAVE
14848         if (!spec->loopback.amplist)
14849                 spec->loopback.amplist = alc662_loopbacks;
14850 #endif
14851
14852         return 0;
14853 }
14854
14855 /*
14856  * patch entries
14857  */
14858 struct hda_codec_preset snd_hda_preset_realtek[] = {
14859         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
14860         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
14861         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
14862         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
14863         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
14864         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
14865           .patch = patch_alc861 },
14866         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
14867         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
14868         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
14869         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
14870           .patch = patch_alc883 },
14871         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
14872           .patch = patch_alc662 },
14873         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
14874         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
14875         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
14876         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
14877         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
14878           .patch = patch_alc882 }, /* should be patch_alc883() in future */
14879         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
14880         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
14881         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
14882         {} /* terminator */
14883 };