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 /* add mic boosts if needed */
6441 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6442 {
6443         struct alc_spec *spec = codec->spec;
6444         int err;
6445         hda_nid_t nid;
6446
6447         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6448         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6449                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6450                                   "Mic Boost",
6451                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6452                 if (err < 0)
6453                         return err;
6454         }
6455         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6456         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6457                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6458                                   "Front Mic Boost",
6459                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6460                 if (err < 0)
6461                         return err;
6462         }
6463         return 0;
6464 }
6465
6466 /* almost identical with ALC880 parser... */
6467 static int alc882_parse_auto_config(struct hda_codec *codec)
6468 {
6469         struct alc_spec *spec = codec->spec;
6470         int err = alc880_parse_auto_config(codec);
6471
6472         if (err < 0)
6473                 return err;
6474         else if (!err)
6475                 return 0; /* no config found */
6476
6477         err = alc_auto_add_mic_boost(codec);
6478         if (err < 0)
6479                 return err;
6480
6481         /* hack - override the init verbs */
6482         spec->init_verbs[0] = alc882_auto_init_verbs;
6483
6484         return 1; /* config found */
6485 }
6486
6487 /* additional initialization for auto-configuration model */
6488 static void alc882_auto_init(struct hda_codec *codec)
6489 {
6490         struct alc_spec *spec = codec->spec;
6491         alc882_auto_init_multi_out(codec);
6492         alc882_auto_init_hp_out(codec);
6493         alc882_auto_init_analog_input(codec);
6494         if (spec->unsol_event)
6495                 alc_sku_automute(codec);
6496 }
6497
6498 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6499
6500 static int patch_alc882(struct hda_codec *codec)
6501 {
6502         struct alc_spec *spec;
6503         int err, board_config;
6504
6505         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6506         if (spec == NULL)
6507                 return -ENOMEM;
6508
6509         codec->spec = spec;
6510
6511         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6512                                                   alc882_models,
6513                                                   alc882_cfg_tbl);
6514
6515         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6516                 /* Pick up systems that don't supply PCI SSID */
6517                 switch (codec->subsystem_id) {
6518                 case 0x106b0c00: /* Mac Pro */
6519                         board_config = ALC885_MACPRO;
6520                         break;
6521                 case 0x106b1000: /* iMac 24 */
6522                         board_config = ALC885_IMAC24;
6523                         break;
6524                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
6525                 case 0x106b2c00: /* Macbook Pro rev3 */
6526                 case 0x106b3600: /* Macbook 3.1 */
6527                         board_config = ALC885_MBP3;
6528                         break;
6529                 default:
6530                         /* ALC889A is handled better as ALC888-compatible */
6531                         if (codec->revision_id == 0x100103) {
6532                                 alc_free(codec);
6533                                 return patch_alc883(codec);
6534                         }
6535                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6536                                          "trying auto-probe from BIOS...\n");
6537                         board_config = ALC882_AUTO;
6538                 }
6539         }
6540
6541         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6542
6543         if (board_config == ALC882_AUTO) {
6544                 /* automatic parse from the BIOS config */
6545                 err = alc882_parse_auto_config(codec);
6546                 if (err < 0) {
6547                         alc_free(codec);
6548                         return err;
6549                 } else if (!err) {
6550                         printk(KERN_INFO
6551                                "hda_codec: Cannot set up configuration "
6552                                "from BIOS.  Using base mode...\n");
6553                         board_config = ALC882_3ST_DIG;
6554                 }
6555         }
6556
6557         if (board_config != ALC882_AUTO)
6558                 setup_preset(spec, &alc882_presets[board_config]);
6559
6560         if (codec->vendor_id == 0x10ec0885) {
6561                 spec->stream_name_analog = "ALC885 Analog";
6562                 spec->stream_name_digital = "ALC885 Digital";
6563         } else {
6564                 spec->stream_name_analog = "ALC882 Analog";
6565                 spec->stream_name_digital = "ALC882 Digital";
6566         }
6567
6568         spec->stream_analog_playback = &alc882_pcm_analog_playback;
6569         spec->stream_analog_capture = &alc882_pcm_analog_capture;
6570         /* FIXME: setup DAC5 */
6571         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6572         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6573
6574         spec->stream_digital_playback = &alc882_pcm_digital_playback;
6575         spec->stream_digital_capture = &alc882_pcm_digital_capture;
6576
6577         if (!spec->adc_nids && spec->input_mux) {
6578                 /* check whether NID 0x07 is valid */
6579                 unsigned int wcap = get_wcaps(codec, 0x07);
6580                 /* get type */
6581                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6582                 if (wcap != AC_WID_AUD_IN) {
6583                         spec->adc_nids = alc882_adc_nids_alt;
6584                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6585                         spec->capsrc_nids = alc882_capsrc_nids_alt;
6586                         spec->mixers[spec->num_mixers] =
6587                                 alc882_capture_alt_mixer;
6588                         spec->num_mixers++;
6589                 } else {
6590                         spec->adc_nids = alc882_adc_nids;
6591                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6592                         spec->capsrc_nids = alc882_capsrc_nids;
6593                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6594                         spec->num_mixers++;
6595                 }
6596         }
6597
6598         spec->vmaster_nid = 0x0c;
6599
6600         codec->patch_ops = alc_patch_ops;
6601         if (board_config == ALC882_AUTO)
6602                 spec->init_hook = alc882_auto_init;
6603 #ifdef CONFIG_SND_HDA_POWER_SAVE
6604         if (!spec->loopback.amplist)
6605                 spec->loopback.amplist = alc882_loopbacks;
6606 #endif
6607
6608         return 0;
6609 }
6610
6611 /*
6612  * ALC883 support
6613  *
6614  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6615  * configuration.  Each pin widget can choose any input DACs and a mixer.
6616  * Each ADC is connected from a mixer of all inputs.  This makes possible
6617  * 6-channel independent captures.
6618  *
6619  * In addition, an independent DAC for the multi-playback (not used in this
6620  * driver yet).
6621  */
6622 #define ALC883_DIGOUT_NID       0x06
6623 #define ALC883_DIGIN_NID        0x0a
6624
6625 static hda_nid_t alc883_dac_nids[4] = {
6626         /* front, rear, clfe, rear_surr */
6627         0x02, 0x03, 0x04, 0x05
6628 };
6629
6630 static hda_nid_t alc883_adc_nids[2] = {
6631         /* ADC1-2 */
6632         0x08, 0x09,
6633 };
6634
6635 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6636
6637 /* input MUX */
6638 /* FIXME: should be a matrix-type input source selection */
6639
6640 static struct hda_input_mux alc883_capture_source = {
6641         .num_items = 4,
6642         .items = {
6643                 { "Mic", 0x0 },
6644                 { "Front Mic", 0x1 },
6645                 { "Line", 0x2 },
6646                 { "CD", 0x4 },
6647         },
6648 };
6649
6650 static struct hda_input_mux alc883_3stack_6ch_intel = {
6651         .num_items = 4,
6652         .items = {
6653                 { "Mic", 0x1 },
6654                 { "Front Mic", 0x0 },
6655                 { "Line", 0x2 },
6656                 { "CD", 0x4 },
6657         },
6658 };
6659
6660 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6661         .num_items = 2,
6662         .items = {
6663                 { "Mic", 0x1 },
6664                 { "Line", 0x2 },
6665         },
6666 };
6667
6668 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6669         .num_items = 4,
6670         .items = {
6671                 { "Mic", 0x0 },
6672                 { "iMic", 0x1 },
6673                 { "Line", 0x2 },
6674                 { "CD", 0x4 },
6675         },
6676 };
6677
6678 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6679         .num_items = 2,
6680         .items = {
6681                 { "Mic", 0x0 },
6682                 { "Int Mic", 0x1 },
6683         },
6684 };
6685
6686 #define alc883_mux_enum_info alc_mux_enum_info
6687 #define alc883_mux_enum_get alc_mux_enum_get
6688 /* ALC883 has the ALC882-type input selection */
6689 #define alc883_mux_enum_put alc882_mux_enum_put
6690
6691 /*
6692  * 2ch mode
6693  */
6694 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6695         { 2, NULL }
6696 };
6697
6698 /*
6699  * 2ch mode
6700  */
6701 static struct hda_verb alc883_3ST_ch2_init[] = {
6702         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6703         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6704         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6705         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6706         { } /* end */
6707 };
6708
6709 /*
6710  * 4ch mode
6711  */
6712 static struct hda_verb alc883_3ST_ch4_init[] = {
6713         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6714         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6715         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6716         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6717         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6718         { } /* end */
6719 };
6720
6721 /*
6722  * 6ch mode
6723  */
6724 static struct hda_verb alc883_3ST_ch6_init[] = {
6725         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6726         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6727         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6728         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6729         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6730         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6731         { } /* end */
6732 };
6733
6734 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
6735         { 2, alc883_3ST_ch2_init },
6736         { 4, alc883_3ST_ch4_init },
6737         { 6, alc883_3ST_ch6_init },
6738 };
6739
6740 /*
6741  * 2ch mode
6742  */
6743 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6744         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6745         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6746         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6747         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6748         { } /* end */
6749 };
6750
6751 /*
6752  * 4ch mode
6753  */
6754 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6755         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6756         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6757         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6758         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6759         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6760         { } /* end */
6761 };
6762
6763 /*
6764  * 6ch mode
6765  */
6766 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6767         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6768         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6769         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6770         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6771         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6772         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6773         { } /* end */
6774 };
6775
6776 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6777         { 2, alc883_3ST_ch2_intel_init },
6778         { 4, alc883_3ST_ch4_intel_init },
6779         { 6, alc883_3ST_ch6_intel_init },
6780 };
6781
6782 /*
6783  * 6ch mode
6784  */
6785 static struct hda_verb alc883_sixstack_ch6_init[] = {
6786         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6787         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6788         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6789         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6790         { } /* end */
6791 };
6792
6793 /*
6794  * 8ch mode
6795  */
6796 static struct hda_verb alc883_sixstack_ch8_init[] = {
6797         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6798         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6799         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6800         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6801         { } /* end */
6802 };
6803
6804 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6805         { 6, alc883_sixstack_ch6_init },
6806         { 8, alc883_sixstack_ch8_init },
6807 };
6808
6809 static struct hda_verb alc883_medion_eapd_verbs[] = {
6810         /* eanable EAPD on medion laptop */
6811         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6812         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
6813         { }
6814 };
6815
6816 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6817  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6818  */
6819
6820 static struct snd_kcontrol_new alc883_base_mixer[] = {
6821         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6822         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6823         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6824         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6825         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6826         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6827         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6828         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6829         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6830         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6831         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6832         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6833         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6834         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6835         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6836         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6837         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6838         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6839         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6840         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6841         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6842         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6843         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6844         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6845         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6846         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6847         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6848         {
6849                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6850                 /* .name = "Capture Source", */
6851                 .name = "Input Source",
6852                 .count = 2,
6853                 .info = alc883_mux_enum_info,
6854                 .get = alc883_mux_enum_get,
6855                 .put = alc883_mux_enum_put,
6856         },
6857         { } /* end */
6858 };
6859
6860 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
6861         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6862         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6863         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6864         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6865         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6866         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6867         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6868         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6869         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6870         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6871         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6872         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6873         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6874         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6875         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6876         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6877         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6878         {
6879                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6880                 /* .name = "Capture Source", */
6881                 .name = "Input Source",
6882                 .count = 2,
6883                 .info = alc883_mux_enum_info,
6884                 .get = alc883_mux_enum_get,
6885                 .put = alc883_mux_enum_put,
6886         },
6887         { } /* end */
6888 };
6889
6890 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
6891         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6892         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
6893         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6894         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6895         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6896         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6897         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6898         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6899         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
6900         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6901         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6902         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6903         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6904         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6905         {
6906                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6907                 /* .name = "Capture Source", */
6908                 .name = "Input Source",
6909                 .count = 2,
6910                 .info = alc883_mux_enum_info,
6911                 .get = alc883_mux_enum_get,
6912                 .put = alc883_mux_enum_put,
6913         },
6914         { } /* end */
6915 };
6916
6917 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
6918         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6919         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
6920         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6921         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6922         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6923         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6924         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6925         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6926         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
6927         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6928         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6929         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6930         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6931         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6932         {
6933                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6934                 /* .name = "Capture Source", */
6935                 .name = "Input Source",
6936                 .count = 2,
6937                 .info = alc883_mux_enum_info,
6938                 .get = alc883_mux_enum_get,
6939                 .put = alc883_mux_enum_put,
6940         },
6941         { } /* end */
6942 };
6943
6944 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
6945         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6946         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6947         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6948         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6949         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6950         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6951         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6952         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6953         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6954         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6955         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6956         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6957         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6958         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6959         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6960         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6961         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6962         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6963         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6964         {
6965                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6966                 /* .name = "Capture Source", */
6967                 .name = "Input Source",
6968                 .count = 2,
6969                 .info = alc883_mux_enum_info,
6970                 .get = alc883_mux_enum_get,
6971                 .put = alc883_mux_enum_put,
6972         },
6973         { } /* end */
6974 };
6975
6976 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
6977         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6978         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6979         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6980         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6981         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6982         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6983         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6984         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6985         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6986         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6987         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6988         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6989         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6990         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6991         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6992         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6993         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6994         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6995         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6996         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6997         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6998         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6999         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7000         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7001         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7002         {
7003                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7004                 /* .name = "Capture Source", */
7005                 .name = "Input Source",
7006                 .count = 2,
7007                 .info = alc883_mux_enum_info,
7008                 .get = alc883_mux_enum_get,
7009                 .put = alc883_mux_enum_put,
7010         },
7011         { } /* end */
7012 };
7013
7014 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7015         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7016         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7017         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7018         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7019         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7020                               HDA_OUTPUT),
7021         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7022         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7023         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7024         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7025         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7026         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7027         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7028         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7029         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7030         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7031         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7032         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7033         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7034         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7035         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7036         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7037         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7038         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7039         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7040         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7041         {
7042                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7043                 /* .name = "Capture Source", */
7044                 .name = "Input Source",
7045                 .count = 2,
7046                 .info = alc883_mux_enum_info,
7047                 .get = alc883_mux_enum_get,
7048                 .put = alc883_mux_enum_put,
7049         },
7050         { } /* end */
7051 };
7052
7053 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7054         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7055         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7056         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7057         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7058         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7059         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7060         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7061         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7062         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7063         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7064         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7065         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7066         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7067         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7068         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7069         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7070         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7071         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7072         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7073         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7074         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7075         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7076         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7077
7078         {
7079                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7080                 /* .name = "Capture Source", */
7081                 .name = "Input Source",
7082                 .count = 1,
7083                 .info = alc883_mux_enum_info,
7084                 .get = alc883_mux_enum_get,
7085                 .put = alc883_mux_enum_put,
7086         },
7087         { } /* end */
7088 };
7089
7090 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7091         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7092         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7093         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7094         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7095         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7096         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7097         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7098         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7099         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7100         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7101         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7102         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7103         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7104         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7105         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7106         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7107         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7108         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7109         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7110         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7111         {
7112                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7113                 /* .name = "Capture Source", */
7114                 .name = "Input Source",
7115                 .count = 2,
7116                 .info = alc883_mux_enum_info,
7117                 .get = alc883_mux_enum_get,
7118                 .put = alc883_mux_enum_put,
7119         },
7120         { } /* end */
7121 };
7122
7123 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7124         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7125         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7126         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7127         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7128         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7130         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7131         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7132         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7133         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7134         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7135         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7136         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7137         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7138         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7139         {
7140                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7141                 /* .name = "Capture Source", */
7142                 .name = "Input Source",
7143                 .count = 2,
7144                 .info = alc883_mux_enum_info,
7145                 .get = alc883_mux_enum_get,
7146                 .put = alc883_mux_enum_put,
7147         },
7148         { } /* end */
7149 };
7150
7151 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7152         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7153         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7154         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7155         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7156         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7157         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7158         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7159         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7160         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7161         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7162         {
7163                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7164                 /* .name = "Capture Source", */
7165                 .name = "Input Source",
7166                 .count = 1,
7167                 .info = alc883_mux_enum_info,
7168                 .get = alc883_mux_enum_get,
7169                 .put = alc883_mux_enum_put,
7170         },
7171         { } /* end */
7172 };
7173
7174 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7175         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7176         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7177         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7178         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7179         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7181         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7182         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7183         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7184         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7185         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7186         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7187         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7188         {
7189                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7190                 /* .name = "Capture Source", */
7191                 .name = "Input Source",
7192                 .count = 2,
7193                 .info = alc883_mux_enum_info,
7194                 .get = alc883_mux_enum_get,
7195                 .put = alc883_mux_enum_put,
7196         },
7197         { } /* end */
7198 };
7199
7200 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7201         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7202         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7203         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7204         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7205         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7206         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7207         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7208         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7209         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7210         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7211         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7212         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7213         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7214         {
7215                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7216                 /* .name = "Capture Source", */
7217                 .name = "Input Source",
7218                 .count = 2,
7219                 .info = alc883_mux_enum_info,
7220                 .get = alc883_mux_enum_get,
7221                 .put = alc883_mux_enum_put,
7222         },
7223         { } /* end */
7224 };
7225
7226 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7227         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7228         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7229         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7230         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7231         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7232         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7233         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7234         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7235         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7236         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7237         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7238         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7239         {
7240                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7241                 /* .name = "Capture Source", */
7242                 .name = "Input Source",
7243                 .count = 2,
7244                 .info = alc883_mux_enum_info,
7245                 .get = alc883_mux_enum_get,
7246                 .put = alc883_mux_enum_put,
7247         },
7248         { } /* end */
7249 };
7250
7251 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7252         {
7253                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7254                 .name = "Channel Mode",
7255                 .info = alc_ch_mode_info,
7256                 .get = alc_ch_mode_get,
7257                 .put = alc_ch_mode_put,
7258         },
7259         { } /* end */
7260 };
7261
7262 static struct hda_verb alc883_init_verbs[] = {
7263         /* ADC1: mute amp left and right */
7264         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7265         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7266         /* ADC2: mute amp left and right */
7267         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7268         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7269         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7270         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7271         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7272         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7273         /* Rear mixer */
7274         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7275         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7276         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7277         /* CLFE mixer */
7278         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7279         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7280         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7281         /* Side mixer */
7282         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7283         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7284         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7285
7286         /* mute analog input loopbacks */
7287         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7288         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7289         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7290         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7291         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7292
7293         /* Front Pin: output 0 (0x0c) */
7294         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7295         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7296         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7297         /* Rear Pin: output 1 (0x0d) */
7298         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7299         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7300         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7301         /* CLFE Pin: output 2 (0x0e) */
7302         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7303         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7304         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7305         /* Side Pin: output 3 (0x0f) */
7306         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7307         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7308         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7309         /* Mic (rear) pin: input vref at 80% */
7310         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7311         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7312         /* Front Mic pin: input vref at 80% */
7313         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7314         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7315         /* Line In pin: input */
7316         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7317         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7318         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7319         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7320         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7321         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7322         /* CD pin widget for input */
7323         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7324
7325         /* FIXME: use matrix-type input source selection */
7326         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7327         /* Input mixer2 */
7328         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7329         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7330         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7331         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7332         /* Input mixer3 */
7333         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7334         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7335         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7336         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7337         { }
7338 };
7339
7340 /* toggle speaker-output according to the hp-jack state */
7341 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7342 {
7343         unsigned int present;
7344
7345         present = snd_hda_codec_read(codec, 0x15, 0,
7346                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7347         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7348                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7349         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7350                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7351 }
7352
7353 /* auto-toggle front mic */
7354 /*
7355 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7356 {
7357         unsigned int present;
7358         unsigned char bits;
7359
7360         present = snd_hda_codec_read(codec, 0x18, 0,
7361                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7362         bits = present ? HDA_AMP_MUTE : 0;
7363         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7364 }
7365 */
7366
7367 static void alc883_mitac_automute(struct hda_codec *codec)
7368 {
7369         alc883_mitac_hp_automute(codec);
7370         /* alc883_mitac_mic_automute(codec); */
7371 }
7372
7373 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7374                                            unsigned int res)
7375 {
7376         switch (res >> 26) {
7377         case ALC880_HP_EVENT:
7378                 alc883_mitac_hp_automute(codec);
7379                 break;
7380         case ALC880_MIC_EVENT:
7381                 /* alc883_mitac_mic_automute(codec); */
7382                 break;
7383         }
7384 }
7385
7386 static struct hda_verb alc883_mitac_verbs[] = {
7387         /* HP */
7388         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7389         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7390         /* Subwoofer */
7391         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7392         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7393
7394         /* enable unsolicited event */
7395         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7396         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7397
7398         { } /* end */
7399 };
7400
7401 static struct hda_verb alc883_clevo_m720_verbs[] = {
7402         /* HP */
7403         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7404         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7405         /* Int speaker */
7406         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7407         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7408
7409         /* enable unsolicited event */
7410         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7411         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7412
7413         { } /* end */
7414 };
7415
7416 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7417         /* HP */
7418         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7419         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7420         /* Subwoofer */
7421         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7422         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7423
7424         /* enable unsolicited event */
7425         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7426
7427         { } /* end */
7428 };
7429
7430 static struct hda_verb alc883_tagra_verbs[] = {
7431         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7432         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7433
7434         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7435         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7436
7437         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7438         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7439         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7440
7441         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7442         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7443         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7444         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7445
7446         { } /* end */
7447 };
7448
7449 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7450         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7451         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7452         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7453         { } /* end */
7454 };
7455
7456 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7457         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7458         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7459         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7460         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7461         { } /* end */
7462 };
7463
7464 static struct hda_verb alc888_lenovo_ms7195_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         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7468         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7469         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7470         { } /* end */
7471 };
7472
7473 static struct hda_verb alc883_haier_w66_verbs[] = {
7474         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7475         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7476
7477         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7478
7479         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7480         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7481         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7482         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7483         { } /* end */
7484 };
7485
7486 static struct hda_verb alc888_3st_hp_verbs[] = {
7487         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7488         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7489         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7490         { }
7491 };
7492
7493 static struct hda_verb alc888_6st_dell_verbs[] = {
7494         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7495         { }
7496 };
7497
7498 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7499         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7500         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7501         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7502         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7503         { }
7504 };
7505
7506 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7507         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7508         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7509         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7510         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7511         { }
7512 };
7513
7514 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7515         { 2, alc888_3st_hp_2ch_init },
7516         { 6, alc888_3st_hp_6ch_init },
7517 };
7518
7519 /* toggle front-jack and RCA according to the hp-jack state */
7520 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7521 {
7522         unsigned int present;
7523
7524         present = snd_hda_codec_read(codec, 0x1b, 0,
7525                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7526         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7527                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7528         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7529                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7530 }
7531
7532 /* toggle RCA according to the front-jack state */
7533 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7534 {
7535         unsigned int present;
7536
7537         present = snd_hda_codec_read(codec, 0x14, 0,
7538                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7539         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7540                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7541 }
7542
7543 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7544                                              unsigned int res)
7545 {
7546         if ((res >> 26) == ALC880_HP_EVENT)
7547                 alc888_lenovo_ms7195_front_automute(codec);
7548         if ((res >> 26) == ALC880_FRONT_EVENT)
7549                 alc888_lenovo_ms7195_rca_automute(codec);
7550 }
7551
7552 static struct hda_verb alc883_medion_md2_verbs[] = {
7553         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7554         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7555
7556         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7557
7558         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7559         { } /* end */
7560 };
7561
7562 /* toggle speaker-output according to the hp-jack state */
7563 static void alc883_medion_md2_automute(struct hda_codec *codec)
7564 {
7565         unsigned int present;
7566
7567         present = snd_hda_codec_read(codec, 0x14, 0,
7568                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7569         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7570                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7571 }
7572
7573 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7574                                           unsigned int res)
7575 {
7576         if ((res >> 26) == ALC880_HP_EVENT)
7577                 alc883_medion_md2_automute(codec);
7578 }
7579
7580 /* toggle speaker-output according to the hp-jack state */
7581 static void alc883_tagra_automute(struct hda_codec *codec)
7582 {
7583         unsigned int present;
7584         unsigned char bits;
7585
7586         present = snd_hda_codec_read(codec, 0x14, 0,
7587                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7588         bits = present ? HDA_AMP_MUTE : 0;
7589         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7590                                  HDA_AMP_MUTE, bits);
7591         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7592                                   present ? 1 : 3);
7593 }
7594
7595 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7596 {
7597         if ((res >> 26) == ALC880_HP_EVENT)
7598                 alc883_tagra_automute(codec);
7599 }
7600
7601 /* toggle speaker-output according to the hp-jack state */
7602 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7603 {
7604         unsigned int present;
7605         unsigned char bits;
7606
7607         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7608                 & AC_PINSENSE_PRESENCE;
7609         bits = present ? HDA_AMP_MUTE : 0;
7610         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7611                                  HDA_AMP_MUTE, bits);
7612 }
7613
7614 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7615 {
7616         unsigned int present;
7617
7618         present = snd_hda_codec_read(codec, 0x18, 0,
7619                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7620         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7621                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7622 }
7623
7624 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7625 {
7626         alc883_clevo_m720_hp_automute(codec);
7627         alc883_clevo_m720_mic_automute(codec);
7628 }
7629
7630 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7631                                            unsigned int res)
7632 {
7633         switch (res >> 26) {
7634         case ALC880_HP_EVENT:
7635                 alc883_clevo_m720_hp_automute(codec);
7636                 break;
7637         case ALC880_MIC_EVENT:
7638                 alc883_clevo_m720_mic_automute(codec);
7639                 break;
7640         }
7641 }
7642
7643 /* toggle speaker-output according to the hp-jack state */
7644 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
7645 {
7646         unsigned int present;
7647         unsigned char bits;
7648
7649         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
7650                 & AC_PINSENSE_PRESENCE;
7651         bits = present ? HDA_AMP_MUTE : 0;
7652         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7653                                  HDA_AMP_MUTE, bits);
7654 }
7655
7656 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
7657                                                   unsigned int res)
7658 {
7659         if ((res >> 26) == ALC880_HP_EVENT)
7660                 alc883_2ch_fujitsu_pi2515_automute(codec);
7661 }
7662
7663 static void alc883_haier_w66_automute(struct hda_codec *codec)
7664 {
7665         unsigned int present;
7666         unsigned char bits;
7667
7668         present = snd_hda_codec_read(codec, 0x1b, 0,
7669                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7670         bits = present ? 0x80 : 0;
7671         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7672                                  0x80, bits);
7673 }
7674
7675 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
7676                                          unsigned int res)
7677 {
7678         if ((res >> 26) == ALC880_HP_EVENT)
7679                 alc883_haier_w66_automute(codec);
7680 }
7681
7682 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
7683 {
7684         unsigned int present;
7685         unsigned char bits;
7686
7687         present = snd_hda_codec_read(codec, 0x14, 0,
7688                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7689         bits = present ? HDA_AMP_MUTE : 0;
7690         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7691                                  HDA_AMP_MUTE, bits);
7692 }
7693
7694 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
7695 {
7696         unsigned int present;
7697         unsigned char bits;
7698
7699         present = snd_hda_codec_read(codec, 0x1b, 0,
7700                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7701         bits = present ? HDA_AMP_MUTE : 0;
7702         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7703                                  HDA_AMP_MUTE, bits);
7704         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7705                                  HDA_AMP_MUTE, bits);
7706 }
7707
7708 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
7709                                            unsigned int res)
7710 {
7711         if ((res >> 26) == ALC880_HP_EVENT)
7712                 alc883_lenovo_101e_all_automute(codec);
7713         if ((res >> 26) == ALC880_FRONT_EVENT)
7714                 alc883_lenovo_101e_ispeaker_automute(codec);
7715 }
7716
7717 /* toggle speaker-output according to the hp-jack state */
7718 static void alc883_acer_aspire_automute(struct hda_codec *codec)
7719 {
7720         unsigned int present;
7721
7722         present = snd_hda_codec_read(codec, 0x14, 0,
7723                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7724         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7725                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7726         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7727                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7728 }
7729
7730 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
7731                                            unsigned int res)
7732 {
7733         if ((res >> 26) == ALC880_HP_EVENT)
7734                 alc883_acer_aspire_automute(codec);
7735 }
7736
7737 static struct hda_verb alc883_acer_eapd_verbs[] = {
7738         /* HP Pin: output 0 (0x0c) */
7739         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7740         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7741         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7742         /* Front Pin: output 0 (0x0c) */
7743         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7744         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7745         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7746         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
7747         /* eanable EAPD on medion laptop */
7748         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7749         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
7750         /* enable unsolicited event */
7751         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7752         { }
7753 };
7754
7755 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
7756 {
7757         unsigned int present;
7758
7759         present = snd_hda_codec_read(codec, 0x1b, 0,
7760                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7761         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7762                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7763         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7764                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7765         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7766                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7767         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7768                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7769 }
7770
7771 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
7772                                              unsigned int res)
7773 {
7774         switch (res >> 26) {
7775         case ALC880_HP_EVENT:
7776                 printk("hp_event\n");
7777                 alc888_6st_dell_front_automute(codec);
7778                 break;
7779         }
7780 }
7781
7782 /*
7783  * generic initialization of ADC, input mixers and output mixers
7784  */
7785 static struct hda_verb alc883_auto_init_verbs[] = {
7786         /*
7787          * Unmute ADC0-2 and set the default input to mic-in
7788          */
7789         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7790         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7791         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7792         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7793
7794         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7795          * mixer widget
7796          * Note: PASD motherboards uses the Line In 2 as the input for
7797          * front panel mic (mic 2)
7798          */
7799         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7800         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7801         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7802         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7803         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7804         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7805
7806         /*
7807          * Set up output mixers (0x0c - 0x0f)
7808          */
7809         /* set vol=0 to output mixers */
7810         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7811         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7812         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7813         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7814         /* set up input amps for analog loopback */
7815         /* Amp Indices: DAC = 0, mixer = 1 */
7816         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7817         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7818         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7819         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7820         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7821         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7822         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7823         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7824         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7825         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7826
7827         /* FIXME: use matrix-type input source selection */
7828         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7829         /* Input mixer1 */
7830         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7831         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7832         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7833         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7834         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7835         /* Input mixer2 */
7836         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7837         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7838         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7839         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7840         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7841
7842         { }
7843 };
7844
7845 /* capture mixer elements */
7846 static struct snd_kcontrol_new alc883_capture_mixer[] = {
7847         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7848         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7849         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7850         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7851         {
7852                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7853                 /* The multiple "Capture Source" controls confuse alsamixer
7854                  * So call somewhat different..
7855                  */
7856                 /* .name = "Capture Source", */
7857                 .name = "Input Source",
7858                 .count = 2,
7859                 .info = alc882_mux_enum_info,
7860                 .get = alc882_mux_enum_get,
7861                 .put = alc882_mux_enum_put,
7862         },
7863         { } /* end */
7864 };
7865
7866 #ifdef CONFIG_SND_HDA_POWER_SAVE
7867 #define alc883_loopbacks        alc880_loopbacks
7868 #endif
7869
7870 /* pcm configuration: identiacal with ALC880 */
7871 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
7872 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
7873 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
7874 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
7875 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
7876
7877 /*
7878  * configuration and preset
7879  */
7880 static const char *alc883_models[ALC883_MODEL_LAST] = {
7881         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
7882         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
7883         [ALC883_3ST_6ch]        = "3stack-6ch",
7884         [ALC883_6ST_DIG]        = "6stack-dig",
7885         [ALC883_TARGA_DIG]      = "targa-dig",
7886         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
7887         [ALC883_ACER]           = "acer",
7888         [ALC883_ACER_ASPIRE]    = "acer-aspire",
7889         [ALC883_MEDION]         = "medion",
7890         [ALC883_MEDION_MD2]     = "medion-md2",
7891         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
7892         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
7893         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
7894         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
7895         [ALC883_HAIER_W66]      = "haier-w66",
7896         [ALC888_3ST_HP]         = "3stack-hp",
7897         [ALC888_6ST_DELL]       = "6stack-dell",
7898         [ALC883_MITAC]          = "mitac",
7899         [ALC883_CLEVO_M720]     = "clevo-m720",
7900         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
7901         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
7902         [ALC883_AUTO]           = "auto",
7903 };
7904
7905 static struct snd_pci_quirk alc883_cfg_tbl[] = {
7906         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
7907         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
7908         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
7909         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
7910         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
7911         SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
7912         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
7913         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
7914         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
7915         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
7916         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
7917         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
7918         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
7919         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
7920         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
7921         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
7922         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
7923         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
7924         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
7925         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
7926         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
7927         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
7928         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
7929         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
7930         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
7931         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
7932         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
7933         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
7934         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
7935         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
7936         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
7937         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
7938         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
7939         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
7940         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
7941         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
7942         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
7943         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
7944         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
7945         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
7946         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
7947         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
7948         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
7949         SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
7950         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
7951         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
7952         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
7953         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
7954         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7955         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7956         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7957         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
7958         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
7959         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
7960         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
7961         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
7962         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
7963         {}
7964 };
7965
7966 static struct alc_config_preset alc883_presets[] = {
7967         [ALC883_3ST_2ch_DIG] = {
7968                 .mixers = { alc883_3ST_2ch_mixer },
7969                 .init_verbs = { alc883_init_verbs },
7970                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7971                 .dac_nids = alc883_dac_nids,
7972                 .dig_out_nid = ALC883_DIGOUT_NID,
7973                 .dig_in_nid = ALC883_DIGIN_NID,
7974                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7975                 .channel_mode = alc883_3ST_2ch_modes,
7976                 .input_mux = &alc883_capture_source,
7977         },
7978         [ALC883_3ST_6ch_DIG] = {
7979                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7980                 .init_verbs = { alc883_init_verbs },
7981                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7982                 .dac_nids = alc883_dac_nids,
7983                 .dig_out_nid = ALC883_DIGOUT_NID,
7984                 .dig_in_nid = ALC883_DIGIN_NID,
7985                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7986                 .channel_mode = alc883_3ST_6ch_modes,
7987                 .need_dac_fix = 1,
7988                 .input_mux = &alc883_capture_source,
7989         },
7990         [ALC883_3ST_6ch] = {
7991                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7992                 .init_verbs = { alc883_init_verbs },
7993                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7994                 .dac_nids = alc883_dac_nids,
7995                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7996                 .channel_mode = alc883_3ST_6ch_modes,
7997                 .need_dac_fix = 1,
7998                 .input_mux = &alc883_capture_source,
7999         },
8000         [ALC883_3ST_6ch_INTEL] = {
8001                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8002                 .init_verbs = { alc883_init_verbs },
8003                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8004                 .dac_nids = alc883_dac_nids,
8005                 .dig_out_nid = ALC883_DIGOUT_NID,
8006                 .dig_in_nid = ALC883_DIGIN_NID,
8007                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8008                 .channel_mode = alc883_3ST_6ch_intel_modes,
8009                 .need_dac_fix = 1,
8010                 .input_mux = &alc883_3stack_6ch_intel,
8011         },
8012         [ALC883_6ST_DIG] = {
8013                 .mixers = { alc883_base_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_sixstack_modes),
8020                 .channel_mode = alc883_sixstack_modes,
8021                 .input_mux = &alc883_capture_source,
8022         },
8023         [ALC883_TARGA_DIG] = {
8024                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8025                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8026                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8027                 .dac_nids = alc883_dac_nids,
8028                 .dig_out_nid = ALC883_DIGOUT_NID,
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                 .unsol_event = alc883_tagra_unsol_event,
8034                 .init_hook = alc883_tagra_automute,
8035         },
8036         [ALC883_TARGA_2ch_DIG] = {
8037                 .mixers = { alc883_tagra_2ch_mixer},
8038                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8039                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8040                 .dac_nids = alc883_dac_nids,
8041                 .dig_out_nid = ALC883_DIGOUT_NID,
8042                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8043                 .channel_mode = alc883_3ST_2ch_modes,
8044                 .input_mux = &alc883_capture_source,
8045                 .unsol_event = alc883_tagra_unsol_event,
8046                 .init_hook = alc883_tagra_automute,
8047         },
8048         [ALC883_ACER] = {
8049                 .mixers = { alc883_base_mixer },
8050                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8051                  * and the headphone jack.  Turn this on and rely on the
8052                  * standard mute methods whenever the user wants to turn
8053                  * these outputs off.
8054                  */
8055                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8056                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8057                 .dac_nids = alc883_dac_nids,
8058                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8059                 .channel_mode = alc883_3ST_2ch_modes,
8060                 .input_mux = &alc883_capture_source,
8061         },
8062         [ALC883_ACER_ASPIRE] = {
8063                 .mixers = { alc883_acer_aspire_mixer },
8064                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8065                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8066                 .dac_nids = alc883_dac_nids,
8067                 .dig_out_nid = ALC883_DIGOUT_NID,
8068                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8069                 .channel_mode = alc883_3ST_2ch_modes,
8070                 .input_mux = &alc883_capture_source,
8071                 .unsol_event = alc883_acer_aspire_unsol_event,
8072                 .init_hook = alc883_acer_aspire_automute,
8073         },
8074         [ALC883_MEDION] = {
8075                 .mixers = { alc883_fivestack_mixer,
8076                             alc883_chmode_mixer },
8077                 .init_verbs = { alc883_init_verbs,
8078                                 alc883_medion_eapd_verbs },
8079                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8080                 .dac_nids = alc883_dac_nids,
8081                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8082                 .channel_mode = alc883_sixstack_modes,
8083                 .input_mux = &alc883_capture_source,
8084         },
8085         [ALC883_MEDION_MD2] = {
8086                 .mixers = { alc883_medion_md2_mixer},
8087                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8088                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8089                 .dac_nids = alc883_dac_nids,
8090                 .dig_out_nid = ALC883_DIGOUT_NID,
8091                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8092                 .channel_mode = alc883_3ST_2ch_modes,
8093                 .input_mux = &alc883_capture_source,
8094                 .unsol_event = alc883_medion_md2_unsol_event,
8095                 .init_hook = alc883_medion_md2_automute,
8096         },
8097         [ALC883_LAPTOP_EAPD] = {
8098                 .mixers = { alc883_base_mixer },
8099                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8100                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8101                 .dac_nids = alc883_dac_nids,
8102                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8103                 .channel_mode = alc883_3ST_2ch_modes,
8104                 .input_mux = &alc883_capture_source,
8105         },
8106         [ALC883_CLEVO_M720] = {
8107                 .mixers = { alc883_clevo_m720_mixer },
8108                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8109                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8110                 .dac_nids = alc883_dac_nids,
8111                 .dig_out_nid = ALC883_DIGOUT_NID,
8112                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8113                 .channel_mode = alc883_3ST_2ch_modes,
8114                 .input_mux = &alc883_capture_source,
8115                 .unsol_event = alc883_clevo_m720_unsol_event,
8116                 .init_hook = alc883_clevo_m720_automute,
8117         },
8118         [ALC883_LENOVO_101E_2ch] = {
8119                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8120                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8121                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8122                 .dac_nids = alc883_dac_nids,
8123                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8124                 .channel_mode = alc883_3ST_2ch_modes,
8125                 .input_mux = &alc883_lenovo_101e_capture_source,
8126                 .unsol_event = alc883_lenovo_101e_unsol_event,
8127                 .init_hook = alc883_lenovo_101e_all_automute,
8128         },
8129         [ALC883_LENOVO_NB0763] = {
8130                 .mixers = { alc883_lenovo_nb0763_mixer },
8131                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8132                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8133                 .dac_nids = alc883_dac_nids,
8134                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8135                 .channel_mode = alc883_3ST_2ch_modes,
8136                 .need_dac_fix = 1,
8137                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8138                 .unsol_event = alc883_medion_md2_unsol_event,
8139                 .init_hook = alc883_medion_md2_automute,
8140         },
8141         [ALC888_LENOVO_MS7195_DIG] = {
8142                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8143                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8144                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8145                 .dac_nids = alc883_dac_nids,
8146                 .dig_out_nid = ALC883_DIGOUT_NID,
8147                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8148                 .channel_mode = alc883_3ST_6ch_modes,
8149                 .need_dac_fix = 1,
8150                 .input_mux = &alc883_capture_source,
8151                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8152                 .init_hook = alc888_lenovo_ms7195_front_automute,
8153         },
8154         [ALC883_HAIER_W66] = {
8155                 .mixers = { alc883_tagra_2ch_mixer},
8156                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8157                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8158                 .dac_nids = alc883_dac_nids,
8159                 .dig_out_nid = ALC883_DIGOUT_NID,
8160                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8161                 .channel_mode = alc883_3ST_2ch_modes,
8162                 .input_mux = &alc883_capture_source,
8163                 .unsol_event = alc883_haier_w66_unsol_event,
8164                 .init_hook = alc883_haier_w66_automute,
8165         },
8166         [ALC888_3ST_HP] = {
8167                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8168                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8169                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8170                 .dac_nids = alc883_dac_nids,
8171                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8172                 .channel_mode = alc888_3st_hp_modes,
8173                 .need_dac_fix = 1,
8174                 .input_mux = &alc883_capture_source,
8175         },
8176         [ALC888_6ST_DELL] = {
8177                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8178                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8179                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8180                 .dac_nids = alc883_dac_nids,
8181                 .dig_out_nid = ALC883_DIGOUT_NID,
8182                 .dig_in_nid = ALC883_DIGIN_NID,
8183                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8184                 .channel_mode = alc883_sixstack_modes,
8185                 .input_mux = &alc883_capture_source,
8186                 .unsol_event = alc888_6st_dell_unsol_event,
8187                 .init_hook = alc888_6st_dell_front_automute,
8188         },
8189         [ALC883_MITAC] = {
8190                 .mixers = { alc883_mitac_mixer },
8191                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8192                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8193                 .dac_nids = alc883_dac_nids,
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_mitac_unsol_event,
8198                 .init_hook = alc883_mitac_automute,
8199         },
8200         [ALC883_FUJITSU_PI2515] = {
8201                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8202                 .init_verbs = { alc883_init_verbs,
8203                                 alc883_2ch_fujitsu_pi2515_verbs},
8204                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8205                 .dac_nids = alc883_dac_nids,
8206                 .dig_out_nid = ALC883_DIGOUT_NID,
8207                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8208                 .channel_mode = alc883_3ST_2ch_modes,
8209                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8210                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8211                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8212         },
8213 };
8214
8215
8216 /*
8217  * BIOS auto configuration
8218  */
8219 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8220                                               hda_nid_t nid, int pin_type,
8221                                               int dac_idx)
8222 {
8223         /* set as output */
8224         struct alc_spec *spec = codec->spec;
8225         int idx;
8226
8227         alc_set_pin_output(codec, nid, pin_type);
8228         if (spec->multiout.dac_nids[dac_idx] == 0x25)
8229                 idx = 4;
8230         else
8231                 idx = spec->multiout.dac_nids[dac_idx] - 2;
8232         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8233
8234 }
8235
8236 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8237 {
8238         struct alc_spec *spec = codec->spec;
8239         int i;
8240
8241         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8242         for (i = 0; i <= HDA_SIDE; i++) {
8243                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8244                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8245                 if (nid)
8246                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8247                                                           i);
8248         }
8249 }
8250
8251 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8252 {
8253         struct alc_spec *spec = codec->spec;
8254         hda_nid_t pin;
8255
8256         pin = spec->autocfg.hp_pins[0];
8257         if (pin) /* connect to front */
8258                 /* use dac 0 */
8259                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8260         pin = spec->autocfg.speaker_pins[0];
8261         if (pin)
8262                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8263 }
8264
8265 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
8266 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
8267
8268 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8269 {
8270         struct alc_spec *spec = codec->spec;
8271         int i;
8272
8273         for (i = 0; i < AUTO_PIN_LAST; i++) {
8274                 hda_nid_t nid = spec->autocfg.input_pins[i];
8275                 if (alc883_is_input_pin(nid)) {
8276                         snd_hda_codec_write(codec, nid, 0,
8277                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
8278                                             (i <= AUTO_PIN_FRONT_MIC ?
8279                                              PIN_VREF80 : PIN_IN));
8280                         if (nid != ALC883_PIN_CD_NID)
8281                                 snd_hda_codec_write(codec, nid, 0,
8282                                                     AC_VERB_SET_AMP_GAIN_MUTE,
8283                                                     AMP_OUT_MUTE);
8284                 }
8285         }
8286 }
8287
8288 /* almost identical with ALC880 parser... */
8289 static int alc883_parse_auto_config(struct hda_codec *codec)
8290 {
8291         struct alc_spec *spec = codec->spec;
8292         int err = alc880_parse_auto_config(codec);
8293
8294         if (err < 0)
8295                 return err;
8296         else if (!err)
8297                 return 0; /* no config found */
8298
8299         err = alc_auto_add_mic_boost(codec);
8300         if (err < 0)
8301                 return err;
8302
8303         /* hack - override the init verbs */
8304         spec->init_verbs[0] = alc883_auto_init_verbs;
8305         spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8306         spec->num_mixers++;
8307
8308         return 1; /* config found */
8309 }
8310
8311 /* additional initialization for auto-configuration model */
8312 static void alc883_auto_init(struct hda_codec *codec)
8313 {
8314         struct alc_spec *spec = codec->spec;
8315         alc883_auto_init_multi_out(codec);
8316         alc883_auto_init_hp_out(codec);
8317         alc883_auto_init_analog_input(codec);
8318         if (spec->unsol_event)
8319                 alc_sku_automute(codec);
8320 }
8321
8322 static int patch_alc883(struct hda_codec *codec)
8323 {
8324         struct alc_spec *spec;
8325         int err, board_config;
8326
8327         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8328         if (spec == NULL)
8329                 return -ENOMEM;
8330
8331         codec->spec = spec;
8332
8333         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8334
8335         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8336                                                   alc883_models,
8337                                                   alc883_cfg_tbl);
8338         if (board_config < 0) {
8339                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8340                        "trying auto-probe from BIOS...\n");
8341                 board_config = ALC883_AUTO;
8342         }
8343
8344         if (board_config == ALC883_AUTO) {
8345                 /* automatic parse from the BIOS config */
8346                 err = alc883_parse_auto_config(codec);
8347                 if (err < 0) {
8348                         alc_free(codec);
8349                         return err;
8350                 } else if (!err) {
8351                         printk(KERN_INFO
8352                                "hda_codec: Cannot set up configuration "
8353                                "from BIOS.  Using base mode...\n");
8354                         board_config = ALC883_3ST_2ch_DIG;
8355                 }
8356         }
8357
8358         if (board_config != ALC883_AUTO)
8359                 setup_preset(spec, &alc883_presets[board_config]);
8360
8361         switch (codec->vendor_id) {
8362         case 0x10ec0888:
8363                 spec->stream_name_analog = "ALC888 Analog";
8364                 spec->stream_name_digital = "ALC888 Digital";
8365                 break;
8366         case 0x10ec0889:
8367                 spec->stream_name_analog = "ALC889 Analog";
8368                 spec->stream_name_digital = "ALC889 Digital";
8369                 break;
8370         default:
8371                 spec->stream_name_analog = "ALC883 Analog";
8372                 spec->stream_name_digital = "ALC883 Digital";
8373                 break;
8374         }
8375
8376         spec->stream_analog_playback = &alc883_pcm_analog_playback;
8377         spec->stream_analog_capture = &alc883_pcm_analog_capture;
8378         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8379
8380         spec->stream_digital_playback = &alc883_pcm_digital_playback;
8381         spec->stream_digital_capture = &alc883_pcm_digital_capture;
8382
8383         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8384         spec->adc_nids = alc883_adc_nids;
8385         spec->capsrc_nids = alc883_capsrc_nids;
8386
8387         spec->vmaster_nid = 0x0c;
8388
8389         codec->patch_ops = alc_patch_ops;
8390         if (board_config == ALC883_AUTO)
8391                 spec->init_hook = alc883_auto_init;
8392         else if (codec->vendor_id == 0x10ec0888)
8393                 spec->init_hook = alc888_coef_init;
8394
8395 #ifdef CONFIG_SND_HDA_POWER_SAVE
8396         if (!spec->loopback.amplist)
8397                 spec->loopback.amplist = alc883_loopbacks;
8398 #endif
8399
8400         return 0;
8401 }
8402
8403 /*
8404  * ALC262 support
8405  */
8406
8407 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
8408 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
8409
8410 #define alc262_dac_nids         alc260_dac_nids
8411 #define alc262_adc_nids         alc882_adc_nids
8412 #define alc262_adc_nids_alt     alc882_adc_nids_alt
8413 #define alc262_capsrc_nids      alc882_capsrc_nids
8414 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
8415
8416 #define alc262_modes            alc260_modes
8417 #define alc262_capture_source   alc882_capture_source
8418
8419 static struct snd_kcontrol_new alc262_base_mixer[] = {
8420         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8421         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8422         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8423         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8424         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8425         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8426         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8427         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8428         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8429         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8430         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8431         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8432         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8433            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8434         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8435         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8436         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8437         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8438         { } /* end */
8439 };
8440
8441 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8442         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8443         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8444         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8445         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8446         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8447         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8448         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8449         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8450         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8451         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8452         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8453         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8454         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8455            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8456         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8457         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8458         { } /* end */
8459 };
8460
8461 /* update HP, line and mono-out pins according to the master switch */
8462 static void alc262_hp_master_update(struct hda_codec *codec)
8463 {
8464         struct alc_spec *spec = codec->spec;
8465         int val = spec->master_sw;
8466
8467         /* HP & line-out */
8468         snd_hda_codec_write_cache(codec, 0x1b, 0,
8469                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8470                                   val ? PIN_HP : 0);
8471         snd_hda_codec_write_cache(codec, 0x15, 0,
8472                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8473                                   val ? PIN_HP : 0);
8474         /* mono (speaker) depending on the HP jack sense */
8475         val = val && !spec->jack_present;
8476         snd_hda_codec_write_cache(codec, 0x16, 0,
8477                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8478                                   val ? PIN_OUT : 0);
8479 }
8480
8481 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8482 {
8483         struct alc_spec *spec = codec->spec;
8484         unsigned int presence;
8485         presence = snd_hda_codec_read(codec, 0x1b, 0,
8486                                       AC_VERB_GET_PIN_SENSE, 0);
8487         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8488         alc262_hp_master_update(codec);
8489 }
8490
8491 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8492 {
8493         if ((res >> 26) != ALC880_HP_EVENT)
8494                 return;
8495         alc262_hp_bpc_automute(codec);
8496 }
8497
8498 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8499 {
8500         struct alc_spec *spec = codec->spec;
8501         unsigned int presence;
8502         presence = snd_hda_codec_read(codec, 0x15, 0,
8503                                       AC_VERB_GET_PIN_SENSE, 0);
8504         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8505         alc262_hp_master_update(codec);
8506 }
8507
8508 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8509                                            unsigned int res)
8510 {
8511         if ((res >> 26) != ALC880_HP_EVENT)
8512                 return;
8513         alc262_hp_wildwest_automute(codec);
8514 }
8515
8516 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
8517                                    struct snd_ctl_elem_value *ucontrol)
8518 {
8519         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8520         struct alc_spec *spec = codec->spec;
8521         *ucontrol->value.integer.value = spec->master_sw;
8522         return 0;
8523 }
8524
8525 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
8526                                    struct snd_ctl_elem_value *ucontrol)
8527 {
8528         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8529         struct alc_spec *spec = codec->spec;
8530         int val = !!*ucontrol->value.integer.value;
8531
8532         if (val == spec->master_sw)
8533                 return 0;
8534         spec->master_sw = val;
8535         alc262_hp_master_update(codec);
8536         return 1;
8537 }
8538
8539 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
8540         {
8541                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8542                 .name = "Master Playback Switch",
8543                 .info = snd_ctl_boolean_mono_info,
8544                 .get = alc262_hp_master_sw_get,
8545                 .put = alc262_hp_master_sw_put,
8546         },
8547         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8548         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8549         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8550         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8551                               HDA_OUTPUT),
8552         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8553                             HDA_OUTPUT),
8554         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8555         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8556         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8557         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8558         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8559         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8560         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8561         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8562         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8563         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8564         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8565         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8566         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
8567         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
8568         { } /* end */
8569 };
8570
8571 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
8572         {
8573                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8574                 .name = "Master Playback Switch",
8575                 .info = snd_ctl_boolean_mono_info,
8576                 .get = alc262_hp_master_sw_get,
8577                 .put = alc262_hp_master_sw_put,
8578         },
8579         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8580         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8581         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8582         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8583         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8584                               HDA_OUTPUT),
8585         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8586                             HDA_OUTPUT),
8587         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
8588         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
8589         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
8590         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8591         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8592         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8593         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8594         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8595         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8596         { } /* end */
8597 };
8598
8599 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
8600         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8601         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8602         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
8603         { } /* end */
8604 };
8605
8606 /* mute/unmute internal speaker according to the hp jack and mute state */
8607 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
8608 {
8609         struct alc_spec *spec = codec->spec;
8610
8611         if (force || !spec->sense_updated) {
8612                 unsigned int present;
8613                 present = snd_hda_codec_read(codec, 0x15, 0,
8614                                              AC_VERB_GET_PIN_SENSE, 0);
8615                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
8616                 spec->sense_updated = 1;
8617         }
8618         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
8619                                  spec->jack_present ? HDA_AMP_MUTE : 0);
8620 }
8621
8622 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
8623                                         unsigned int res)
8624 {
8625         if ((res >> 26) != ALC880_HP_EVENT)
8626                 return;
8627         alc262_hp_t5735_automute(codec, 1);
8628 }
8629
8630 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
8631 {
8632         alc262_hp_t5735_automute(codec, 1);
8633 }
8634
8635 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
8636         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8637         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8638         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8639         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8640         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8641         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8642         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8643         { } /* end */
8644 };
8645
8646 static struct hda_verb alc262_hp_t5735_verbs[] = {
8647         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8648         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8649
8650         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8651         { }
8652 };
8653
8654 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
8655         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8656         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8657         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8658         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8659         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8660         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8661         { } /* end */
8662 };
8663
8664 static struct hda_verb alc262_hp_rp5700_verbs[] = {
8665         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8666         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8667         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8668         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8669         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8670         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8671         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8672         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8673         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8674         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8675         {}
8676 };
8677
8678 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
8679         .num_items = 1,
8680         .items = {
8681                 { "Line", 0x1 },
8682         },
8683 };
8684
8685 /* bind hp and internal speaker mute (with plug check) */
8686 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
8687                                      struct snd_ctl_elem_value *ucontrol)
8688 {
8689         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8690         long *valp = ucontrol->value.integer.value;
8691         int change;
8692
8693         /* change hp mute */
8694         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
8695                                           HDA_AMP_MUTE,
8696                                           valp[0] ? 0 : HDA_AMP_MUTE);
8697         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
8698                                            HDA_AMP_MUTE,
8699                                            valp[1] ? 0 : HDA_AMP_MUTE);
8700         if (change) {
8701                 /* change speaker according to HP jack state */
8702                 struct alc_spec *spec = codec->spec;
8703                 unsigned int mute;
8704                 if (spec->jack_present)
8705                         mute = HDA_AMP_MUTE;
8706                 else
8707                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
8708                                                       HDA_OUTPUT, 0);
8709                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8710                                          HDA_AMP_MUTE, mute);
8711         }
8712         return change;
8713 }
8714
8715 static struct snd_kcontrol_new alc262_sony_mixer[] = {
8716         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8717         {
8718                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8719                 .name = "Master Playback Switch",
8720                 .info = snd_hda_mixer_amp_switch_info,
8721                 .get = snd_hda_mixer_amp_switch_get,
8722                 .put = alc262_sony_master_sw_put,
8723                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
8724         },
8725         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8726         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8727         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8728         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8729         { } /* end */
8730 };
8731
8732 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
8733         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8734         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8735         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8736         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8737         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8738         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8739         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8740         { } /* end */
8741 };
8742
8743 #define alc262_capture_mixer            alc882_capture_mixer
8744 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
8745
8746 /*
8747  * generic initialization of ADC, input mixers and output mixers
8748  */
8749 static struct hda_verb alc262_init_verbs[] = {
8750         /*
8751          * Unmute ADC0-2 and set the default input to mic-in
8752          */
8753         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8754         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8755         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8756         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8757         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8758         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8759
8760         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8761          * mixer widget
8762          * Note: PASD motherboards uses the Line In 2 as the input for
8763          * front panel mic (mic 2)
8764          */
8765         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8766         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8767         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8768         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8769         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8770         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8771
8772         /*
8773          * Set up output mixers (0x0c - 0x0e)
8774          */
8775         /* set vol=0 to output mixers */
8776         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8777         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8778         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8779         /* set up input amps for analog loopback */
8780         /* Amp Indices: DAC = 0, mixer = 1 */
8781         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8782         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8783         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8784         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8785         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8786         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8787
8788         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8789         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8790         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8791         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8792         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8793         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8794
8795         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8796         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8797         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8798         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8799         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8800
8801         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8802         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8803
8804         /* FIXME: use matrix-type input source selection */
8805         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8806         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8807         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8808         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8809         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8810         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8811         /* Input mixer2 */
8812         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8813         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8814         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8815         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8816         /* Input mixer3 */
8817         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8818         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8819         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8820         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8821
8822         { }
8823 };
8824
8825 static struct hda_verb alc262_hippo_unsol_verbs[] = {
8826         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8827         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8828         {}
8829 };
8830
8831 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
8832         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8833         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8834         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8835
8836         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8837         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8838         {}
8839 };
8840
8841 static struct hda_verb alc262_sony_unsol_verbs[] = {
8842         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8843         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8844         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
8845
8846         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8847         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8848         {}
8849 };
8850
8851 /* mute/unmute internal speaker according to the hp jack and mute state */
8852 static void alc262_hippo_automute(struct hda_codec *codec)
8853 {
8854         struct alc_spec *spec = codec->spec;
8855         unsigned int mute;
8856         unsigned int present;
8857
8858         /* need to execute and sync at first */
8859         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
8860         present = snd_hda_codec_read(codec, 0x15, 0,
8861                                      AC_VERB_GET_PIN_SENSE, 0);
8862         spec->jack_present = (present & 0x80000000) != 0;
8863         if (spec->jack_present) {
8864                 /* mute internal speaker */
8865                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8866                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8867         } else {
8868                 /* unmute internal speaker if necessary */
8869                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
8870                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8871                                          HDA_AMP_MUTE, mute);
8872         }
8873 }
8874
8875 /* unsolicited event for HP jack sensing */
8876 static void alc262_hippo_unsol_event(struct hda_codec *codec,
8877                                        unsigned int res)
8878 {
8879         if ((res >> 26) != ALC880_HP_EVENT)
8880                 return;
8881         alc262_hippo_automute(codec);
8882 }
8883
8884 static void alc262_hippo1_automute(struct hda_codec *codec)
8885 {
8886         unsigned int mute;
8887         unsigned int present;
8888
8889         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8890         present = snd_hda_codec_read(codec, 0x1b, 0,
8891                                      AC_VERB_GET_PIN_SENSE, 0);
8892         present = (present & 0x80000000) != 0;
8893         if (present) {
8894                 /* mute internal speaker */
8895                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8896                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8897         } else {
8898                 /* unmute internal speaker if necessary */
8899                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8900                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8901                                          HDA_AMP_MUTE, mute);
8902         }
8903 }
8904
8905 /* unsolicited event for HP jack sensing */
8906 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
8907                                        unsigned int res)
8908 {
8909         if ((res >> 26) != ALC880_HP_EVENT)
8910                 return;
8911         alc262_hippo1_automute(codec);
8912 }
8913
8914 /*
8915  * fujitsu model
8916  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
8917  *  0x1b = port replicator headphone out
8918  */
8919
8920 #define ALC_HP_EVENT    0x37
8921
8922 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
8923         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8924         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8925         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8926         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8927         {}
8928 };
8929
8930 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
8931         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8932         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8933         {}
8934 };
8935
8936 static struct hda_input_mux alc262_fujitsu_capture_source = {
8937         .num_items = 3,
8938         .items = {
8939                 { "Mic", 0x0 },
8940                 { "Int Mic", 0x1 },
8941                 { "CD", 0x4 },
8942         },
8943 };
8944
8945 static struct hda_input_mux alc262_HP_capture_source = {
8946         .num_items = 5,
8947         .items = {
8948                 { "Mic", 0x0 },
8949                 { "Front Mic", 0x1 },
8950                 { "Line", 0x2 },
8951                 { "CD", 0x4 },
8952                 { "AUX IN", 0x6 },
8953         },
8954 };
8955
8956 static struct hda_input_mux alc262_HP_D7000_capture_source = {
8957         .num_items = 4,
8958         .items = {
8959                 { "Mic", 0x0 },
8960                 { "Front Mic", 0x2 },
8961                 { "Line", 0x1 },
8962                 { "CD", 0x4 },
8963         },
8964 };
8965
8966 /* mute/unmute internal speaker according to the hp jacks and mute state */
8967 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
8968 {
8969         struct alc_spec *spec = codec->spec;
8970         unsigned int mute;
8971
8972         if (force || !spec->sense_updated) {
8973                 unsigned int present;
8974                 /* need to execute and sync at first */
8975                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
8976                 /* check laptop HP jack */
8977                 present = snd_hda_codec_read(codec, 0x14, 0,
8978                                              AC_VERB_GET_PIN_SENSE, 0);
8979                 /* need to execute and sync at first */
8980                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8981                 /* check docking HP jack */
8982                 present |= snd_hda_codec_read(codec, 0x1b, 0,
8983                                               AC_VERB_GET_PIN_SENSE, 0);
8984                 if (present & AC_PINSENSE_PRESENCE)
8985                         spec->jack_present = 1;
8986                 else
8987                         spec->jack_present = 0;
8988                 spec->sense_updated = 1;
8989         }
8990         /* unmute internal speaker only if both HPs are unplugged and
8991          * master switch is on
8992          */
8993         if (spec->jack_present)
8994                 mute = HDA_AMP_MUTE;
8995         else
8996                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
8997         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8998                                  HDA_AMP_MUTE, mute);
8999 }
9000
9001 /* unsolicited event for HP jack sensing */
9002 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9003                                        unsigned int res)
9004 {
9005         if ((res >> 26) != ALC_HP_EVENT)
9006                 return;
9007         alc262_fujitsu_automute(codec, 1);
9008 }
9009
9010 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9011 {
9012         alc262_fujitsu_automute(codec, 1);
9013 }
9014
9015 /* bind volumes of both NID 0x0c and 0x0d */
9016 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9017         .ops = &snd_hda_bind_vol,
9018         .values = {
9019                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9020                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9021                 0
9022         },
9023 };
9024
9025 /* mute/unmute internal speaker according to the hp jack and mute state */
9026 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9027 {
9028         struct alc_spec *spec = codec->spec;
9029         unsigned int mute;
9030
9031         if (force || !spec->sense_updated) {
9032                 unsigned int present_int_hp;
9033                 /* need to execute and sync at first */
9034                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9035                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9036                                         AC_VERB_GET_PIN_SENSE, 0);
9037                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9038                 spec->sense_updated = 1;
9039         }
9040         if (spec->jack_present) {
9041                 /* mute internal speaker */
9042                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9043                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9044                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9045                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9046         } else {
9047                 /* unmute internal speaker if necessary */
9048                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9049                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9050                                          HDA_AMP_MUTE, mute);
9051                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9052                                          HDA_AMP_MUTE, mute);
9053         }
9054 }
9055
9056 /* unsolicited event for HP jack sensing */
9057 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9058                                        unsigned int res)
9059 {
9060         if ((res >> 26) != ALC_HP_EVENT)
9061                 return;
9062         alc262_lenovo_3000_automute(codec, 1);
9063 }
9064
9065 /* bind hp and internal speaker mute (with plug check) */
9066 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9067                                          struct snd_ctl_elem_value *ucontrol)
9068 {
9069         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9070         long *valp = ucontrol->value.integer.value;
9071         int change;
9072
9073         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9074                                                  HDA_AMP_MUTE,
9075                                                  valp ? 0 : HDA_AMP_MUTE);
9076         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9077                                                  HDA_AMP_MUTE,
9078                                                  valp ? 0 : HDA_AMP_MUTE);
9079
9080         if (change)
9081                 alc262_fujitsu_automute(codec, 0);
9082         return change;
9083 }
9084
9085 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9086         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9087         {
9088                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9089                 .name = "Master Playback Switch",
9090                 .info = snd_hda_mixer_amp_switch_info,
9091                 .get = snd_hda_mixer_amp_switch_get,
9092                 .put = alc262_fujitsu_master_sw_put,
9093                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9094         },
9095         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9096         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9097         HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9098         HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9099         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9100         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9101         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9102         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9103         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9104         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9105         { } /* end */
9106 };
9107
9108 /* bind hp and internal speaker mute (with plug check) */
9109 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9110                                          struct snd_ctl_elem_value *ucontrol)
9111 {
9112         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9113         long *valp = ucontrol->value.integer.value;
9114         int change;
9115
9116         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9117                                                  HDA_AMP_MUTE,
9118                                                  valp ? 0 : HDA_AMP_MUTE);
9119
9120         if (change)
9121                 alc262_lenovo_3000_automute(codec, 0);
9122         return change;
9123 }
9124
9125 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9126         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9127         {
9128                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9129                 .name = "Master Playback Switch",
9130                 .info = snd_hda_mixer_amp_switch_info,
9131                 .get = snd_hda_mixer_amp_switch_get,
9132                 .put = alc262_lenovo_3000_master_sw_put,
9133                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9134         },
9135         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9136         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9137         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9138         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9139         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9140         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9141         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9142         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9143         { } /* end */
9144 };
9145
9146 /* additional init verbs for Benq laptops */
9147 static struct hda_verb alc262_EAPD_verbs[] = {
9148         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9149         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
9150         {}
9151 };
9152
9153 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9154         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9155         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9156
9157         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9158         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
9159         {}
9160 };
9161
9162 /* Samsung Q1 Ultra Vista model setup */
9163 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9164         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9165         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9166         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9167         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9168         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9169         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9170         { } /* end */
9171 };
9172
9173 static struct hda_verb alc262_ultra_verbs[] = {
9174         /* output mixer */
9175         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9176         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9177         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9178         /* speaker */
9179         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9180         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9181         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9182         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9183         /* HP */
9184         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9185         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9186         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9187         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9188         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9189         /* internal mic */
9190         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9191         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9192         /* ADC, choose mic */
9193         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9194         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9195         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9196         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9197         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9198         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9199         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9200         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9201         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9202         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9203         {}
9204 };
9205
9206 /* mute/unmute internal speaker according to the hp jack and mute state */
9207 static void alc262_ultra_automute(struct hda_codec *codec)
9208 {
9209         struct alc_spec *spec = codec->spec;
9210         unsigned int mute;
9211
9212         mute = 0;
9213         /* auto-mute only when HP is used as HP */
9214         if (!spec->cur_mux[0]) {
9215                 unsigned int present;
9216                 /* need to execute and sync at first */
9217                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9218                 present = snd_hda_codec_read(codec, 0x15, 0,
9219                                              AC_VERB_GET_PIN_SENSE, 0);
9220                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9221                 if (spec->jack_present)
9222                         mute = HDA_AMP_MUTE;
9223         }
9224         /* mute/unmute internal speaker */
9225         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9226                                  HDA_AMP_MUTE, mute);
9227         /* mute/unmute HP */
9228         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9229                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9230 }
9231
9232 /* unsolicited event for HP jack sensing */
9233 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9234                                        unsigned int res)
9235 {
9236         if ((res >> 26) != ALC880_HP_EVENT)
9237                 return;
9238         alc262_ultra_automute(codec);
9239 }
9240
9241 static struct hda_input_mux alc262_ultra_capture_source = {
9242         .num_items = 2,
9243         .items = {
9244                 { "Mic", 0x1 },
9245                 { "Headphone", 0x7 },
9246         },
9247 };
9248
9249 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9250                                      struct snd_ctl_elem_value *ucontrol)
9251 {
9252         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9253         struct alc_spec *spec = codec->spec;
9254         int ret;
9255
9256         ret = alc882_mux_enum_put(kcontrol, ucontrol);
9257         if (!ret)
9258                 return 0;
9259         /* reprogram the HP pin as mic or HP according to the input source */
9260         snd_hda_codec_write_cache(codec, 0x15, 0,
9261                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9262                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9263         alc262_ultra_automute(codec); /* mute/unmute HP */
9264         return ret;
9265 }
9266
9267 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9268         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9269         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9270         {
9271                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9272                 .name = "Capture Source",
9273                 .info = alc882_mux_enum_info,
9274                 .get = alc882_mux_enum_get,
9275                 .put = alc262_ultra_mux_enum_put,
9276         },
9277         { } /* end */
9278 };
9279
9280 /* add playback controls from the parsed DAC table */
9281 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9282                                              const struct auto_pin_cfg *cfg)
9283 {
9284         hda_nid_t nid;
9285         int err;
9286
9287         spec->multiout.num_dacs = 1;    /* only use one dac */
9288         spec->multiout.dac_nids = spec->private_dac_nids;
9289         spec->multiout.dac_nids[0] = 2;
9290
9291         nid = cfg->line_out_pins[0];
9292         if (nid) {
9293                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9294                                   "Front Playback Volume",
9295                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
9296                 if (err < 0)
9297                         return err;
9298                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9299                                   "Front Playback Switch",
9300                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9301                 if (err < 0)
9302                         return err;
9303         }
9304
9305         nid = cfg->speaker_pins[0];
9306         if (nid) {
9307                 if (nid == 0x16) {
9308                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9309                                           "Speaker Playback Volume",
9310                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9311                                                               HDA_OUTPUT));
9312                         if (err < 0)
9313                                 return err;
9314                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9315                                           "Speaker Playback Switch",
9316                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9317                                                               HDA_OUTPUT));
9318                         if (err < 0)
9319                                 return err;
9320                 } else {
9321                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9322                                           "Speaker Playback Switch",
9323                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9324                                                               HDA_OUTPUT));
9325                         if (err < 0)
9326                                 return err;
9327                 }
9328         }
9329         nid = cfg->hp_pins[0];
9330         if (nid) {
9331                 /* spec->multiout.hp_nid = 2; */
9332                 if (nid == 0x16) {
9333                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9334                                           "Headphone Playback Volume",
9335                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9336                                                               HDA_OUTPUT));
9337                         if (err < 0)
9338                                 return err;
9339                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9340                                           "Headphone Playback Switch",
9341                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9342                                                               HDA_OUTPUT));
9343                         if (err < 0)
9344                                 return err;
9345                 } else {
9346                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9347                                           "Headphone Playback Switch",
9348                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9349                                                               HDA_OUTPUT));
9350                         if (err < 0)
9351                                 return err;
9352                 }
9353         }
9354         return 0;
9355 }
9356
9357 /* identical with ALC880 */
9358 #define alc262_auto_create_analog_input_ctls \
9359         alc880_auto_create_analog_input_ctls
9360
9361 /*
9362  * generic initialization of ADC, input mixers and output mixers
9363  */
9364 static struct hda_verb alc262_volume_init_verbs[] = {
9365         /*
9366          * Unmute ADC0-2 and set the default input to mic-in
9367          */
9368         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9369         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9370         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9371         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9372         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9373         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9374
9375         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9376          * mixer widget
9377          * Note: PASD motherboards uses the Line In 2 as the input for
9378          * front panel mic (mic 2)
9379          */
9380         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9381         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9382         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9383         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9384         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9385         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9386
9387         /*
9388          * Set up output mixers (0x0c - 0x0f)
9389          */
9390         /* set vol=0 to output mixers */
9391         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9392         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9393         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9394
9395         /* set up input amps for analog loopback */
9396         /* Amp Indices: DAC = 0, mixer = 1 */
9397         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9398         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9399         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9400         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9401         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9402         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9403
9404         /* FIXME: use matrix-type input source selection */
9405         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9406         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9407         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9408         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9409         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9410         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9411         /* Input mixer2 */
9412         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9413         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9414         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9415         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9416         /* Input mixer3 */
9417         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9418         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9419         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9420         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9421
9422         { }
9423 };
9424
9425 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
9426         /*
9427          * Unmute ADC0-2 and set the default input to mic-in
9428          */
9429         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9430         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9431         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9432         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9433         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9434         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9435
9436         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9437          * mixer widget
9438          * Note: PASD motherboards uses the Line In 2 as the input for
9439          * front panel mic (mic 2)
9440          */
9441         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9442         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9443         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9444         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9445         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9446         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9447         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9448         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9449
9450         /*
9451          * Set up output mixers (0x0c - 0x0e)
9452          */
9453         /* set vol=0 to output mixers */
9454         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9455         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9456         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9457
9458         /* set up input amps for analog loopback */
9459         /* Amp Indices: DAC = 0, mixer = 1 */
9460         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9461         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9462         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9463         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9464         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9465         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9466
9467         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9468         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9469         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9470
9471         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9472         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9473
9474         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9475         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9476
9477         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9478         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9479         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9480         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9481         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9482
9483         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9484         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9485         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9486         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9487         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9488         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9489
9490
9491         /* FIXME: use matrix-type input source selection */
9492         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9493         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9494         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9495         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9496         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9497         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9498         /* Input mixer2 */
9499         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9500         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9501         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9502         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9503         /* Input mixer3 */
9504         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9505         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9506         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9507         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9508
9509         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9510
9511         { }
9512 };
9513
9514 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
9515         /*
9516          * Unmute ADC0-2 and set the default input to mic-in
9517          */
9518         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9519         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9520         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9521         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9522         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9523         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9524
9525         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9526          * mixer widget
9527          * Note: PASD motherboards uses the Line In 2 as the input for front
9528          * panel mic (mic 2)
9529          */
9530         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9531         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9532         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9533         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9534         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9535         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9536         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9537         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9538         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9539         /*
9540          * Set up output mixers (0x0c - 0x0e)
9541          */
9542         /* set vol=0 to output mixers */
9543         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9544         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9545         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9546
9547         /* set up input amps for analog loopback */
9548         /* Amp Indices: DAC = 0, mixer = 1 */
9549         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9550         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9551         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9552         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9553         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9554         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9555
9556
9557         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
9558         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
9559         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
9560         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
9561         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
9562         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
9563         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
9564
9565         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9566         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9567
9568         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9569         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9570
9571         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
9572         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9573         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9574         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9575         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9576         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9577
9578         /* FIXME: use matrix-type input source selection */
9579         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9580         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9581         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
9582         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
9583         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
9584         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
9585         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
9586         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
9587         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
9588         /* Input mixer2 */
9589         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9590         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9591         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9592         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9593         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9594         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9595         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9596         /* Input mixer3 */
9597         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9598         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9599         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9600         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9601         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9602         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9603         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9604
9605         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9606
9607         { }
9608 };
9609
9610 #ifdef CONFIG_SND_HDA_POWER_SAVE
9611 #define alc262_loopbacks        alc880_loopbacks
9612 #endif
9613
9614 /* pcm configuration: identiacal with ALC880 */
9615 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
9616 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
9617 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
9618 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
9619
9620 /*
9621  * BIOS auto configuration
9622  */
9623 static int alc262_parse_auto_config(struct hda_codec *codec)
9624 {
9625         struct alc_spec *spec = codec->spec;
9626         int err;
9627         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
9628
9629         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9630                                            alc262_ignore);
9631         if (err < 0)
9632                 return err;
9633         if (!spec->autocfg.line_outs)
9634                 return 0; /* can't find valid BIOS pin config */
9635         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
9636         if (err < 0)
9637                 return err;
9638         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
9639         if (err < 0)
9640                 return err;
9641
9642         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9643
9644         if (spec->autocfg.dig_out_pin)
9645                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
9646         if (spec->autocfg.dig_in_pin)
9647                 spec->dig_in_nid = ALC262_DIGIN_NID;
9648
9649         if (spec->kctl_alloc)
9650                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
9651
9652         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
9653         spec->num_mux_defs = 1;
9654         spec->input_mux = &spec->private_imux;
9655
9656         err = alc_auto_add_mic_boost(codec);
9657         if (err < 0)
9658                 return err;
9659
9660         return 1;
9661 }
9662
9663 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
9664 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
9665 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
9666
9667
9668 /* init callback for auto-configuration model -- overriding the default init */
9669 static void alc262_auto_init(struct hda_codec *codec)
9670 {
9671         struct alc_spec *spec = codec->spec;
9672         alc262_auto_init_multi_out(codec);
9673         alc262_auto_init_hp_out(codec);
9674         alc262_auto_init_analog_input(codec);
9675         if (spec->unsol_event)
9676                 alc_sku_automute(codec);
9677 }
9678
9679 /*
9680  * configuration and preset
9681  */
9682 static const char *alc262_models[ALC262_MODEL_LAST] = {
9683         [ALC262_BASIC]          = "basic",
9684         [ALC262_HIPPO]          = "hippo",
9685         [ALC262_HIPPO_1]        = "hippo_1",
9686         [ALC262_FUJITSU]        = "fujitsu",
9687         [ALC262_HP_BPC]         = "hp-bpc",
9688         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
9689         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
9690         [ALC262_HP_RP5700]      = "hp-rp5700",
9691         [ALC262_BENQ_ED8]       = "benq",
9692         [ALC262_BENQ_T31]       = "benq-t31",
9693         [ALC262_SONY_ASSAMD]    = "sony-assamd",
9694         [ALC262_ULTRA]          = "ultra",
9695         [ALC262_LENOVO_3000]    = "lenovo-3000",
9696         [ALC262_AUTO]           = "auto",
9697 };
9698
9699 static struct snd_pci_quirk alc262_cfg_tbl[] = {
9700         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
9701         SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
9702         SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
9703         SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
9704         SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
9705         SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
9706         SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
9707         SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
9708         SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
9709         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
9710         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
9711         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
9712         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
9713         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
9714         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
9715         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
9716         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
9717         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
9718         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
9719         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
9720         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
9721                       ALC262_HP_TC_T5735),
9722         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
9723         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9724         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
9725         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9726         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9727         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
9728         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
9729                       ALC262_SONY_ASSAMD),
9730         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
9731         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
9732         SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
9733         SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
9734         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
9735         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
9736         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
9737         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
9738         {}
9739 };
9740
9741 static struct alc_config_preset alc262_presets[] = {
9742         [ALC262_BASIC] = {
9743                 .mixers = { alc262_base_mixer },
9744                 .init_verbs = { alc262_init_verbs },
9745                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9746                 .dac_nids = alc262_dac_nids,
9747                 .hp_nid = 0x03,
9748                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9749                 .channel_mode = alc262_modes,
9750                 .input_mux = &alc262_capture_source,
9751         },
9752         [ALC262_HIPPO] = {
9753                 .mixers = { alc262_base_mixer },
9754                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
9755                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9756                 .dac_nids = alc262_dac_nids,
9757                 .hp_nid = 0x03,
9758                 .dig_out_nid = ALC262_DIGOUT_NID,
9759                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9760                 .channel_mode = alc262_modes,
9761                 .input_mux = &alc262_capture_source,
9762                 .unsol_event = alc262_hippo_unsol_event,
9763                 .init_hook = alc262_hippo_automute,
9764         },
9765         [ALC262_HIPPO_1] = {
9766                 .mixers = { alc262_hippo1_mixer },
9767                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
9768                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9769                 .dac_nids = alc262_dac_nids,
9770                 .hp_nid = 0x02,
9771                 .dig_out_nid = ALC262_DIGOUT_NID,
9772                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9773                 .channel_mode = alc262_modes,
9774                 .input_mux = &alc262_capture_source,
9775                 .unsol_event = alc262_hippo1_unsol_event,
9776                 .init_hook = alc262_hippo1_automute,
9777         },
9778         [ALC262_FUJITSU] = {
9779                 .mixers = { alc262_fujitsu_mixer },
9780                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9781                                 alc262_fujitsu_unsol_verbs },
9782                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9783                 .dac_nids = alc262_dac_nids,
9784                 .hp_nid = 0x03,
9785                 .dig_out_nid = ALC262_DIGOUT_NID,
9786                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9787                 .channel_mode = alc262_modes,
9788                 .input_mux = &alc262_fujitsu_capture_source,
9789                 .unsol_event = alc262_fujitsu_unsol_event,
9790                 .init_hook = alc262_fujitsu_init_hook,
9791         },
9792         [ALC262_HP_BPC] = {
9793                 .mixers = { alc262_HP_BPC_mixer },
9794                 .init_verbs = { alc262_HP_BPC_init_verbs },
9795                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9796                 .dac_nids = alc262_dac_nids,
9797                 .hp_nid = 0x03,
9798                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9799                 .channel_mode = alc262_modes,
9800                 .input_mux = &alc262_HP_capture_source,
9801                 .unsol_event = alc262_hp_bpc_unsol_event,
9802                 .init_hook = alc262_hp_bpc_automute,
9803         },
9804         [ALC262_HP_BPC_D7000_WF] = {
9805                 .mixers = { alc262_HP_BPC_WildWest_mixer },
9806                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9807                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9808                 .dac_nids = alc262_dac_nids,
9809                 .hp_nid = 0x03,
9810                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9811                 .channel_mode = alc262_modes,
9812                 .input_mux = &alc262_HP_D7000_capture_source,
9813                 .unsol_event = alc262_hp_wildwest_unsol_event,
9814                 .init_hook = alc262_hp_wildwest_automute,
9815         },
9816         [ALC262_HP_BPC_D7000_WL] = {
9817                 .mixers = { alc262_HP_BPC_WildWest_mixer,
9818                             alc262_HP_BPC_WildWest_option_mixer },
9819                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9820                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9821                 .dac_nids = alc262_dac_nids,
9822                 .hp_nid = 0x03,
9823                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9824                 .channel_mode = alc262_modes,
9825                 .input_mux = &alc262_HP_D7000_capture_source,
9826                 .unsol_event = alc262_hp_wildwest_unsol_event,
9827                 .init_hook = alc262_hp_wildwest_automute,
9828         },
9829         [ALC262_HP_TC_T5735] = {
9830                 .mixers = { alc262_hp_t5735_mixer },
9831                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
9832                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9833                 .dac_nids = alc262_dac_nids,
9834                 .hp_nid = 0x03,
9835                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9836                 .channel_mode = alc262_modes,
9837                 .input_mux = &alc262_capture_source,
9838                 .unsol_event = alc262_hp_t5735_unsol_event,
9839                 .init_hook = alc262_hp_t5735_init_hook,
9840         },
9841         [ALC262_HP_RP5700] = {
9842                 .mixers = { alc262_hp_rp5700_mixer },
9843                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
9844                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9845                 .dac_nids = alc262_dac_nids,
9846                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9847                 .channel_mode = alc262_modes,
9848                 .input_mux = &alc262_hp_rp5700_capture_source,
9849         },
9850         [ALC262_BENQ_ED8] = {
9851                 .mixers = { alc262_base_mixer },
9852                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
9853                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9854                 .dac_nids = alc262_dac_nids,
9855                 .hp_nid = 0x03,
9856                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9857                 .channel_mode = alc262_modes,
9858                 .input_mux = &alc262_capture_source,
9859         },
9860         [ALC262_SONY_ASSAMD] = {
9861                 .mixers = { alc262_sony_mixer },
9862                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
9863                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9864                 .dac_nids = alc262_dac_nids,
9865                 .hp_nid = 0x02,
9866                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9867                 .channel_mode = alc262_modes,
9868                 .input_mux = &alc262_capture_source,
9869                 .unsol_event = alc262_hippo_unsol_event,
9870                 .init_hook = alc262_hippo_automute,
9871         },
9872         [ALC262_BENQ_T31] = {
9873                 .mixers = { alc262_benq_t31_mixer },
9874                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
9875                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9876                 .dac_nids = alc262_dac_nids,
9877                 .hp_nid = 0x03,
9878                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9879                 .channel_mode = alc262_modes,
9880                 .input_mux = &alc262_capture_source,
9881                 .unsol_event = alc262_hippo_unsol_event,
9882                 .init_hook = alc262_hippo_automute,
9883         },
9884         [ALC262_ULTRA] = {
9885                 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
9886                 .init_verbs = { alc262_ultra_verbs },
9887                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9888                 .dac_nids = alc262_dac_nids,
9889                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9890                 .channel_mode = alc262_modes,
9891                 .input_mux = &alc262_ultra_capture_source,
9892                 .adc_nids = alc262_adc_nids, /* ADC0 */
9893                 .capsrc_nids = alc262_capsrc_nids,
9894                 .num_adc_nids = 1, /* single ADC */
9895                 .unsol_event = alc262_ultra_unsol_event,
9896                 .init_hook = alc262_ultra_automute,
9897         },
9898         [ALC262_LENOVO_3000] = {
9899                 .mixers = { alc262_lenovo_3000_mixer },
9900                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9901                                 alc262_lenovo_3000_unsol_verbs },
9902                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9903                 .dac_nids = alc262_dac_nids,
9904                 .hp_nid = 0x03,
9905                 .dig_out_nid = ALC262_DIGOUT_NID,
9906                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9907                 .channel_mode = alc262_modes,
9908                 .input_mux = &alc262_fujitsu_capture_source,
9909                 .unsol_event = alc262_lenovo_3000_unsol_event,
9910         },
9911 };
9912
9913 static int patch_alc262(struct hda_codec *codec)
9914 {
9915         struct alc_spec *spec;
9916         int board_config;
9917         int err;
9918
9919         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9920         if (spec == NULL)
9921                 return -ENOMEM;
9922
9923         codec->spec = spec;
9924 #if 0
9925         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
9926          * under-run
9927          */
9928         {
9929         int tmp;
9930         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9931         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
9932         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9933         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
9934         }
9935 #endif
9936
9937         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9938
9939         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
9940                                                   alc262_models,
9941                                                   alc262_cfg_tbl);
9942
9943         if (board_config < 0) {
9944                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
9945                        "trying auto-probe from BIOS...\n");
9946                 board_config = ALC262_AUTO;
9947         }
9948
9949         if (board_config == ALC262_AUTO) {
9950                 /* automatic parse from the BIOS config */
9951                 err = alc262_parse_auto_config(codec);
9952                 if (err < 0) {
9953                         alc_free(codec);
9954                         return err;
9955                 } else if (!err) {
9956                         printk(KERN_INFO
9957                                "hda_codec: Cannot set up configuration "
9958                                "from BIOS.  Using base mode...\n");
9959                         board_config = ALC262_BASIC;
9960                 }
9961         }
9962
9963         if (board_config != ALC262_AUTO)
9964                 setup_preset(spec, &alc262_presets[board_config]);
9965
9966         spec->stream_name_analog = "ALC262 Analog";
9967         spec->stream_analog_playback = &alc262_pcm_analog_playback;
9968         spec->stream_analog_capture = &alc262_pcm_analog_capture;
9969
9970         spec->stream_name_digital = "ALC262 Digital";
9971         spec->stream_digital_playback = &alc262_pcm_digital_playback;
9972         spec->stream_digital_capture = &alc262_pcm_digital_capture;
9973
9974         if (!spec->adc_nids && spec->input_mux) {
9975                 /* check whether NID 0x07 is valid */
9976                 unsigned int wcap = get_wcaps(codec, 0x07);
9977
9978                 /* get type */
9979                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9980                 if (wcap != AC_WID_AUD_IN) {
9981                         spec->adc_nids = alc262_adc_nids_alt;
9982                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
9983                         spec->capsrc_nids = alc262_capsrc_nids_alt;
9984                         spec->mixers[spec->num_mixers] =
9985                                 alc262_capture_alt_mixer;
9986                         spec->num_mixers++;
9987                 } else {
9988                         spec->adc_nids = alc262_adc_nids;
9989                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
9990                         spec->capsrc_nids = alc262_capsrc_nids;
9991                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
9992                         spec->num_mixers++;
9993                 }
9994         }
9995
9996         spec->vmaster_nid = 0x0c;
9997
9998         codec->patch_ops = alc_patch_ops;
9999         if (board_config == ALC262_AUTO)
10000                 spec->init_hook = alc262_auto_init;
10001 #ifdef CONFIG_SND_HDA_POWER_SAVE
10002         if (!spec->loopback.amplist)
10003                 spec->loopback.amplist = alc262_loopbacks;
10004 #endif
10005
10006         return 0;
10007 }
10008
10009 /*
10010  *  ALC268 channel source setting (2 channel)
10011  */
10012 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
10013 #define alc268_modes            alc260_modes
10014
10015 static hda_nid_t alc268_dac_nids[2] = {
10016         /* front, hp */
10017         0x02, 0x03
10018 };
10019
10020 static hda_nid_t alc268_adc_nids[2] = {
10021         /* ADC0-1 */
10022         0x08, 0x07
10023 };
10024
10025 static hda_nid_t alc268_adc_nids_alt[1] = {
10026         /* ADC0 */
10027         0x08
10028 };
10029
10030 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10031
10032 static struct snd_kcontrol_new alc268_base_mixer[] = {
10033         /* output mixer control */
10034         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10035         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10036         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10037         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10038         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10039         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10040         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10041         { }
10042 };
10043
10044 /* bind Beep switches of both NID 0x0f and 0x10 */
10045 static struct hda_bind_ctls alc268_bind_beep_sw = {
10046         .ops = &snd_hda_bind_sw,
10047         .values = {
10048                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10049                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10050                 0
10051         },
10052 };
10053
10054 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10055         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10056         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10057         { }
10058 };
10059
10060 static struct hda_verb alc268_eapd_verbs[] = {
10061         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10062         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10063         { }
10064 };
10065
10066 /* Toshiba specific */
10067 #define alc268_toshiba_automute alc262_hippo_automute
10068
10069 static struct hda_verb alc268_toshiba_verbs[] = {
10070         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10071         { } /* end */
10072 };
10073
10074 /* Acer specific */
10075 /* bind volumes of both NID 0x02 and 0x03 */
10076 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10077         .ops = &snd_hda_bind_vol,
10078         .values = {
10079                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10080                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10081                 0
10082         },
10083 };
10084
10085 /* mute/unmute internal speaker according to the hp jack and mute state */
10086 static void alc268_acer_automute(struct hda_codec *codec, int force)
10087 {
10088         struct alc_spec *spec = codec->spec;
10089         unsigned int mute;
10090
10091         if (force || !spec->sense_updated) {
10092                 unsigned int present;
10093                 present = snd_hda_codec_read(codec, 0x14, 0,
10094                                          AC_VERB_GET_PIN_SENSE, 0);
10095                 spec->jack_present = (present & 0x80000000) != 0;
10096                 spec->sense_updated = 1;
10097         }
10098         if (spec->jack_present)
10099                 mute = HDA_AMP_MUTE; /* mute internal speaker */
10100         else /* unmute internal speaker if necessary */
10101                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10102         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10103                                  HDA_AMP_MUTE, mute);
10104 }
10105
10106
10107 /* bind hp and internal speaker mute (with plug check) */
10108 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10109                                      struct snd_ctl_elem_value *ucontrol)
10110 {
10111         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10112         long *valp = ucontrol->value.integer.value;
10113         int change;
10114
10115         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10116                                           HDA_AMP_MUTE,
10117                                           valp[0] ? 0 : HDA_AMP_MUTE);
10118         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10119                                            HDA_AMP_MUTE,
10120                                            valp[1] ? 0 : HDA_AMP_MUTE);
10121         if (change)
10122                 alc268_acer_automute(codec, 0);
10123         return change;
10124 }
10125
10126 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10127         /* output mixer control */
10128         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10129         {
10130                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10131                 .name = "Master Playback Switch",
10132                 .info = snd_hda_mixer_amp_switch_info,
10133                 .get = snd_hda_mixer_amp_switch_get,
10134                 .put = alc268_acer_master_sw_put,
10135                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10136         },
10137         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10138         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10139         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10140         { }
10141 };
10142
10143 static struct hda_verb alc268_acer_verbs[] = {
10144         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10145         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10146         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10147         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10148         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10149         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10150
10151         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10152         { }
10153 };
10154
10155 /* unsolicited event for HP jack sensing */
10156 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10157                                        unsigned int res)
10158 {
10159         if ((res >> 26) != ALC880_HP_EVENT)
10160                 return;
10161         alc268_toshiba_automute(codec);
10162 }
10163
10164 static void alc268_acer_unsol_event(struct hda_codec *codec,
10165                                        unsigned int res)
10166 {
10167         if ((res >> 26) != ALC880_HP_EVENT)
10168                 return;
10169         alc268_acer_automute(codec, 1);
10170 }
10171
10172 static void alc268_acer_init_hook(struct hda_codec *codec)
10173 {
10174         alc268_acer_automute(codec, 1);
10175 }
10176
10177 static struct snd_kcontrol_new alc268_dell_mixer[] = {
10178         /* output mixer control */
10179         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10180         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10181         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10182         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10183         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10184         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10185         { }
10186 };
10187
10188 static struct hda_verb alc268_dell_verbs[] = {
10189         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10190         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10191         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10192         { }
10193 };
10194
10195 /* mute/unmute internal speaker according to the hp jack and mute state */
10196 static void alc268_dell_automute(struct hda_codec *codec)
10197 {
10198         unsigned int present;
10199         unsigned int mute;
10200
10201         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
10202         if (present & 0x80000000)
10203                 mute = HDA_AMP_MUTE;
10204         else
10205                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
10206         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10207                                  HDA_AMP_MUTE, mute);
10208 }
10209
10210 static void alc268_dell_unsol_event(struct hda_codec *codec,
10211                                     unsigned int res)
10212 {
10213         if ((res >> 26) != ALC880_HP_EVENT)
10214                 return;
10215         alc268_dell_automute(codec);
10216 }
10217
10218 #define alc268_dell_init_hook   alc268_dell_automute
10219
10220 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
10221         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10222         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10223         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10224         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10225         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10226         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
10227         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
10228         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10229         { }
10230 };
10231
10232 static struct hda_verb alc267_quanta_il1_verbs[] = {
10233         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10234         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
10235         { }
10236 };
10237
10238 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
10239 {
10240         unsigned int present;
10241
10242         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
10243                 & AC_PINSENSE_PRESENCE;
10244         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
10245                             present ? 0 : PIN_OUT);
10246 }
10247
10248 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
10249 {
10250         unsigned int present;
10251
10252         present = snd_hda_codec_read(codec, 0x18, 0,
10253                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10254         snd_hda_codec_write(codec, 0x23, 0,
10255                             AC_VERB_SET_CONNECT_SEL,
10256                             present ? 0x00 : 0x01);
10257 }
10258
10259 static void alc267_quanta_il1_automute(struct hda_codec *codec)
10260 {
10261         alc267_quanta_il1_hp_automute(codec);
10262         alc267_quanta_il1_mic_automute(codec);
10263 }
10264
10265 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
10266                                            unsigned int res)
10267 {
10268         switch (res >> 26) {
10269         case ALC880_HP_EVENT:
10270                 alc267_quanta_il1_hp_automute(codec);
10271                 break;
10272         case ALC880_MIC_EVENT:
10273                 alc267_quanta_il1_mic_automute(codec);
10274                 break;
10275         }
10276 }
10277
10278 /*
10279  * generic initialization of ADC, input mixers and output mixers
10280  */
10281 static struct hda_verb alc268_base_init_verbs[] = {
10282         /* Unmute DAC0-1 and set vol = 0 */
10283         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10284         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10285         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10286         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10287         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10288         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10289
10290         /*
10291          * Set up output mixers (0x0c - 0x0e)
10292          */
10293         /* set vol=0 to output mixers */
10294         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10295         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10296         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10297         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
10298
10299         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10300         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10301
10302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10303         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10304         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10305         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10306         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10307         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10308         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10309         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10310
10311         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10312         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10313         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10314         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10315         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10316         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10317         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10318
10319         /* set PCBEEP vol = 0, mute connections */
10320         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10321         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10322         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10323
10324         /* Unmute Selector 23h,24h and set the default input to mic-in */
10325
10326         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
10327         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10328         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
10329         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10330
10331         { }
10332 };
10333
10334 /*
10335  * generic initialization of ADC, input mixers and output mixers
10336  */
10337 static struct hda_verb alc268_volume_init_verbs[] = {
10338         /* set output DAC */
10339         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10340         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10341         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10342         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10343
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         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10351         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10352         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10353         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10354         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10355
10356         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10357         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10358         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10359         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10360
10361         /* set PCBEEP vol = 0, mute connections */
10362         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10363         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10364         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10365
10366         { }
10367 };
10368
10369 #define alc268_mux_enum_info alc_mux_enum_info
10370 #define alc268_mux_enum_get alc_mux_enum_get
10371 #define alc268_mux_enum_put alc_mux_enum_put
10372
10373 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
10374         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10375         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
10376         {
10377                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10378                 /* The multiple "Capture Source" controls confuse alsamixer
10379                  * So call somewhat different..
10380                  */
10381                 /* .name = "Capture Source", */
10382                 .name = "Input Source",
10383                 .count = 1,
10384                 .info = alc268_mux_enum_info,
10385                 .get = alc268_mux_enum_get,
10386                 .put = alc268_mux_enum_put,
10387         },
10388         { } /* end */
10389 };
10390
10391 static struct snd_kcontrol_new alc268_capture_mixer[] = {
10392         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10393         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
10394         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
10395         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
10396         {
10397                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10398                 /* The multiple "Capture Source" controls confuse alsamixer
10399                  * So call somewhat different..
10400                  */
10401                 /* .name = "Capture Source", */
10402                 .name = "Input Source",
10403                 .count = 2,
10404                 .info = alc268_mux_enum_info,
10405                 .get = alc268_mux_enum_get,
10406                 .put = alc268_mux_enum_put,
10407         },
10408         { } /* end */
10409 };
10410
10411 static struct hda_input_mux alc268_capture_source = {
10412         .num_items = 4,
10413         .items = {
10414                 { "Mic", 0x0 },
10415                 { "Front Mic", 0x1 },
10416                 { "Line", 0x2 },
10417                 { "CD", 0x3 },
10418         },
10419 };
10420
10421 static struct hda_input_mux alc268_acer_capture_source = {
10422         .num_items = 3,
10423         .items = {
10424                 { "Mic", 0x0 },
10425                 { "Internal Mic", 0x6 },
10426                 { "Line", 0x2 },
10427         },
10428 };
10429
10430 #ifdef CONFIG_SND_DEBUG
10431 static struct snd_kcontrol_new alc268_test_mixer[] = {
10432         /* Volume widgets */
10433         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10434         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10435         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
10436         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
10437         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
10438         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
10439         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
10440         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
10441         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
10442         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
10443         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
10444         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
10445         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
10446         /* The below appears problematic on some hardwares */
10447         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
10448         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10449         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
10450         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
10451         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
10452
10453         /* Modes for retasking pin widgets */
10454         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
10455         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
10456         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
10457         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
10458
10459         /* Controls for GPIO pins, assuming they are configured as outputs */
10460         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
10461         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
10462         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
10463         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
10464
10465         /* Switches to allow the digital SPDIF output pin to be enabled.
10466          * The ALC268 does not have an SPDIF input.
10467          */
10468         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
10469
10470         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
10471          * this output to turn on an external amplifier.
10472          */
10473         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
10474         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
10475
10476         { } /* end */
10477 };
10478 #endif
10479
10480 /* create input playback/capture controls for the given pin */
10481 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
10482                                     const char *ctlname, int idx)
10483 {
10484         char name[32];
10485         int err;
10486
10487         sprintf(name, "%s Playback Volume", ctlname);
10488         if (nid == 0x14) {
10489                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
10490                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
10491                                                       HDA_OUTPUT));
10492                 if (err < 0)
10493                         return err;
10494         } else if (nid == 0x15) {
10495                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
10496                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
10497                                                       HDA_OUTPUT));
10498                 if (err < 0)
10499                         return err;
10500         } else
10501                 return -1;
10502         sprintf(name, "%s Playback Switch", ctlname);
10503         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
10504                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
10505         if (err < 0)
10506                 return err;
10507         return 0;
10508 }
10509
10510 /* add playback controls from the parsed DAC table */
10511 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
10512                                              const struct auto_pin_cfg *cfg)
10513 {
10514         hda_nid_t nid;
10515         int err;
10516
10517         spec->multiout.num_dacs = 2;    /* only use one dac */
10518         spec->multiout.dac_nids = spec->private_dac_nids;
10519         spec->multiout.dac_nids[0] = 2;
10520         spec->multiout.dac_nids[1] = 3;
10521
10522         nid = cfg->line_out_pins[0];
10523         if (nid)
10524                 alc268_new_analog_output(spec, nid, "Front", 0);
10525
10526         nid = cfg->speaker_pins[0];
10527         if (nid == 0x1d) {
10528                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10529                                   "Speaker Playback Volume",
10530                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10531                 if (err < 0)
10532                         return err;
10533         }
10534         nid = cfg->hp_pins[0];
10535         if (nid)
10536                 alc268_new_analog_output(spec, nid, "Headphone", 0);
10537
10538         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
10539         if (nid == 0x16) {
10540                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10541                                   "Mono Playback Switch",
10542                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
10543                 if (err < 0)
10544                         return err;
10545         }
10546         return 0;
10547 }
10548
10549 /* create playback/capture controls for input pins */
10550 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
10551                                                 const struct auto_pin_cfg *cfg)
10552 {
10553         struct hda_input_mux *imux = &spec->private_imux;
10554         int i, idx1;
10555
10556         for (i = 0; i < AUTO_PIN_LAST; i++) {
10557                 switch(cfg->input_pins[i]) {
10558                 case 0x18:
10559                         idx1 = 0;       /* Mic 1 */
10560                         break;
10561                 case 0x19:
10562                         idx1 = 1;       /* Mic 2 */
10563                         break;
10564                 case 0x1a:
10565                         idx1 = 2;       /* Line In */
10566                         break;
10567                 case 0x1c:
10568                         idx1 = 3;       /* CD */
10569                         break;
10570                 case 0x12:
10571                 case 0x13:
10572                         idx1 = 6;       /* digital mics */
10573                         break;
10574                 default:
10575                         continue;
10576                 }
10577                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
10578                 imux->items[imux->num_items].index = idx1;
10579                 imux->num_items++;
10580         }
10581         return 0;
10582 }
10583
10584 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
10585 {
10586         struct alc_spec *spec = codec->spec;
10587         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10588         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10589         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10590         unsigned int    dac_vol1, dac_vol2;
10591
10592         if (speaker_nid) {
10593                 snd_hda_codec_write(codec, speaker_nid, 0,
10594                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
10595                 snd_hda_codec_write(codec, 0x0f, 0,
10596                                     AC_VERB_SET_AMP_GAIN_MUTE,
10597                                     AMP_IN_UNMUTE(1));
10598                 snd_hda_codec_write(codec, 0x10, 0,
10599                                     AC_VERB_SET_AMP_GAIN_MUTE,
10600                                     AMP_IN_UNMUTE(1));
10601         } else {
10602                 snd_hda_codec_write(codec, 0x0f, 0,
10603                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
10604                 snd_hda_codec_write(codec, 0x10, 0,
10605                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
10606         }
10607
10608         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
10609         if (line_nid == 0x14)
10610                 dac_vol2 = AMP_OUT_ZERO;
10611         else if (line_nid == 0x15)
10612                 dac_vol1 = AMP_OUT_ZERO;
10613         if (hp_nid == 0x14)
10614                 dac_vol2 = AMP_OUT_ZERO;
10615         else if (hp_nid == 0x15)
10616                 dac_vol1 = AMP_OUT_ZERO;
10617         if (line_nid != 0x16 || hp_nid != 0x16 ||
10618             spec->autocfg.line_out_pins[1] != 0x16 ||
10619             spec->autocfg.line_out_pins[2] != 0x16)
10620                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
10621
10622         snd_hda_codec_write(codec, 0x02, 0,
10623                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
10624         snd_hda_codec_write(codec, 0x03, 0,
10625                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
10626 }
10627
10628 /* pcm configuration: identiacal with ALC880 */
10629 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
10630 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
10631 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
10632 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
10633
10634 /*
10635  * BIOS auto configuration
10636  */
10637 static int alc268_parse_auto_config(struct hda_codec *codec)
10638 {
10639         struct alc_spec *spec = codec->spec;
10640         int err;
10641         static hda_nid_t alc268_ignore[] = { 0 };
10642
10643         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10644                                            alc268_ignore);
10645         if (err < 0)
10646                 return err;
10647         if (!spec->autocfg.line_outs)
10648                 return 0; /* can't find valid BIOS pin config */
10649
10650         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
10651         if (err < 0)
10652                 return err;
10653         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
10654         if (err < 0)
10655                 return err;
10656
10657         spec->multiout.max_channels = 2;
10658
10659         /* digital only support output */
10660         if (spec->autocfg.dig_out_pin)
10661                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
10662
10663         if (spec->kctl_alloc)
10664                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10665
10666         if (spec->autocfg.speaker_pins[0] != 0x1d)
10667                 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
10668
10669         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
10670         spec->num_mux_defs = 1;
10671         spec->input_mux = &spec->private_imux;
10672
10673         err = alc_auto_add_mic_boost(codec);
10674         if (err < 0)
10675                 return err;
10676
10677         return 1;
10678 }
10679
10680 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
10681 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
10682 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
10683
10684 /* init callback for auto-configuration model -- overriding the default init */
10685 static void alc268_auto_init(struct hda_codec *codec)
10686 {
10687         struct alc_spec *spec = codec->spec;
10688         alc268_auto_init_multi_out(codec);
10689         alc268_auto_init_hp_out(codec);
10690         alc268_auto_init_mono_speaker_out(codec);
10691         alc268_auto_init_analog_input(codec);
10692         if (spec->unsol_event)
10693                 alc_sku_automute(codec);
10694 }
10695
10696 /*
10697  * configuration and preset
10698  */
10699 static const char *alc268_models[ALC268_MODEL_LAST] = {
10700         [ALC267_QUANTA_IL1]     = "quanta-il1",
10701         [ALC268_3ST]            = "3stack",
10702         [ALC268_TOSHIBA]        = "toshiba",
10703         [ALC268_ACER]           = "acer",
10704         [ALC268_DELL]           = "dell",
10705         [ALC268_ZEPTO]          = "zepto",
10706 #ifdef CONFIG_SND_DEBUG
10707         [ALC268_TEST]           = "test",
10708 #endif
10709         [ALC268_AUTO]           = "auto",
10710 };
10711
10712 static struct snd_pci_quirk alc268_cfg_tbl[] = {
10713         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
10714         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
10715         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
10716         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
10717         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
10718         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
10719         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
10720         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
10721         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
10722         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
10723         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
10724         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
10725         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
10726         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
10727         {}
10728 };
10729
10730 static struct alc_config_preset alc268_presets[] = {
10731         [ALC267_QUANTA_IL1] = {
10732                 .mixers = { alc267_quanta_il1_mixer },
10733                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10734                                 alc267_quanta_il1_verbs },
10735                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10736                 .dac_nids = alc268_dac_nids,
10737                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10738                 .adc_nids = alc268_adc_nids_alt,
10739                 .hp_nid = 0x03,
10740                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10741                 .channel_mode = alc268_modes,
10742                 .input_mux = &alc268_capture_source,
10743                 .unsol_event = alc267_quanta_il1_unsol_event,
10744                 .init_hook = alc267_quanta_il1_automute,
10745         },
10746         [ALC268_3ST] = {
10747                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10748                             alc268_beep_mixer },
10749                 .init_verbs = { alc268_base_init_verbs },
10750                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10751                 .dac_nids = alc268_dac_nids,
10752                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10753                 .adc_nids = alc268_adc_nids_alt,
10754                 .capsrc_nids = alc268_capsrc_nids,
10755                 .hp_nid = 0x03,
10756                 .dig_out_nid = ALC268_DIGOUT_NID,
10757                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10758                 .channel_mode = alc268_modes,
10759                 .input_mux = &alc268_capture_source,
10760         },
10761         [ALC268_TOSHIBA] = {
10762                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10763                             alc268_beep_mixer },
10764                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10765                                 alc268_toshiba_verbs },
10766                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10767                 .dac_nids = alc268_dac_nids,
10768                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10769                 .adc_nids = alc268_adc_nids_alt,
10770                 .capsrc_nids = alc268_capsrc_nids,
10771                 .hp_nid = 0x03,
10772                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10773                 .channel_mode = alc268_modes,
10774                 .input_mux = &alc268_capture_source,
10775                 .unsol_event = alc268_toshiba_unsol_event,
10776                 .init_hook = alc268_toshiba_automute,
10777         },
10778         [ALC268_ACER] = {
10779                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
10780                             alc268_beep_mixer },
10781                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10782                                 alc268_acer_verbs },
10783                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10784                 .dac_nids = alc268_dac_nids,
10785                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10786                 .adc_nids = alc268_adc_nids_alt,
10787                 .capsrc_nids = alc268_capsrc_nids,
10788                 .hp_nid = 0x02,
10789                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10790                 .channel_mode = alc268_modes,
10791                 .input_mux = &alc268_acer_capture_source,
10792                 .unsol_event = alc268_acer_unsol_event,
10793                 .init_hook = alc268_acer_init_hook,
10794         },
10795         [ALC268_DELL] = {
10796                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
10797                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10798                                 alc268_dell_verbs },
10799                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10800                 .dac_nids = alc268_dac_nids,
10801                 .hp_nid = 0x02,
10802                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10803                 .channel_mode = alc268_modes,
10804                 .unsol_event = alc268_dell_unsol_event,
10805                 .init_hook = alc268_dell_init_hook,
10806                 .input_mux = &alc268_capture_source,
10807         },
10808         [ALC268_ZEPTO] = {
10809                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
10810                             alc268_beep_mixer },
10811                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10812                                 alc268_toshiba_verbs },
10813                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10814                 .dac_nids = alc268_dac_nids,
10815                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10816                 .adc_nids = alc268_adc_nids_alt,
10817                 .capsrc_nids = alc268_capsrc_nids,
10818                 .hp_nid = 0x03,
10819                 .dig_out_nid = ALC268_DIGOUT_NID,
10820                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10821                 .channel_mode = alc268_modes,
10822                 .input_mux = &alc268_capture_source,
10823                 .unsol_event = alc268_toshiba_unsol_event,
10824                 .init_hook = alc268_toshiba_automute
10825         },
10826 #ifdef CONFIG_SND_DEBUG
10827         [ALC268_TEST] = {
10828                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
10829                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10830                                 alc268_volume_init_verbs },
10831                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10832                 .dac_nids = alc268_dac_nids,
10833                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10834                 .adc_nids = alc268_adc_nids_alt,
10835                 .capsrc_nids = alc268_capsrc_nids,
10836                 .hp_nid = 0x03,
10837                 .dig_out_nid = ALC268_DIGOUT_NID,
10838                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10839                 .channel_mode = alc268_modes,
10840                 .input_mux = &alc268_capture_source,
10841         },
10842 #endif
10843 };
10844
10845 static int patch_alc268(struct hda_codec *codec)
10846 {
10847         struct alc_spec *spec;
10848         int board_config;
10849         int err;
10850
10851         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
10852         if (spec == NULL)
10853                 return -ENOMEM;
10854
10855         codec->spec = spec;
10856
10857         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
10858                                                   alc268_models,
10859                                                   alc268_cfg_tbl);
10860
10861         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
10862                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
10863                        "trying auto-probe from BIOS...\n");
10864                 board_config = ALC268_AUTO;
10865         }
10866
10867         if (board_config == ALC268_AUTO) {
10868                 /* automatic parse from the BIOS config */
10869                 err = alc268_parse_auto_config(codec);
10870                 if (err < 0) {
10871                         alc_free(codec);
10872                         return err;
10873                 } else if (!err) {
10874                         printk(KERN_INFO
10875                                "hda_codec: Cannot set up configuration "
10876                                "from BIOS.  Using base mode...\n");
10877                         board_config = ALC268_3ST;
10878                 }
10879         }
10880
10881         if (board_config != ALC268_AUTO)
10882                 setup_preset(spec, &alc268_presets[board_config]);
10883
10884         if (codec->vendor_id == 0x10ec0267) {
10885                 spec->stream_name_analog = "ALC267 Analog";
10886                 spec->stream_name_digital = "ALC267 Digital";
10887         } else {
10888                 spec->stream_name_analog = "ALC268 Analog";
10889                 spec->stream_name_digital = "ALC268 Digital";
10890         }
10891
10892         spec->stream_analog_playback = &alc268_pcm_analog_playback;
10893         spec->stream_analog_capture = &alc268_pcm_analog_capture;
10894         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
10895
10896         spec->stream_digital_playback = &alc268_pcm_digital_playback;
10897
10898         if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
10899                 /* override the amp caps for beep generator */
10900                 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
10901                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
10902                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
10903                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
10904                                           (0 << AC_AMPCAP_MUTE_SHIFT));
10905
10906         if (!spec->adc_nids && spec->input_mux) {
10907                 /* check whether NID 0x07 is valid */
10908                 unsigned int wcap = get_wcaps(codec, 0x07);
10909                 int i;
10910
10911                 /* get type */
10912                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10913                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
10914                         spec->adc_nids = alc268_adc_nids_alt;
10915                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
10916                         spec->mixers[spec->num_mixers] =
10917                                         alc268_capture_alt_mixer;
10918                         spec->num_mixers++;
10919                 } else {
10920                         spec->adc_nids = alc268_adc_nids;
10921                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
10922                         spec->mixers[spec->num_mixers] =
10923                                 alc268_capture_mixer;
10924                         spec->num_mixers++;
10925                 }
10926                 spec->capsrc_nids = alc268_capsrc_nids;
10927                 /* set default input source */
10928                 for (i = 0; i < spec->num_adc_nids; i++)
10929                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
10930                                 0, AC_VERB_SET_CONNECT_SEL,
10931                                 spec->input_mux->items[0].index);
10932         }
10933
10934         spec->vmaster_nid = 0x02;
10935
10936         codec->patch_ops = alc_patch_ops;
10937         if (board_config == ALC268_AUTO)
10938                 spec->init_hook = alc268_auto_init;
10939
10940         return 0;
10941 }
10942
10943 /*
10944  *  ALC269 channel source setting (2 channel)
10945  */
10946 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
10947
10948 #define alc269_dac_nids         alc260_dac_nids
10949
10950 static hda_nid_t alc269_adc_nids[1] = {
10951         /* ADC1 */
10952         0x08,
10953 };
10954
10955 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
10956         .num_items = 2,
10957         .items = {
10958                 { "i-Mic", 0x5 },
10959                 { "e-Mic", 0x0 },
10960         },
10961 };
10962
10963 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
10964         .num_items = 2,
10965         .items = {
10966                 { "i-Mic", 0x1 },
10967                 { "e-Mic", 0x0 },
10968         },
10969 };
10970
10971 #define alc269_modes            alc260_modes
10972 #define alc269_capture_source   alc880_lg_lw_capture_source
10973
10974 static struct snd_kcontrol_new alc269_base_mixer[] = {
10975         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10976         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10977         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10978         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10979         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10980         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10981         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10982         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10983         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10984         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10985         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10986         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10987         { } /* end */
10988 };
10989
10990 /* bind volumes of both NID 0x0c and 0x0d */
10991 static struct hda_bind_ctls alc269_epc_bind_vol = {
10992         .ops = &snd_hda_bind_vol,
10993         .values = {
10994                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10995                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10996                 0
10997         },
10998 };
10999
11000 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11001         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11002         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11003         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11004         { } /* end */
11005 };
11006
11007 /* capture mixer elements */
11008 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11009         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11010         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11011         {
11012                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11013                 /* The multiple "Capture Source" controls confuse alsamixer
11014                  * So call somewhat different..
11015                  */
11016                 /* .name = "Capture Source", */
11017                 .name = "Input Source",
11018                 .count = 1,
11019                 .info = alc_mux_enum_info,
11020                 .get = alc_mux_enum_get,
11021                 .put = alc_mux_enum_put,
11022         },
11023         { } /* end */
11024 };
11025
11026 /* capture mixer elements */
11027 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11028         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11029         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11030         { } /* end */
11031 };
11032
11033 /*
11034  * generic initialization of ADC, input mixers and output mixers
11035  */
11036 static struct hda_verb alc269_init_verbs[] = {
11037         /*
11038          * Unmute ADC0 and set the default input to mic-in
11039          */
11040         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11041
11042         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
11043          * analog-loopback mixer widget
11044          * Note: PASD motherboards uses the Line In 2 as the input for
11045          * front panel mic (mic 2)
11046          */
11047         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11049         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11050         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11051         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11052         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11053
11054         /*
11055          * Set up output mixers (0x0c - 0x0e)
11056          */
11057         /* set vol=0 to output mixers */
11058         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11059         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11060
11061         /* set up input amps for analog loopback */
11062         /* Amp Indices: DAC = 0, mixer = 1 */
11063         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11064         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11065         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11066         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11067         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11068         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11069
11070         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11071         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11072         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11073         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11074         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11075         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11076         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11077
11078         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11079         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11080         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11081         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11082         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11083         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11084         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11085
11086         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11087         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11088
11089         /* FIXME: use matrix-type input source selection */
11090         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
11091         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11092         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11093         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11094         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11095         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11096
11097         /* set EAPD */
11098         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11099         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11100         { }
11101 };
11102
11103 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
11104         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11105         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
11106         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11107         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
11108         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11109         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11110         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11111         {}
11112 };
11113
11114 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
11115         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11116         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
11117         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11118         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
11119         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11120         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11121         {}
11122 };
11123
11124 /* toggle speaker-output according to the hp-jack state */
11125 static void alc269_speaker_automute(struct hda_codec *codec)
11126 {
11127         unsigned int present;
11128         unsigned int bits;
11129
11130         present = snd_hda_codec_read(codec, 0x15, 0,
11131                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11132         bits = present ? AMP_IN_MUTE(0) : 0;
11133         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11134                                  AMP_IN_MUTE(0), bits);
11135         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11136                                  AMP_IN_MUTE(0), bits);
11137 }
11138
11139 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
11140 {
11141         unsigned int present;
11142
11143         present = snd_hda_codec_read(codec, 0x18, 0, AC_VERB_GET_PIN_SENSE, 0)
11144                 & AC_PINSENSE_PRESENCE;
11145         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11146                             present ? 0 : 5);
11147 }
11148
11149 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
11150 {
11151         unsigned int present;
11152
11153         present = snd_hda_codec_read(codec, 0x18, 0, AC_VERB_GET_PIN_SENSE, 0)
11154                 & AC_PINSENSE_PRESENCE;
11155         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11156                             present ? AMP_IN_UNMUTE(0) : AMP_IN_MUTE(0));
11157         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11158                             present ? AMP_IN_MUTE(1) : AMP_IN_UNMUTE(1));
11159 }
11160
11161 /* unsolicited event for HP jack sensing */
11162 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
11163                                           unsigned int res)
11164 {
11165         if ((res >> 26) == ALC880_HP_EVENT)
11166                 alc269_speaker_automute(codec);
11167
11168         if ((res >> 26) == ALC880_MIC_EVENT)
11169                 alc269_eeepc_dmic_automute(codec);
11170 }
11171
11172 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
11173 {
11174         alc269_speaker_automute(codec);
11175         alc269_eeepc_dmic_automute(codec);
11176 }
11177
11178 /* unsolicited event for HP jack sensing */
11179 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
11180                                           unsigned int res)
11181 {
11182         if ((res >> 26) == ALC880_HP_EVENT)
11183                 alc269_speaker_automute(codec);
11184
11185         if ((res >> 26) == ALC880_MIC_EVENT)
11186                 alc269_eeepc_amic_automute(codec);
11187 }
11188
11189 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
11190 {
11191         alc269_speaker_automute(codec);
11192         alc269_eeepc_amic_automute(codec);
11193 }
11194
11195 /* add playback controls from the parsed DAC table */
11196 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
11197                                              const struct auto_pin_cfg *cfg)
11198 {
11199         hda_nid_t nid;
11200         int err;
11201
11202         spec->multiout.num_dacs = 1;    /* only use one dac */
11203         spec->multiout.dac_nids = spec->private_dac_nids;
11204         spec->multiout.dac_nids[0] = 2;
11205
11206         nid = cfg->line_out_pins[0];
11207         if (nid) {
11208                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11209                                   "Front Playback Volume",
11210                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
11211                 if (err < 0)
11212                         return err;
11213                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11214                                   "Front Playback Switch",
11215                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
11216                 if (err < 0)
11217                         return err;
11218         }
11219
11220         nid = cfg->speaker_pins[0];
11221         if (nid) {
11222                 if (!cfg->line_out_pins[0]) {
11223                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
11224                                           "Speaker Playback Volume",
11225                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
11226                                                               HDA_OUTPUT));
11227                         if (err < 0)
11228                                 return err;
11229                 }
11230                 if (nid == 0x16) {
11231                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11232                                           "Speaker Playback Switch",
11233                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11234                                                               HDA_OUTPUT));
11235                         if (err < 0)
11236                                 return err;
11237                 } else {
11238                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11239                                           "Speaker Playback Switch",
11240                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11241                                                               HDA_OUTPUT));
11242                         if (err < 0)
11243                                 return err;
11244                 }
11245         }
11246         nid = cfg->hp_pins[0];
11247         if (nid) {
11248                 /* spec->multiout.hp_nid = 2; */
11249                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
11250                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
11251                                           "Headphone Playback Volume",
11252                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
11253                                                               HDA_OUTPUT));
11254                         if (err < 0)
11255                                 return err;
11256                 }
11257                 if (nid == 0x16) {
11258                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11259                                           "Headphone Playback Switch",
11260                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11261                                                               HDA_OUTPUT));
11262                         if (err < 0)
11263                                 return err;
11264                 } else {
11265                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11266                                           "Headphone Playback Switch",
11267                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11268                                                               HDA_OUTPUT));
11269                         if (err < 0)
11270                                 return err;
11271                 }
11272         }
11273         return 0;
11274 }
11275
11276 #define alc269_auto_create_analog_input_ctls \
11277         alc880_auto_create_analog_input_ctls
11278
11279 #ifdef CONFIG_SND_HDA_POWER_SAVE
11280 #define alc269_loopbacks        alc880_loopbacks
11281 #endif
11282
11283 /* pcm configuration: identiacal with ALC880 */
11284 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
11285 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
11286 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
11287 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
11288
11289 /*
11290  * BIOS auto configuration
11291  */
11292 static int alc269_parse_auto_config(struct hda_codec *codec)
11293 {
11294         struct alc_spec *spec = codec->spec;
11295         int err;
11296         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
11297
11298         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11299                                            alc269_ignore);
11300         if (err < 0)
11301                 return err;
11302
11303         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
11304         if (err < 0)
11305                 return err;
11306         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
11307         if (err < 0)
11308                 return err;
11309
11310         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11311
11312         if (spec->autocfg.dig_out_pin)
11313                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
11314
11315         if (spec->kctl_alloc)
11316                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11317
11318         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
11319         spec->num_mux_defs = 1;
11320         spec->input_mux = &spec->private_imux;
11321
11322         err = alc_auto_add_mic_boost(codec);
11323         if (err < 0)
11324                 return err;
11325
11326         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
11327         spec->num_mixers++;
11328
11329         return 1;
11330 }
11331
11332 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
11333 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
11334 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
11335
11336
11337 /* init callback for auto-configuration model -- overriding the default init */
11338 static void alc269_auto_init(struct hda_codec *codec)
11339 {
11340         struct alc_spec *spec = codec->spec;
11341         alc269_auto_init_multi_out(codec);
11342         alc269_auto_init_hp_out(codec);
11343         alc269_auto_init_analog_input(codec);
11344         if (spec->unsol_event)
11345                 alc_sku_automute(codec);
11346 }
11347
11348 /*
11349  * configuration and preset
11350  */
11351 static const char *alc269_models[ALC269_MODEL_LAST] = {
11352         [ALC269_BASIC]          = "basic",
11353 };
11354
11355 static struct snd_pci_quirk alc269_cfg_tbl[] = {
11356         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
11357                       ALC269_ASUS_EEEPC_P703),
11358         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
11359                       ALC269_ASUS_EEEPC_P901),
11360         {}
11361 };
11362
11363 static struct alc_config_preset alc269_presets[] = {
11364         [ALC269_BASIC] = {
11365                 .mixers = { alc269_base_mixer, alc269_capture_mixer },
11366                 .init_verbs = { alc269_init_verbs },
11367                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11368                 .dac_nids = alc269_dac_nids,
11369                 .hp_nid = 0x03,
11370                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11371                 .channel_mode = alc269_modes,
11372                 .input_mux = &alc269_capture_source,
11373         },
11374         [ALC269_ASUS_EEEPC_P703] = {
11375                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
11376                 .init_verbs = { alc269_init_verbs,
11377                                 alc269_eeepc_amic_init_verbs },
11378                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11379                 .dac_nids = alc269_dac_nids,
11380                 .hp_nid = 0x03,
11381                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11382                 .channel_mode = alc269_modes,
11383                 .input_mux = &alc269_eeepc_amic_capture_source,
11384                 .unsol_event = alc269_eeepc_amic_unsol_event,
11385                 .init_hook = alc269_eeepc_amic_inithook,
11386         },
11387         [ALC269_ASUS_EEEPC_P901] = {
11388                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
11389                 .init_verbs = { alc269_init_verbs,
11390                                 alc269_eeepc_dmic_init_verbs },
11391                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
11392                 .dac_nids = alc269_dac_nids,
11393                 .hp_nid = 0x03,
11394                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
11395                 .channel_mode = alc269_modes,
11396                 .input_mux = &alc269_eeepc_dmic_capture_source,
11397                 .unsol_event = alc269_eeepc_dmic_unsol_event,
11398                 .init_hook = alc269_eeepc_dmic_inithook,
11399         },
11400 };
11401
11402 static int patch_alc269(struct hda_codec *codec)
11403 {
11404         struct alc_spec *spec;
11405         int board_config;
11406         int err;
11407
11408         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11409         if (spec == NULL)
11410                 return -ENOMEM;
11411
11412         codec->spec = spec;
11413
11414         alc_fix_pll_init(codec, 0x20, 0x04, 15);
11415
11416         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
11417                                                   alc269_models,
11418                                                   alc269_cfg_tbl);
11419
11420         if (board_config < 0) {
11421                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
11422                        "trying auto-probe from BIOS...\n");
11423                 board_config = ALC269_AUTO;
11424         }
11425
11426         if (board_config == ALC269_AUTO) {
11427                 /* automatic parse from the BIOS config */
11428                 err = alc269_parse_auto_config(codec);
11429                 if (err < 0) {
11430                         alc_free(codec);
11431                         return err;
11432                 } else if (!err) {
11433                         printk(KERN_INFO
11434                                "hda_codec: Cannot set up configuration "
11435                                "from BIOS.  Using base mode...\n");
11436                         board_config = ALC269_BASIC;
11437                 }
11438         }
11439
11440         if (board_config != ALC269_AUTO)
11441                 setup_preset(spec, &alc269_presets[board_config]);
11442
11443         spec->stream_name_analog = "ALC269 Analog";
11444         spec->stream_analog_playback = &alc269_pcm_analog_playback;
11445         spec->stream_analog_capture = &alc269_pcm_analog_capture;
11446
11447         spec->stream_name_digital = "ALC269 Digital";
11448         spec->stream_digital_playback = &alc269_pcm_digital_playback;
11449         spec->stream_digital_capture = &alc269_pcm_digital_capture;
11450
11451         spec->adc_nids = alc269_adc_nids;
11452         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
11453
11454         codec->patch_ops = alc_patch_ops;
11455         if (board_config == ALC269_AUTO)
11456                 spec->init_hook = alc269_auto_init;
11457 #ifdef CONFIG_SND_HDA_POWER_SAVE
11458         if (!spec->loopback.amplist)
11459                 spec->loopback.amplist = alc269_loopbacks;
11460 #endif
11461
11462         return 0;
11463 }
11464
11465 /*
11466  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
11467  */
11468
11469 /*
11470  * set the path ways for 2 channel output
11471  * need to set the codec line out and mic 1 pin widgets to inputs
11472  */
11473 static struct hda_verb alc861_threestack_ch2_init[] = {
11474         /* set pin widget 1Ah (line in) for input */
11475         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11476         /* set pin widget 18h (mic1/2) for input, for mic also enable
11477          * the vref
11478          */
11479         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11480
11481         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
11482 #if 0
11483         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11484         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
11485 #endif
11486         { } /* end */
11487 };
11488 /*
11489  * 6ch mode
11490  * need to set the codec line out and mic 1 pin widgets to outputs
11491  */
11492 static struct hda_verb alc861_threestack_ch6_init[] = {
11493         /* set pin widget 1Ah (line in) for output (Back Surround)*/
11494         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11495         /* set pin widget 18h (mic1) for output (CLFE)*/
11496         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11497
11498         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
11499         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
11500
11501         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
11502 #if 0
11503         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11504         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
11505 #endif
11506         { } /* end */
11507 };
11508
11509 static struct hda_channel_mode alc861_threestack_modes[2] = {
11510         { 2, alc861_threestack_ch2_init },
11511         { 6, alc861_threestack_ch6_init },
11512 };
11513 /* Set mic1 as input and unmute the mixer */
11514 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
11515         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11516         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11517         { } /* end */
11518 };
11519 /* Set mic1 as output and mute mixer */
11520 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
11521         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11522         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11523         { } /* end */
11524 };
11525
11526 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
11527         { 2, alc861_uniwill_m31_ch2_init },
11528         { 4, alc861_uniwill_m31_ch4_init },
11529 };
11530
11531 /* Set mic1 and line-in as input and unmute the mixer */
11532 static struct hda_verb alc861_asus_ch2_init[] = {
11533         /* set pin widget 1Ah (line in) for input */
11534         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11535         /* set pin widget 18h (mic1/2) for input, for mic also enable
11536          * the vref
11537          */
11538         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11539
11540         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
11541 #if 0
11542         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
11543         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
11544 #endif
11545         { } /* end */
11546 };
11547 /* Set mic1 nad line-in as output and mute mixer */
11548 static struct hda_verb alc861_asus_ch6_init[] = {
11549         /* set pin widget 1Ah (line in) for output (Back Surround)*/
11550         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11551         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
11552         /* set pin widget 18h (mic1) for output (CLFE)*/
11553         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11554         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
11555         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
11556         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
11557
11558         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
11559 #if 0
11560         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
11561         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
11562 #endif
11563         { } /* end */
11564 };
11565
11566 static struct hda_channel_mode alc861_asus_modes[2] = {
11567         { 2, alc861_asus_ch2_init },
11568         { 6, alc861_asus_ch6_init },
11569 };
11570
11571 /* patch-ALC861 */
11572
11573 static struct snd_kcontrol_new alc861_base_mixer[] = {
11574         /* output mixer control */
11575         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11576         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11577         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11578         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11579         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
11580
11581         /*Input mixer control */
11582         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11583            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11584         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11585         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11586         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11587         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11588         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11589         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11590         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11591         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11592
11593         /* Capture mixer control */
11594         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11595         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11596         {
11597                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11598                 .name = "Capture Source",
11599                 .count = 1,
11600                 .info = alc_mux_enum_info,
11601                 .get = alc_mux_enum_get,
11602                 .put = alc_mux_enum_put,
11603         },
11604         { } /* end */
11605 };
11606
11607 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
11608         /* output mixer control */
11609         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11610         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11611         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11612         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11613         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
11614
11615         /* Input mixer control */
11616         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11617            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11618         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11619         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11620         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11621         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11622         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11623         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11624         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11625         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11626
11627         /* Capture mixer control */
11628         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11629         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11630         {
11631                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11632                 .name = "Capture Source",
11633                 .count = 1,
11634                 .info = alc_mux_enum_info,
11635                 .get = alc_mux_enum_get,
11636                 .put = alc_mux_enum_put,
11637         },
11638         {
11639                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11640                 .name = "Channel Mode",
11641                 .info = alc_ch_mode_info,
11642                 .get = alc_ch_mode_get,
11643                 .put = alc_ch_mode_put,
11644                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
11645         },
11646         { } /* end */
11647 };
11648
11649 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
11650         /* output mixer control */
11651         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11652         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11653         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11654
11655         /*Capture mixer control */
11656         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11657         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11658         {
11659                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11660                 .name = "Capture Source",
11661                 .count = 1,
11662                 .info = alc_mux_enum_info,
11663                 .get = alc_mux_enum_get,
11664                 .put = alc_mux_enum_put,
11665         },
11666
11667         { } /* end */
11668 };
11669
11670 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
11671         /* output mixer control */
11672         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11673         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11674         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11675         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11676         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
11677
11678         /* Input mixer control */
11679         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11680            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
11681         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11682         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11683         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11684         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11685         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11686         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11687         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11688         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
11689
11690         /* Capture mixer control */
11691         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11692         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11693         {
11694                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11695                 .name = "Capture Source",
11696                 .count = 1,
11697                 .info = alc_mux_enum_info,
11698                 .get = alc_mux_enum_get,
11699                 .put = alc_mux_enum_put,
11700         },
11701         {
11702                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11703                 .name = "Channel Mode",
11704                 .info = alc_ch_mode_info,
11705                 .get = alc_ch_mode_get,
11706                 .put = alc_ch_mode_put,
11707                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
11708         },
11709         { } /* end */
11710 };
11711
11712 static struct snd_kcontrol_new alc861_asus_mixer[] = {
11713         /* output mixer control */
11714         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
11715         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
11716         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
11717         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
11718         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
11719
11720         /* Input mixer control */
11721         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
11722         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11723         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11724         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11725         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
11726         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
11727         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
11728         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
11729         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
11730         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
11731
11732         /* Capture mixer control */
11733         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11734         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11735         {
11736                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11737                 .name = "Capture Source",
11738                 .count = 1,
11739                 .info = alc_mux_enum_info,
11740                 .get = alc_mux_enum_get,
11741                 .put = alc_mux_enum_put,
11742         },
11743         {
11744                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11745                 .name = "Channel Mode",
11746                 .info = alc_ch_mode_info,
11747                 .get = alc_ch_mode_get,
11748                 .put = alc_ch_mode_put,
11749                 .private_value = ARRAY_SIZE(alc861_asus_modes),
11750         },
11751         { }
11752 };
11753
11754 /* additional mixer */
11755 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
11756         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
11757         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
11758         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
11759         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
11760         { }
11761 };
11762
11763 /*
11764  * generic initialization of ADC, input mixers and output mixers
11765  */
11766 static struct hda_verb alc861_base_init_verbs[] = {
11767         /*
11768          * Unmute ADC0 and set the default input to mic-in
11769          */
11770         /* port-A for surround (rear panel) */
11771         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11772         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
11773         /* port-B for mic-in (rear panel) with vref */
11774         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11775         /* port-C for line-in (rear panel) */
11776         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11777         /* port-D for Front */
11778         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11779         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11780         /* port-E for HP out (front panel) */
11781         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
11782         /* route front PCM to HP */
11783         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11784         /* port-F for mic-in (front panel) with vref */
11785         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11786         /* port-G for CLFE (rear panel) */
11787         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11788         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11789         /* port-H for side (rear panel) */
11790         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11791         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
11792         /* CD-in */
11793         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11794         /* route front mic to ADC1*/
11795         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11796         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11797
11798         /* Unmute DAC0~3 & spdif out*/
11799         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11800         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11801         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11802         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11803         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11804
11805         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11806         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11807         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11808         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11809         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11810
11811         /* Unmute Stereo Mixer 15 */
11812         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11813         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11814         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11815         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11816
11817         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11818         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11819         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11820         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11821         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11822         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11823         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11824         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11825         /* hp used DAC 3 (Front) */
11826         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11827         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11828
11829         { }
11830 };
11831
11832 static struct hda_verb alc861_threestack_init_verbs[] = {
11833         /*
11834          * Unmute ADC0 and set the default input to mic-in
11835          */
11836         /* port-A for surround (rear panel) */
11837         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11838         /* port-B for mic-in (rear panel) with vref */
11839         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11840         /* port-C for line-in (rear panel) */
11841         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11842         /* port-D for Front */
11843         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11844         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11845         /* port-E for HP out (front panel) */
11846         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
11847         /* route front PCM to HP */
11848         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11849         /* port-F for mic-in (front panel) with vref */
11850         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11851         /* port-G for CLFE (rear panel) */
11852         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11853         /* port-H for side (rear panel) */
11854         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11855         /* CD-in */
11856         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11857         /* route front mic to ADC1*/
11858         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11859         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11860         /* Unmute DAC0~3 & spdif out*/
11861         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11862         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11863         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11864         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11865         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11866
11867         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11868         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11869         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11870         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11871         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11872
11873         /* Unmute Stereo Mixer 15 */
11874         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11875         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11876         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11877         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11878
11879         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11880         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11881         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11882         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11883         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11884         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11885         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11886         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11887         /* hp used DAC 3 (Front) */
11888         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11889         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11890         { }
11891 };
11892
11893 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
11894         /*
11895          * Unmute ADC0 and set the default input to mic-in
11896          */
11897         /* port-A for surround (rear panel) */
11898         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11899         /* port-B for mic-in (rear panel) with vref */
11900         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11901         /* port-C for line-in (rear panel) */
11902         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11903         /* port-D for Front */
11904         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11905         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11906         /* port-E for HP out (front panel) */
11907         /* this has to be set to VREF80 */
11908         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11909         /* route front PCM to HP */
11910         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11911         /* port-F for mic-in (front panel) with vref */
11912         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11913         /* port-G for CLFE (rear panel) */
11914         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11915         /* port-H for side (rear panel) */
11916         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11917         /* CD-in */
11918         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11919         /* route front mic to ADC1*/
11920         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11921         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11922         /* Unmute DAC0~3 & spdif out*/
11923         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11924         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11925         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11926         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11927         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11928
11929         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11930         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11931         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11932         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11933         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11934
11935         /* Unmute Stereo Mixer 15 */
11936         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11937         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11938         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11939         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11940
11941         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11942         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11943         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11944         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11945         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11946         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11947         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11948         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11949         /* hp used DAC 3 (Front) */
11950         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11951         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11952         { }
11953 };
11954
11955 static struct hda_verb alc861_asus_init_verbs[] = {
11956         /*
11957          * Unmute ADC0 and set the default input to mic-in
11958          */
11959         /* port-A for surround (rear panel)
11960          * according to codec#0 this is the HP jack
11961          */
11962         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
11963         /* route front PCM to HP */
11964         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
11965         /* port-B for mic-in (rear panel) with vref */
11966         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11967         /* port-C for line-in (rear panel) */
11968         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11969         /* port-D for Front */
11970         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11971         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11972         /* port-E for HP out (front panel) */
11973         /* this has to be set to VREF80 */
11974         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11975         /* route front PCM to HP */
11976         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11977         /* port-F for mic-in (front panel) with vref */
11978         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11979         /* port-G for CLFE (rear panel) */
11980         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11981         /* port-H for side (rear panel) */
11982         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11983         /* CD-in */
11984         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11985         /* route front mic to ADC1*/
11986         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11987         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11988         /* Unmute DAC0~3 & spdif out*/
11989         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11990         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11991         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11992         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11993         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11994         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11995         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11996         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11997         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11998         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11999
12000         /* Unmute Stereo Mixer 15 */
12001         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12002         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12003         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12004         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12005
12006         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12007         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12008         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12009         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12010         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12011         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12012         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12013         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12014         /* hp used DAC 3 (Front) */
12015         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12016         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12017         { }
12018 };
12019
12020 /* additional init verbs for ASUS laptops */
12021 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
12022         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
12023         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
12024         { }
12025 };
12026
12027 /*
12028  * generic initialization of ADC, input mixers and output mixers
12029  */
12030 static struct hda_verb alc861_auto_init_verbs[] = {
12031         /*
12032          * Unmute ADC0 and set the default input to mic-in
12033          */
12034         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
12035         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12036
12037         /* Unmute DAC0~3 & spdif out*/
12038         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12039         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12040         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12041         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12042         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12043
12044         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12045         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12046         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12047         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12048         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12049
12050         /* Unmute Stereo Mixer 15 */
12051         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12052         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12053         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12054         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
12055
12056         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12057         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12058         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12059         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12060         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12061         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12062         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12063         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12064
12065         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12066         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12067         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12068         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12069         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12070         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12071         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12072         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12073
12074         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
12075
12076         { }
12077 };
12078
12079 static struct hda_verb alc861_toshiba_init_verbs[] = {
12080         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12081
12082         { }
12083 };
12084
12085 /* toggle speaker-output according to the hp-jack state */
12086 static void alc861_toshiba_automute(struct hda_codec *codec)
12087 {
12088         unsigned int present;
12089
12090         present = snd_hda_codec_read(codec, 0x0f, 0,
12091                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12092         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
12093                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
12094         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
12095                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
12096 }
12097
12098 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
12099                                        unsigned int res)
12100 {
12101         if ((res >> 26) == ALC880_HP_EVENT)
12102                 alc861_toshiba_automute(codec);
12103 }
12104
12105 /* pcm configuration: identiacal with ALC880 */
12106 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
12107 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
12108 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
12109 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
12110
12111
12112 #define ALC861_DIGOUT_NID       0x07
12113
12114 static struct hda_channel_mode alc861_8ch_modes[1] = {
12115         { 8, NULL }
12116 };
12117
12118 static hda_nid_t alc861_dac_nids[4] = {
12119         /* front, surround, clfe, side */
12120         0x03, 0x06, 0x05, 0x04
12121 };
12122
12123 static hda_nid_t alc660_dac_nids[3] = {
12124         /* front, clfe, surround */
12125         0x03, 0x05, 0x06
12126 };
12127
12128 static hda_nid_t alc861_adc_nids[1] = {
12129         /* ADC0-2 */
12130         0x08,
12131 };
12132
12133 static struct hda_input_mux alc861_capture_source = {
12134         .num_items = 5,
12135         .items = {
12136                 { "Mic", 0x0 },
12137                 { "Front Mic", 0x3 },
12138                 { "Line", 0x1 },
12139                 { "CD", 0x4 },
12140                 { "Mixer", 0x5 },
12141         },
12142 };
12143
12144 /* fill in the dac_nids table from the parsed pin configuration */
12145 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
12146                                      const struct auto_pin_cfg *cfg)
12147 {
12148         int i;
12149         hda_nid_t nid;
12150
12151         spec->multiout.dac_nids = spec->private_dac_nids;
12152         for (i = 0; i < cfg->line_outs; i++) {
12153                 nid = cfg->line_out_pins[i];
12154                 if (nid) {
12155                         if (i >= ARRAY_SIZE(alc861_dac_nids))
12156                                 continue;
12157                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
12158                 }
12159         }
12160         spec->multiout.num_dacs = cfg->line_outs;
12161         return 0;
12162 }
12163
12164 /* add playback controls from the parsed DAC table */
12165 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
12166                                              const struct auto_pin_cfg *cfg)
12167 {
12168         char name[32];
12169         static const char *chname[4] = {
12170                 "Front", "Surround", NULL /*CLFE*/, "Side"
12171         };
12172         hda_nid_t nid;
12173         int i, idx, err;
12174
12175         for (i = 0; i < cfg->line_outs; i++) {
12176                 nid = spec->multiout.dac_nids[i];
12177                 if (!nid)
12178                         continue;
12179                 if (nid == 0x05) {
12180                         /* Center/LFE */
12181                         err = add_control(spec, ALC_CTL_BIND_MUTE,
12182                                           "Center Playback Switch",
12183                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
12184                                                               HDA_OUTPUT));
12185                         if (err < 0)
12186                                 return err;
12187                         err = add_control(spec, ALC_CTL_BIND_MUTE,
12188                                           "LFE Playback Switch",
12189                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12190                                                               HDA_OUTPUT));
12191                         if (err < 0)
12192                                 return err;
12193                 } else {
12194                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
12195                              idx++)
12196                                 if (nid == alc861_dac_nids[idx])
12197                                         break;
12198                         sprintf(name, "%s Playback Switch", chname[idx]);
12199                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
12200                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12201                                                               HDA_OUTPUT));
12202                         if (err < 0)
12203                                 return err;
12204                 }
12205         }
12206         return 0;
12207 }
12208
12209 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
12210 {
12211         int err;
12212         hda_nid_t nid;
12213
12214         if (!pin)
12215                 return 0;
12216
12217         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
12218                 nid = 0x03;
12219                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12220                                   "Headphone Playback Switch",
12221                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12222                 if (err < 0)
12223                         return err;
12224                 spec->multiout.hp_nid = nid;
12225         }
12226         return 0;
12227 }
12228
12229 /* create playback/capture controls for input pins */
12230 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
12231                                                 const struct auto_pin_cfg *cfg)
12232 {
12233         struct hda_input_mux *imux = &spec->private_imux;
12234         int i, err, idx, idx1;
12235
12236         for (i = 0; i < AUTO_PIN_LAST; i++) {
12237                 switch (cfg->input_pins[i]) {
12238                 case 0x0c:
12239                         idx1 = 1;
12240                         idx = 2;        /* Line In */
12241                         break;
12242                 case 0x0f:
12243                         idx1 = 2;
12244                         idx = 2;        /* Line In */
12245                         break;
12246                 case 0x0d:
12247                         idx1 = 0;
12248                         idx = 1;        /* Mic In */
12249                         break;
12250                 case 0x10:
12251                         idx1 = 3;
12252                         idx = 1;        /* Mic In */
12253                         break;
12254                 case 0x11:
12255                         idx1 = 4;
12256                         idx = 0;        /* CD */
12257                         break;
12258                 default:
12259                         continue;
12260                 }
12261
12262                 err = new_analog_input(spec, cfg->input_pins[i],
12263                                        auto_pin_cfg_labels[i], idx, 0x15);
12264                 if (err < 0)
12265                         return err;
12266
12267                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
12268                 imux->items[imux->num_items].index = idx1;
12269                 imux->num_items++;
12270         }
12271         return 0;
12272 }
12273
12274 static struct snd_kcontrol_new alc861_capture_mixer[] = {
12275         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12276         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12277
12278         {
12279                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12280                 /* The multiple "Capture Source" controls confuse alsamixer
12281                  * So call somewhat different..
12282                  */
12283                 /* .name = "Capture Source", */
12284                 .name = "Input Source",
12285                 .count = 1,
12286                 .info = alc_mux_enum_info,
12287                 .get = alc_mux_enum_get,
12288                 .put = alc_mux_enum_put,
12289         },
12290         { } /* end */
12291 };
12292
12293 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
12294                                               hda_nid_t nid,
12295                                               int pin_type, int dac_idx)
12296 {
12297         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
12298                             pin_type);
12299         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12300                             AMP_OUT_UNMUTE);
12301 }
12302
12303 static void alc861_auto_init_multi_out(struct hda_codec *codec)
12304 {
12305         struct alc_spec *spec = codec->spec;
12306         int i;
12307
12308         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
12309         for (i = 0; i < spec->autocfg.line_outs; i++) {
12310                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
12311                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12312                 if (nid)
12313                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
12314                                                           spec->multiout.dac_nids[i]);
12315         }
12316 }
12317
12318 static void alc861_auto_init_hp_out(struct hda_codec *codec)
12319 {
12320         struct alc_spec *spec = codec->spec;
12321         hda_nid_t pin;
12322
12323         pin = spec->autocfg.hp_pins[0];
12324         if (pin) /* connect to front */
12325                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
12326                                                   spec->multiout.dac_nids[0]);
12327         pin = spec->autocfg.speaker_pins[0];
12328         if (pin)
12329                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
12330 }
12331
12332 static void alc861_auto_init_analog_input(struct hda_codec *codec)
12333 {
12334         struct alc_spec *spec = codec->spec;
12335         int i;
12336
12337         for (i = 0; i < AUTO_PIN_LAST; i++) {
12338                 hda_nid_t nid = spec->autocfg.input_pins[i];
12339                 if (nid >= 0x0c && nid <= 0x11) {
12340                         snd_hda_codec_write(codec, nid, 0,
12341                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
12342                                             i <= AUTO_PIN_FRONT_MIC ?
12343                                             PIN_VREF80 : PIN_IN);
12344                 }
12345         }
12346 }
12347
12348 /* parse the BIOS configuration and set up the alc_spec */
12349 /* return 1 if successful, 0 if the proper config is not found,
12350  * or a negative error code
12351  */
12352 static int alc861_parse_auto_config(struct hda_codec *codec)
12353 {
12354         struct alc_spec *spec = codec->spec;
12355         int err;
12356         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
12357
12358         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12359                                            alc861_ignore);
12360         if (err < 0)
12361                 return err;
12362         if (!spec->autocfg.line_outs)
12363                 return 0; /* can't find valid BIOS pin config */
12364
12365         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
12366         if (err < 0)
12367                 return err;
12368         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
12369         if (err < 0)
12370                 return err;
12371         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
12372         if (err < 0)
12373                 return err;
12374         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
12375         if (err < 0)
12376                 return err;
12377
12378         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12379
12380         if (spec->autocfg.dig_out_pin)
12381                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
12382
12383         if (spec->kctl_alloc)
12384                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12385
12386         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
12387
12388         spec->num_mux_defs = 1;
12389         spec->input_mux = &spec->private_imux;
12390
12391         spec->adc_nids = alc861_adc_nids;
12392         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
12393         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
12394         spec->num_mixers++;
12395
12396         return 1;
12397 }
12398
12399 /* additional initialization for auto-configuration model */
12400 static void alc861_auto_init(struct hda_codec *codec)
12401 {
12402         struct alc_spec *spec = codec->spec;
12403         alc861_auto_init_multi_out(codec);
12404         alc861_auto_init_hp_out(codec);
12405         alc861_auto_init_analog_input(codec);
12406         if (spec->unsol_event)
12407                 alc_sku_automute(codec);
12408 }
12409
12410 #ifdef CONFIG_SND_HDA_POWER_SAVE
12411 static struct hda_amp_list alc861_loopbacks[] = {
12412         { 0x15, HDA_INPUT, 0 },
12413         { 0x15, HDA_INPUT, 1 },
12414         { 0x15, HDA_INPUT, 2 },
12415         { 0x15, HDA_INPUT, 3 },
12416         { } /* end */
12417 };
12418 #endif
12419
12420
12421 /*
12422  * configuration and preset
12423  */
12424 static const char *alc861_models[ALC861_MODEL_LAST] = {
12425         [ALC861_3ST]            = "3stack",
12426         [ALC660_3ST]            = "3stack-660",
12427         [ALC861_3ST_DIG]        = "3stack-dig",
12428         [ALC861_6ST_DIG]        = "6stack-dig",
12429         [ALC861_UNIWILL_M31]    = "uniwill-m31",
12430         [ALC861_TOSHIBA]        = "toshiba",
12431         [ALC861_ASUS]           = "asus",
12432         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
12433         [ALC861_AUTO]           = "auto",
12434 };
12435
12436 static struct snd_pci_quirk alc861_cfg_tbl[] = {
12437         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
12438         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
12439         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
12440         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
12441         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
12442         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
12443         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
12444         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
12445          *        Any other models that need this preset?
12446          */
12447         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
12448         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
12449         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
12450         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
12451         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
12452         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
12453         /* FIXME: the below seems conflict */
12454         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
12455         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
12456         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
12457         {}
12458 };
12459
12460 static struct alc_config_preset alc861_presets[] = {
12461         [ALC861_3ST] = {
12462                 .mixers = { alc861_3ST_mixer },
12463                 .init_verbs = { alc861_threestack_init_verbs },
12464                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12465                 .dac_nids = alc861_dac_nids,
12466                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12467                 .channel_mode = alc861_threestack_modes,
12468                 .need_dac_fix = 1,
12469                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12470                 .adc_nids = alc861_adc_nids,
12471                 .input_mux = &alc861_capture_source,
12472         },
12473         [ALC861_3ST_DIG] = {
12474                 .mixers = { alc861_base_mixer },
12475                 .init_verbs = { alc861_threestack_init_verbs },
12476                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12477                 .dac_nids = alc861_dac_nids,
12478                 .dig_out_nid = ALC861_DIGOUT_NID,
12479                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12480                 .channel_mode = alc861_threestack_modes,
12481                 .need_dac_fix = 1,
12482                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12483                 .adc_nids = alc861_adc_nids,
12484                 .input_mux = &alc861_capture_source,
12485         },
12486         [ALC861_6ST_DIG] = {
12487                 .mixers = { alc861_base_mixer },
12488                 .init_verbs = { alc861_base_init_verbs },
12489                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12490                 .dac_nids = alc861_dac_nids,
12491                 .dig_out_nid = ALC861_DIGOUT_NID,
12492                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
12493                 .channel_mode = alc861_8ch_modes,
12494                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12495                 .adc_nids = alc861_adc_nids,
12496                 .input_mux = &alc861_capture_source,
12497         },
12498         [ALC660_3ST] = {
12499                 .mixers = { alc861_3ST_mixer },
12500                 .init_verbs = { alc861_threestack_init_verbs },
12501                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
12502                 .dac_nids = alc660_dac_nids,
12503                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
12504                 .channel_mode = alc861_threestack_modes,
12505                 .need_dac_fix = 1,
12506                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12507                 .adc_nids = alc861_adc_nids,
12508                 .input_mux = &alc861_capture_source,
12509         },
12510         [ALC861_UNIWILL_M31] = {
12511                 .mixers = { alc861_uniwill_m31_mixer },
12512                 .init_verbs = { alc861_uniwill_m31_init_verbs },
12513                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12514                 .dac_nids = alc861_dac_nids,
12515                 .dig_out_nid = ALC861_DIGOUT_NID,
12516                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
12517                 .channel_mode = alc861_uniwill_m31_modes,
12518                 .need_dac_fix = 1,
12519                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12520                 .adc_nids = alc861_adc_nids,
12521                 .input_mux = &alc861_capture_source,
12522         },
12523         [ALC861_TOSHIBA] = {
12524                 .mixers = { alc861_toshiba_mixer },
12525                 .init_verbs = { alc861_base_init_verbs,
12526                                 alc861_toshiba_init_verbs },
12527                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12528                 .dac_nids = alc861_dac_nids,
12529                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
12530                 .channel_mode = alc883_3ST_2ch_modes,
12531                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12532                 .adc_nids = alc861_adc_nids,
12533                 .input_mux = &alc861_capture_source,
12534                 .unsol_event = alc861_toshiba_unsol_event,
12535                 .init_hook = alc861_toshiba_automute,
12536         },
12537         [ALC861_ASUS] = {
12538                 .mixers = { alc861_asus_mixer },
12539                 .init_verbs = { alc861_asus_init_verbs },
12540                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12541                 .dac_nids = alc861_dac_nids,
12542                 .dig_out_nid = ALC861_DIGOUT_NID,
12543                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
12544                 .channel_mode = alc861_asus_modes,
12545                 .need_dac_fix = 1,
12546                 .hp_nid = 0x06,
12547                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12548                 .adc_nids = alc861_adc_nids,
12549                 .input_mux = &alc861_capture_source,
12550         },
12551         [ALC861_ASUS_LAPTOP] = {
12552                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
12553                 .init_verbs = { alc861_asus_init_verbs,
12554                                 alc861_asus_laptop_init_verbs },
12555                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
12556                 .dac_nids = alc861_dac_nids,
12557                 .dig_out_nid = ALC861_DIGOUT_NID,
12558                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
12559                 .channel_mode = alc883_3ST_2ch_modes,
12560                 .need_dac_fix = 1,
12561                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
12562                 .adc_nids = alc861_adc_nids,
12563                 .input_mux = &alc861_capture_source,
12564         },
12565 };
12566
12567
12568 static int patch_alc861(struct hda_codec *codec)
12569 {
12570         struct alc_spec *spec;
12571         int board_config;
12572         int err;
12573
12574         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12575         if (spec == NULL)
12576                 return -ENOMEM;
12577
12578         codec->spec = spec;
12579
12580         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
12581                                                   alc861_models,
12582                                                   alc861_cfg_tbl);
12583
12584         if (board_config < 0) {
12585                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
12586                        "trying auto-probe from BIOS...\n");
12587                 board_config = ALC861_AUTO;
12588         }
12589
12590         if (board_config == ALC861_AUTO) {
12591                 /* automatic parse from the BIOS config */
12592                 err = alc861_parse_auto_config(codec);
12593                 if (err < 0) {
12594                         alc_free(codec);
12595                         return err;
12596                 } else if (!err) {
12597                         printk(KERN_INFO
12598                                "hda_codec: Cannot set up configuration "
12599                                "from BIOS.  Using base mode...\n");
12600                    board_config = ALC861_3ST_DIG;
12601                 }
12602         }
12603
12604         if (board_config != ALC861_AUTO)
12605                 setup_preset(spec, &alc861_presets[board_config]);
12606
12607         spec->stream_name_analog = "ALC861 Analog";
12608         spec->stream_analog_playback = &alc861_pcm_analog_playback;
12609         spec->stream_analog_capture = &alc861_pcm_analog_capture;
12610
12611         spec->stream_name_digital = "ALC861 Digital";
12612         spec->stream_digital_playback = &alc861_pcm_digital_playback;
12613         spec->stream_digital_capture = &alc861_pcm_digital_capture;
12614
12615         spec->vmaster_nid = 0x03;
12616
12617         codec->patch_ops = alc_patch_ops;
12618         if (board_config == ALC861_AUTO)
12619                 spec->init_hook = alc861_auto_init;
12620 #ifdef CONFIG_SND_HDA_POWER_SAVE
12621         if (!spec->loopback.amplist)
12622                 spec->loopback.amplist = alc861_loopbacks;
12623 #endif
12624
12625         return 0;
12626 }
12627
12628 /*
12629  * ALC861-VD support
12630  *
12631  * Based on ALC882
12632  *
12633  * In addition, an independent DAC
12634  */
12635 #define ALC861VD_DIGOUT_NID     0x06
12636
12637 static hda_nid_t alc861vd_dac_nids[4] = {
12638         /* front, surr, clfe, side surr */
12639         0x02, 0x03, 0x04, 0x05
12640 };
12641
12642 /* dac_nids for ALC660vd are in a different order - according to
12643  * Realtek's driver.
12644  * This should probably tesult in a different mixer for 6stack models
12645  * of ALC660vd codecs, but for now there is only 3stack mixer
12646  * - and it is the same as in 861vd.
12647  * adc_nids in ALC660vd are (is) the same as in 861vd
12648  */
12649 static hda_nid_t alc660vd_dac_nids[3] = {
12650         /* front, rear, clfe, rear_surr */
12651         0x02, 0x04, 0x03
12652 };
12653
12654 static hda_nid_t alc861vd_adc_nids[1] = {
12655         /* ADC0 */
12656         0x09,
12657 };
12658
12659 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
12660
12661 /* input MUX */
12662 /* FIXME: should be a matrix-type input source selection */
12663 static struct hda_input_mux alc861vd_capture_source = {
12664         .num_items = 4,
12665         .items = {
12666                 { "Mic", 0x0 },
12667                 { "Front Mic", 0x1 },
12668                 { "Line", 0x2 },
12669                 { "CD", 0x4 },
12670         },
12671 };
12672
12673 static struct hda_input_mux alc861vd_dallas_capture_source = {
12674         .num_items = 2,
12675         .items = {
12676                 { "Ext Mic", 0x0 },
12677                 { "Int Mic", 0x1 },
12678         },
12679 };
12680
12681 static struct hda_input_mux alc861vd_hp_capture_source = {
12682         .num_items = 2,
12683         .items = {
12684                 { "Front Mic", 0x0 },
12685                 { "ATAPI Mic", 0x1 },
12686         },
12687 };
12688
12689 #define alc861vd_mux_enum_info alc_mux_enum_info
12690 #define alc861vd_mux_enum_get alc_mux_enum_get
12691 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
12692 #define alc861vd_mux_enum_put alc882_mux_enum_put
12693
12694 /*
12695  * 2ch mode
12696  */
12697 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
12698         { 2, NULL }
12699 };
12700
12701 /*
12702  * 6ch mode
12703  */
12704 static struct hda_verb alc861vd_6stack_ch6_init[] = {
12705         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12706         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12707         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12708         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12709         { } /* end */
12710 };
12711
12712 /*
12713  * 8ch mode
12714  */
12715 static struct hda_verb alc861vd_6stack_ch8_init[] = {
12716         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12717         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12718         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12719         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12720         { } /* end */
12721 };
12722
12723 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
12724         { 6, alc861vd_6stack_ch6_init },
12725         { 8, alc861vd_6stack_ch8_init },
12726 };
12727
12728 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
12729         {
12730                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12731                 .name = "Channel Mode",
12732                 .info = alc_ch_mode_info,
12733                 .get = alc_ch_mode_get,
12734                 .put = alc_ch_mode_put,
12735         },
12736         { } /* end */
12737 };
12738
12739 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
12740         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
12741         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
12742
12743         {
12744                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12745                 /* The multiple "Capture Source" controls confuse alsamixer
12746                  * So call somewhat different..
12747                  */
12748                 /* .name = "Capture Source", */
12749                 .name = "Input Source",
12750                 .count = 1,
12751                 .info = alc861vd_mux_enum_info,
12752                 .get = alc861vd_mux_enum_get,
12753                 .put = alc861vd_mux_enum_put,
12754         },
12755         { } /* end */
12756 };
12757
12758 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
12759  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
12760  */
12761 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
12762         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12763         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12764
12765         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12766         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
12767
12768         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
12769                                 HDA_OUTPUT),
12770         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
12771                                 HDA_OUTPUT),
12772         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12773         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
12774
12775         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
12776         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
12777
12778         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12779
12780         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12781         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12782         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12783
12784         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12785         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12786         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12787
12788         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12789         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12790
12791         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12792         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12793
12794         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12795         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12796
12797         { } /* end */
12798 };
12799
12800 static struct snd_kcontrol_new alc861vd_3st_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_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12805
12806         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12807         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12808         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12809
12810         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12811         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12812         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12813
12814         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12815         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12816
12817         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12818         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12819
12820         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12821         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12822
12823         { } /* end */
12824 };
12825
12826 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
12827         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12828         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
12829         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12830
12831         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12832
12833         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12834         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12835         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12836
12837         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12838         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12839         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12840
12841         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12842         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12843
12844         { } /* end */
12845 };
12846
12847 /* Pin assignment: Speaker=0x14, HP = 0x15,
12848  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
12849  */
12850 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
12851         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12852         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
12853         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12854         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12855         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12856         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12857         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12858         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12859         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12860         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12861         HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
12862         HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
12863         { } /* end */
12864 };
12865
12866 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
12867  *                 Front Mic=0x18, ATAPI Mic = 0x19,
12868  */
12869 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
12870         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12871         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12872         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12873         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12874         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12875         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12876         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12877         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12878
12879         { } /* end */
12880 };
12881
12882 /*
12883  * generic initialization of ADC, input mixers and output mixers
12884  */
12885 static struct hda_verb alc861vd_volume_init_verbs[] = {
12886         /*
12887          * Unmute ADC0 and set the default input to mic-in
12888          */
12889         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12890         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12891
12892         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
12893          * the analog-loopback mixer widget
12894          */
12895         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12896         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12897         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12898         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12899         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12900         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12901
12902         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
12903         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12904         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12905         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12906         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
12907
12908         /*
12909          * Set up output mixers (0x02 - 0x05)
12910          */
12911         /* set vol=0 to output mixers */
12912         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12913         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12914         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12915         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12916
12917         /* set up input amps for analog loopback */
12918         /* Amp Indices: DAC = 0, mixer = 1 */
12919         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12920         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12921         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12922         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12923         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12924         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12925         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12926         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12927
12928         { }
12929 };
12930
12931 /*
12932  * 3-stack pin configuration:
12933  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
12934  */
12935 static struct hda_verb alc861vd_3stack_init_verbs[] = {
12936         /*
12937          * Set pin mode and muting
12938          */
12939         /* set front pin widgets 0x14 for output */
12940         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12941         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12942         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12943
12944         /* Mic (rear) pin: input vref at 80% */
12945         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12946         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12947         /* Front Mic pin: input vref at 80% */
12948         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12949         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12950         /* Line In pin: input */
12951         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12952         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12953         /* Line-2 In: Headphone output (output 0 - 0x0c) */
12954         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12955         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12956         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12957         /* CD pin widget for input */
12958         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12959
12960         { }
12961 };
12962
12963 /*
12964  * 6-stack pin configuration:
12965  */
12966 static struct hda_verb alc861vd_6stack_init_verbs[] = {
12967         /*
12968          * Set pin mode and muting
12969          */
12970         /* set front pin widgets 0x14 for output */
12971         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12972         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12973         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12974
12975         /* Rear Pin: output 1 (0x0d) */
12976         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12977         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12978         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12979         /* CLFE Pin: output 2 (0x0e) */
12980         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12981         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12982         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
12983         /* Side Pin: output 3 (0x0f) */
12984         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12985         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12986         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
12987
12988         /* Mic (rear) pin: input vref at 80% */
12989         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12990         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12991         /* Front Mic pin: input vref at 80% */
12992         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12993         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12994         /* Line In pin: input */
12995         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12996         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12997         /* Line-2 In: Headphone output (output 0 - 0x0c) */
12998         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12999         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13000         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13001         /* CD pin widget for input */
13002         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13003
13004         { }
13005 };
13006
13007 static struct hda_verb alc861vd_eapd_verbs[] = {
13008         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13009         { }
13010 };
13011
13012 static struct hda_verb alc660vd_eapd_verbs[] = {
13013         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13014         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13015         { }
13016 };
13017
13018 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
13019         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13020         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13021         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
13022         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13023         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13024         {}
13025 };
13026
13027 /* toggle speaker-output according to the hp-jack state */
13028 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
13029 {
13030         unsigned int present;
13031         unsigned char bits;
13032
13033         present = snd_hda_codec_read(codec, 0x1b, 0,
13034                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13035         bits = present ? HDA_AMP_MUTE : 0;
13036         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13037                                  HDA_AMP_MUTE, bits);
13038 }
13039
13040 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
13041 {
13042         unsigned int present;
13043         unsigned char bits;
13044
13045         present = snd_hda_codec_read(codec, 0x18, 0,
13046                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13047         bits = present ? HDA_AMP_MUTE : 0;
13048         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
13049                                  HDA_AMP_MUTE, bits);
13050 }
13051
13052 static void alc861vd_lenovo_automute(struct hda_codec *codec)
13053 {
13054         alc861vd_lenovo_hp_automute(codec);
13055         alc861vd_lenovo_mic_automute(codec);
13056 }
13057
13058 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
13059                                         unsigned int res)
13060 {
13061         switch (res >> 26) {
13062         case ALC880_HP_EVENT:
13063                 alc861vd_lenovo_hp_automute(codec);
13064                 break;
13065         case ALC880_MIC_EVENT:
13066                 alc861vd_lenovo_mic_automute(codec);
13067                 break;
13068         }
13069 }
13070
13071 static struct hda_verb alc861vd_dallas_verbs[] = {
13072         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13073         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13074         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13075         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13076
13077         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13078         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13079         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13080         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13081         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13082         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13083         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13084         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13085
13086         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13087         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13088         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13089         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13090         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13091         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13092         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13093         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13094
13095         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
13096         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13097         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
13098         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13099         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13100         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13101         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13102         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13103
13104         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13105         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13106         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13107         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13108
13109         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13110         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13111         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13112
13113         { } /* end */
13114 };
13115
13116 /* toggle speaker-output according to the hp-jack state */
13117 static void alc861vd_dallas_automute(struct hda_codec *codec)
13118 {
13119         unsigned int present;
13120
13121         present = snd_hda_codec_read(codec, 0x15, 0,
13122                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13123         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13124                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13125 }
13126
13127 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
13128 {
13129         if ((res >> 26) == ALC880_HP_EVENT)
13130                 alc861vd_dallas_automute(codec);
13131 }
13132
13133 #ifdef CONFIG_SND_HDA_POWER_SAVE
13134 #define alc861vd_loopbacks      alc880_loopbacks
13135 #endif
13136
13137 /* pcm configuration: identiacal with ALC880 */
13138 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
13139 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
13140 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
13141 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
13142
13143 /*
13144  * configuration and preset
13145  */
13146 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
13147         [ALC660VD_3ST]          = "3stack-660",
13148         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
13149         [ALC861VD_3ST]          = "3stack",
13150         [ALC861VD_3ST_DIG]      = "3stack-digout",
13151         [ALC861VD_6ST_DIG]      = "6stack-digout",
13152         [ALC861VD_LENOVO]       = "lenovo",
13153         [ALC861VD_DALLAS]       = "dallas",
13154         [ALC861VD_HP]           = "hp",
13155         [ALC861VD_AUTO]         = "auto",
13156 };
13157
13158 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
13159         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
13160         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
13161         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
13162         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
13163         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
13164         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
13165         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
13166         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
13167         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
13168         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
13169         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
13170         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
13171         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
13172         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
13173         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
13174         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
13175         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
13176         {}
13177 };
13178
13179 static struct alc_config_preset alc861vd_presets[] = {
13180         [ALC660VD_3ST] = {
13181                 .mixers = { alc861vd_3st_mixer },
13182                 .init_verbs = { alc861vd_volume_init_verbs,
13183                                  alc861vd_3stack_init_verbs },
13184                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13185                 .dac_nids = alc660vd_dac_nids,
13186                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13187                 .channel_mode = alc861vd_3stack_2ch_modes,
13188                 .input_mux = &alc861vd_capture_source,
13189         },
13190         [ALC660VD_3ST_DIG] = {
13191                 .mixers = { alc861vd_3st_mixer },
13192                 .init_verbs = { alc861vd_volume_init_verbs,
13193                                  alc861vd_3stack_init_verbs },
13194                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13195                 .dac_nids = alc660vd_dac_nids,
13196                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13197                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13198                 .channel_mode = alc861vd_3stack_2ch_modes,
13199                 .input_mux = &alc861vd_capture_source,
13200         },
13201         [ALC861VD_3ST] = {
13202                 .mixers = { alc861vd_3st_mixer },
13203                 .init_verbs = { alc861vd_volume_init_verbs,
13204                                  alc861vd_3stack_init_verbs },
13205                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13206                 .dac_nids = alc861vd_dac_nids,
13207                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13208                 .channel_mode = alc861vd_3stack_2ch_modes,
13209                 .input_mux = &alc861vd_capture_source,
13210         },
13211         [ALC861VD_3ST_DIG] = {
13212                 .mixers = { alc861vd_3st_mixer },
13213                 .init_verbs = { alc861vd_volume_init_verbs,
13214                                  alc861vd_3stack_init_verbs },
13215                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13216                 .dac_nids = alc861vd_dac_nids,
13217                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13218                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13219                 .channel_mode = alc861vd_3stack_2ch_modes,
13220                 .input_mux = &alc861vd_capture_source,
13221         },
13222         [ALC861VD_6ST_DIG] = {
13223                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
13224                 .init_verbs = { alc861vd_volume_init_verbs,
13225                                 alc861vd_6stack_init_verbs },
13226                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13227                 .dac_nids = alc861vd_dac_nids,
13228                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13229                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
13230                 .channel_mode = alc861vd_6stack_modes,
13231                 .input_mux = &alc861vd_capture_source,
13232         },
13233         [ALC861VD_LENOVO] = {
13234                 .mixers = { alc861vd_lenovo_mixer },
13235                 .init_verbs = { alc861vd_volume_init_verbs,
13236                                 alc861vd_3stack_init_verbs,
13237                                 alc861vd_eapd_verbs,
13238                                 alc861vd_lenovo_unsol_verbs },
13239                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
13240                 .dac_nids = alc660vd_dac_nids,
13241                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13242                 .channel_mode = alc861vd_3stack_2ch_modes,
13243                 .input_mux = &alc861vd_capture_source,
13244                 .unsol_event = alc861vd_lenovo_unsol_event,
13245                 .init_hook = alc861vd_lenovo_automute,
13246         },
13247         [ALC861VD_DALLAS] = {
13248                 .mixers = { alc861vd_dallas_mixer },
13249                 .init_verbs = { alc861vd_dallas_verbs },
13250                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13251                 .dac_nids = alc861vd_dac_nids,
13252                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13253                 .channel_mode = alc861vd_3stack_2ch_modes,
13254                 .input_mux = &alc861vd_dallas_capture_source,
13255                 .unsol_event = alc861vd_dallas_unsol_event,
13256                 .init_hook = alc861vd_dallas_automute,
13257         },
13258         [ALC861VD_HP] = {
13259                 .mixers = { alc861vd_hp_mixer },
13260                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
13261                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
13262                 .dac_nids = alc861vd_dac_nids,
13263                 .dig_out_nid = ALC861VD_DIGOUT_NID,
13264                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
13265                 .channel_mode = alc861vd_3stack_2ch_modes,
13266                 .input_mux = &alc861vd_hp_capture_source,
13267                 .unsol_event = alc861vd_dallas_unsol_event,
13268                 .init_hook = alc861vd_dallas_automute,
13269         },
13270 };
13271
13272 /*
13273  * BIOS auto configuration
13274  */
13275 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
13276                                 hda_nid_t nid, int pin_type, int dac_idx)
13277 {
13278         alc_set_pin_output(codec, nid, pin_type);
13279 }
13280
13281 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
13282 {
13283         struct alc_spec *spec = codec->spec;
13284         int i;
13285
13286         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
13287         for (i = 0; i <= HDA_SIDE; i++) {
13288                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13289                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13290                 if (nid)
13291                         alc861vd_auto_set_output_and_unmute(codec, nid,
13292                                                             pin_type, i);
13293         }
13294 }
13295
13296
13297 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
13298 {
13299         struct alc_spec *spec = codec->spec;
13300         hda_nid_t pin;
13301
13302         pin = spec->autocfg.hp_pins[0];
13303         if (pin) /* connect to front and  use dac 0 */
13304                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
13305         pin = spec->autocfg.speaker_pins[0];
13306         if (pin)
13307                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13308 }
13309
13310 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
13311 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
13312
13313 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
13314 {
13315         struct alc_spec *spec = codec->spec;
13316         int i;
13317
13318         for (i = 0; i < AUTO_PIN_LAST; i++) {
13319                 hda_nid_t nid = spec->autocfg.input_pins[i];
13320                 if (alc861vd_is_input_pin(nid)) {
13321                         snd_hda_codec_write(codec, nid, 0,
13322                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
13323                                         i <= AUTO_PIN_FRONT_MIC ?
13324                                                         PIN_VREF80 : PIN_IN);
13325                         if (nid != ALC861VD_PIN_CD_NID)
13326                                 snd_hda_codec_write(codec, nid, 0,
13327                                                 AC_VERB_SET_AMP_GAIN_MUTE,
13328                                                 AMP_OUT_MUTE);
13329                 }
13330         }
13331 }
13332
13333 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
13334 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
13335
13336 /* add playback controls from the parsed DAC table */
13337 /* Based on ALC880 version. But ALC861VD has separate,
13338  * different NIDs for mute/unmute switch and volume control */
13339 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
13340                                              const struct auto_pin_cfg *cfg)
13341 {
13342         char name[32];
13343         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
13344         hda_nid_t nid_v, nid_s;
13345         int i, err;
13346
13347         for (i = 0; i < cfg->line_outs; i++) {
13348                 if (!spec->multiout.dac_nids[i])
13349                         continue;
13350                 nid_v = alc861vd_idx_to_mixer_vol(
13351                                 alc880_dac_to_idx(
13352                                         spec->multiout.dac_nids[i]));
13353                 nid_s = alc861vd_idx_to_mixer_switch(
13354                                 alc880_dac_to_idx(
13355                                         spec->multiout.dac_nids[i]));
13356
13357                 if (i == 2) {
13358                         /* Center/LFE */
13359                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13360                                           "Center Playback Volume",
13361                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
13362                                                               HDA_OUTPUT));
13363                         if (err < 0)
13364                                 return err;
13365                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13366                                           "LFE Playback Volume",
13367                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
13368                                                               HDA_OUTPUT));
13369                         if (err < 0)
13370                                 return err;
13371                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13372                                           "Center Playback Switch",
13373                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
13374                                                               HDA_INPUT));
13375                         if (err < 0)
13376                                 return err;
13377                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13378                                           "LFE Playback Switch",
13379                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
13380                                                               HDA_INPUT));
13381                         if (err < 0)
13382                                 return err;
13383                 } else {
13384                         sprintf(name, "%s Playback Volume", chname[i]);
13385                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13386                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
13387                                                               HDA_OUTPUT));
13388                         if (err < 0)
13389                                 return err;
13390                         sprintf(name, "%s Playback Switch", chname[i]);
13391                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13392                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
13393                                                               HDA_INPUT));
13394                         if (err < 0)
13395                                 return err;
13396                 }
13397         }
13398         return 0;
13399 }
13400
13401 /* add playback controls for speaker and HP outputs */
13402 /* Based on ALC880 version. But ALC861VD has separate,
13403  * different NIDs for mute/unmute switch and volume control */
13404 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
13405                                         hda_nid_t pin, const char *pfx)
13406 {
13407         hda_nid_t nid_v, nid_s;
13408         int err;
13409         char name[32];
13410
13411         if (!pin)
13412                 return 0;
13413
13414         if (alc880_is_fixed_pin(pin)) {
13415                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
13416                 /* specify the DAC as the extra output */
13417                 if (!spec->multiout.hp_nid)
13418                         spec->multiout.hp_nid = nid_v;
13419                 else
13420                         spec->multiout.extra_out_nid[0] = nid_v;
13421                 /* control HP volume/switch on the output mixer amp */
13422                 nid_v = alc861vd_idx_to_mixer_vol(
13423                                 alc880_fixed_pin_idx(pin));
13424                 nid_s = alc861vd_idx_to_mixer_switch(
13425                                 alc880_fixed_pin_idx(pin));
13426
13427                 sprintf(name, "%s Playback Volume", pfx);
13428                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13429                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
13430                 if (err < 0)
13431                         return err;
13432                 sprintf(name, "%s Playback Switch", pfx);
13433                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13434                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
13435                 if (err < 0)
13436                         return err;
13437         } else if (alc880_is_multi_pin(pin)) {
13438                 /* set manual connection */
13439                 /* we have only a switch on HP-out PIN */
13440                 sprintf(name, "%s Playback Switch", pfx);
13441                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
13442                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
13443                 if (err < 0)
13444                         return err;
13445         }
13446         return 0;
13447 }
13448
13449 /* parse the BIOS configuration and set up the alc_spec
13450  * return 1 if successful, 0 if the proper config is not found,
13451  * or a negative error code
13452  * Based on ALC880 version - had to change it to override
13453  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
13454 static int alc861vd_parse_auto_config(struct hda_codec *codec)
13455 {
13456         struct alc_spec *spec = codec->spec;
13457         int err;
13458         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
13459
13460         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13461                                            alc861vd_ignore);
13462         if (err < 0)
13463                 return err;
13464         if (!spec->autocfg.line_outs)
13465                 return 0; /* can't find valid BIOS pin config */
13466
13467         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
13468         if (err < 0)
13469                 return err;
13470         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
13471         if (err < 0)
13472                 return err;
13473         err = alc861vd_auto_create_extra_out(spec,
13474                                              spec->autocfg.speaker_pins[0],
13475                                              "Speaker");
13476         if (err < 0)
13477                 return err;
13478         err = alc861vd_auto_create_extra_out(spec,
13479                                              spec->autocfg.hp_pins[0],
13480                                              "Headphone");
13481         if (err < 0)
13482                 return err;
13483         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
13484         if (err < 0)
13485                 return err;
13486
13487         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13488
13489         if (spec->autocfg.dig_out_pin)
13490                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
13491
13492         if (spec->kctl_alloc)
13493                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13494
13495         spec->init_verbs[spec->num_init_verbs++]
13496                 = alc861vd_volume_init_verbs;
13497
13498         spec->num_mux_defs = 1;
13499         spec->input_mux = &spec->private_imux;
13500
13501         err = alc_auto_add_mic_boost(codec);
13502         if (err < 0)
13503                 return err;
13504
13505         return 1;
13506 }
13507
13508 /* additional initialization for auto-configuration model */
13509 static void alc861vd_auto_init(struct hda_codec *codec)
13510 {
13511         struct alc_spec *spec = codec->spec;
13512         alc861vd_auto_init_multi_out(codec);
13513         alc861vd_auto_init_hp_out(codec);
13514         alc861vd_auto_init_analog_input(codec);
13515         if (spec->unsol_event)
13516                 alc_sku_automute(codec);
13517 }
13518
13519 static int patch_alc861vd(struct hda_codec *codec)
13520 {
13521         struct alc_spec *spec;
13522         int err, board_config;
13523
13524         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13525         if (spec == NULL)
13526                 return -ENOMEM;
13527
13528         codec->spec = spec;
13529
13530         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
13531                                                   alc861vd_models,
13532                                                   alc861vd_cfg_tbl);
13533
13534         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
13535                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
13536                         "ALC861VD, trying auto-probe from BIOS...\n");
13537                 board_config = ALC861VD_AUTO;
13538         }
13539
13540         if (board_config == ALC861VD_AUTO) {
13541                 /* automatic parse from the BIOS config */
13542                 err = alc861vd_parse_auto_config(codec);
13543                 if (err < 0) {
13544                         alc_free(codec);
13545                         return err;
13546                 } else if (!err) {
13547                         printk(KERN_INFO
13548                                "hda_codec: Cannot set up configuration "
13549                                "from BIOS.  Using base mode...\n");
13550                         board_config = ALC861VD_3ST;
13551                 }
13552         }
13553
13554         if (board_config != ALC861VD_AUTO)
13555                 setup_preset(spec, &alc861vd_presets[board_config]);
13556
13557         if (codec->vendor_id == 0x10ec0660) {
13558                 spec->stream_name_analog = "ALC660-VD Analog";
13559                 spec->stream_name_digital = "ALC660-VD Digital";
13560                 /* always turn on EAPD */
13561                 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
13562         } else {
13563                 spec->stream_name_analog = "ALC861VD Analog";
13564                 spec->stream_name_digital = "ALC861VD Digital";
13565         }
13566
13567         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
13568         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
13569
13570         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
13571         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
13572
13573         spec->adc_nids = alc861vd_adc_nids;
13574         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
13575         spec->capsrc_nids = alc861vd_capsrc_nids;
13576
13577         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
13578         spec->num_mixers++;
13579
13580         spec->vmaster_nid = 0x02;
13581
13582         codec->patch_ops = alc_patch_ops;
13583
13584         if (board_config == ALC861VD_AUTO)
13585                 spec->init_hook = alc861vd_auto_init;
13586 #ifdef CONFIG_SND_HDA_POWER_SAVE
13587         if (!spec->loopback.amplist)
13588                 spec->loopback.amplist = alc861vd_loopbacks;
13589 #endif
13590
13591         return 0;
13592 }
13593
13594 /*
13595  * ALC662 support
13596  *
13597  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
13598  * configuration.  Each pin widget can choose any input DACs and a mixer.
13599  * Each ADC is connected from a mixer of all inputs.  This makes possible
13600  * 6-channel independent captures.
13601  *
13602  * In addition, an independent DAC for the multi-playback (not used in this
13603  * driver yet).
13604  */
13605 #define ALC662_DIGOUT_NID       0x06
13606 #define ALC662_DIGIN_NID        0x0a
13607
13608 static hda_nid_t alc662_dac_nids[4] = {
13609         /* front, rear, clfe, rear_surr */
13610         0x02, 0x03, 0x04
13611 };
13612
13613 static hda_nid_t alc662_adc_nids[1] = {
13614         /* ADC1-2 */
13615         0x09,
13616 };
13617
13618 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
13619
13620 /* input MUX */
13621 /* FIXME: should be a matrix-type input source selection */
13622 static struct hda_input_mux alc662_capture_source = {
13623         .num_items = 4,
13624         .items = {
13625                 { "Mic", 0x0 },
13626                 { "Front Mic", 0x1 },
13627                 { "Line", 0x2 },
13628                 { "CD", 0x4 },
13629         },
13630 };
13631
13632 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
13633         .num_items = 2,
13634         .items = {
13635                 { "Mic", 0x1 },
13636                 { "Line", 0x2 },
13637         },
13638 };
13639
13640 static struct hda_input_mux alc662_eeepc_capture_source = {
13641         .num_items = 2,
13642         .items = {
13643                 { "i-Mic", 0x1 },
13644                 { "e-Mic", 0x0 },
13645         },
13646 };
13647
13648 static struct hda_input_mux alc663_capture_source = {
13649         .num_items = 3,
13650         .items = {
13651                 { "Mic", 0x0 },
13652                 { "Front Mic", 0x1 },
13653                 { "Line", 0x2 },
13654         },
13655 };
13656
13657 static struct hda_input_mux alc663_m51va_capture_source = {
13658         .num_items = 2,
13659         .items = {
13660                 { "Ext-Mic", 0x0 },
13661                 { "D-Mic", 0x9 },
13662         },
13663 };
13664
13665 #define alc662_mux_enum_info alc_mux_enum_info
13666 #define alc662_mux_enum_get alc_mux_enum_get
13667 #define alc662_mux_enum_put alc882_mux_enum_put
13668
13669 /*
13670  * 2ch mode
13671  */
13672 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
13673         { 2, NULL }
13674 };
13675
13676 /*
13677  * 2ch mode
13678  */
13679 static struct hda_verb alc662_3ST_ch2_init[] = {
13680         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
13681         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
13682         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
13683         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
13684         { } /* end */
13685 };
13686
13687 /*
13688  * 6ch mode
13689  */
13690 static struct hda_verb alc662_3ST_ch6_init[] = {
13691         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13692         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
13693         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
13694         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13695         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
13696         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
13697         { } /* end */
13698 };
13699
13700 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
13701         { 2, alc662_3ST_ch2_init },
13702         { 6, alc662_3ST_ch6_init },
13703 };
13704
13705 /*
13706  * 2ch mode
13707  */
13708 static struct hda_verb alc662_sixstack_ch6_init[] = {
13709         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13710         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13711         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13712         { } /* end */
13713 };
13714
13715 /*
13716  * 6ch mode
13717  */
13718 static struct hda_verb alc662_sixstack_ch8_init[] = {
13719         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13720         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13721         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13722         { } /* end */
13723 };
13724
13725 static struct hda_channel_mode alc662_5stack_modes[2] = {
13726         { 2, alc662_sixstack_ch6_init },
13727         { 6, alc662_sixstack_ch8_init },
13728 };
13729
13730 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13731  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13732  */
13733
13734 static struct snd_kcontrol_new alc662_base_mixer[] = {
13735         /* output mixer control */
13736         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13737         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13738         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13739         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
13740         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13741         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13742         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
13743         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
13744         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13745
13746         /*Input mixer control */
13747         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
13748         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
13749         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
13750         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
13751         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
13752         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
13753         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
13754         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
13755         { } /* end */
13756 };
13757
13758 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
13759         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13760         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13761         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13762         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13763         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13764         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13765         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13766         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13767         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13768         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13769         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13770         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13771         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13772         { } /* end */
13773 };
13774
13775 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
13776         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13777         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
13778         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13779         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
13780         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13781         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13782         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
13783         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
13784         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13785         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13786         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13787         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13788         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13789         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13790         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13791         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13792         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13793         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13794         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13795         { } /* end */
13796 };
13797
13798 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
13799         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13800         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
13801         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13802         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
13803         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13804         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13805         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13806         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13807         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13808         { } /* end */
13809 };
13810
13811 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
13812         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13813
13814         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13815         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13816
13817         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
13818         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13819         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13820
13821         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
13822         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13823         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13824         { } /* end */
13825 };
13826
13827 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
13828         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13829         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13830         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13831         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
13832         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
13833         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
13834         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
13835         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
13836         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13837         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
13838         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13839         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13840         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13841         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13842         { } /* end */
13843 };
13844
13845 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
13846         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13847         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13848         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13849         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13850         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13851         HDA_CODEC_MUTE("DMic Playback Switch", 0x23, 0x9, HDA_INPUT),
13852         { } /* end */
13853 };
13854
13855 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
13856         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13857         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13858         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13859         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13860         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13861
13862         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13863         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, 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 alc663_g50v_mixer[] = {
13870         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13871         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13872         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13873
13874         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13875         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13876         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13877         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13878         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13879         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13880         { } /* end */
13881 };
13882
13883 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
13884         {
13885                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13886                 .name = "Channel Mode",
13887                 .info = alc_ch_mode_info,
13888                 .get = alc_ch_mode_get,
13889                 .put = alc_ch_mode_put,
13890         },
13891         { } /* end */
13892 };
13893
13894 static struct hda_verb alc662_init_verbs[] = {
13895         /* ADC: mute amp left and right */
13896         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13897         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13898         /* Front mixer: unmute input/output amp left and right (volume = 0) */
13899
13900         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13901         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13902         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13903         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13904         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13905
13906         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13907         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13908         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13909         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13910         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13911         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13912
13913         /* Front Pin: output 0 (0x0c) */
13914         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13915         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13916
13917         /* Rear Pin: output 1 (0x0d) */
13918         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13919         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13920
13921         /* CLFE Pin: output 2 (0x0e) */
13922         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13923         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13924
13925         /* Mic (rear) pin: input vref at 80% */
13926         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13927         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13928         /* Front Mic pin: input vref at 80% */
13929         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13930         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13931         /* Line In pin: input */
13932         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13933         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13934         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13935         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13936         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13937         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13938         /* CD pin widget for input */
13939         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13940
13941         /* FIXME: use matrix-type input source selection */
13942         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
13943         /* Input mixer */
13944         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13945         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13946         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13947         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13948
13949         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13950         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13951         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13952         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13953
13954         /* always trun on EAPD */
13955         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13956         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13957
13958         { }
13959 };
13960
13961 static struct hda_verb alc662_sue_init_verbs[] = {
13962         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
13963         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
13964         {}
13965 };
13966
13967 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
13968         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13969         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13970         {}
13971 };
13972
13973 /* Set Unsolicited Event*/
13974 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
13975         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13976         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13977         {}
13978 };
13979
13980 /*
13981  * generic initialization of ADC, input mixers and output mixers
13982  */
13983 static struct hda_verb alc662_auto_init_verbs[] = {
13984         /*
13985          * Unmute ADC and set the default input to mic-in
13986          */
13987         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13988         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13989
13990         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
13991          * mixer widget
13992          * Note: PASD motherboards uses the Line In 2 as the input for front
13993          * panel mic (mic 2)
13994          */
13995         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13996         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13997         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13998         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13999         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14000         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14001
14002         /*
14003          * Set up output mixers (0x0c - 0x0f)
14004          */
14005         /* set vol=0 to output mixers */
14006         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14007         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14008         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14009
14010         /* set up input amps for analog loopback */
14011         /* Amp Indices: DAC = 0, mixer = 1 */
14012         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14013         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14014         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14015         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14016         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14017         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14018
14019
14020         /* FIXME: use matrix-type input source selection */
14021         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
14022         /* Input mixer */
14023         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14024         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14025         { }
14026 };
14027
14028 static struct hda_verb alc663_m51va_init_verbs[] = {
14029         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14030         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14031         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
14032
14033         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
14034
14035         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14036         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14037         {}
14038 };
14039
14040 static struct hda_verb alc663_g71v_init_verbs[] = {
14041         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14042         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
14043         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
14044
14045         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14046         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14047         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
14048
14049         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
14050         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
14051         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
14052         {}
14053 };
14054
14055 static struct hda_verb alc663_g50v_init_verbs[] = {
14056         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14057         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14058         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
14059
14060         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14061         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14062         {}
14063 };
14064
14065 /* capture mixer elements */
14066 static struct snd_kcontrol_new alc662_capture_mixer[] = {
14067         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14068         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14069         {
14070                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14071                 /* The multiple "Capture Source" controls confuse alsamixer
14072                  * So call somewhat different..
14073                  */
14074                 /* .name = "Capture Source", */
14075                 .name = "Input Source",
14076                 .count = 1,
14077                 .info = alc662_mux_enum_info,
14078                 .get = alc662_mux_enum_get,
14079                 .put = alc662_mux_enum_put,
14080         },
14081         { } /* end */
14082 };
14083
14084 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
14085 {
14086         unsigned int present;
14087         unsigned char bits;
14088
14089         present = snd_hda_codec_read(codec, 0x14, 0,
14090                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14091         bits = present ? HDA_AMP_MUTE : 0;
14092         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14093                                  HDA_AMP_MUTE, bits);
14094 }
14095
14096 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
14097 {
14098         unsigned int present;
14099         unsigned char bits;
14100
14101         present = snd_hda_codec_read(codec, 0x1b, 0,
14102                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14103         bits = present ? HDA_AMP_MUTE : 0;
14104         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14105                                  HDA_AMP_MUTE, bits);
14106         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14107                                  HDA_AMP_MUTE, bits);
14108 }
14109
14110 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
14111                                            unsigned int res)
14112 {
14113         if ((res >> 26) == ALC880_HP_EVENT)
14114                 alc662_lenovo_101e_all_automute(codec);
14115         if ((res >> 26) == ALC880_FRONT_EVENT)
14116                 alc662_lenovo_101e_ispeaker_automute(codec);
14117 }
14118
14119 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
14120 {
14121         unsigned int present;
14122
14123         present = snd_hda_codec_read(codec, 0x18, 0,
14124                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14125         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14126                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14127         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14128                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14129         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14130                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
14131         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14132                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
14133 }
14134
14135 /* unsolicited event for HP jack sensing */
14136 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
14137                                      unsigned int res)
14138 {
14139         if ((res >> 26) == ALC880_HP_EVENT)
14140                 alc262_hippo1_automute( codec );
14141
14142         if ((res >> 26) == ALC880_MIC_EVENT)
14143                 alc662_eeepc_mic_automute(codec);
14144 }
14145
14146 static void alc662_eeepc_inithook(struct hda_codec *codec)
14147 {
14148         alc262_hippo1_automute( codec );
14149         alc662_eeepc_mic_automute(codec);
14150 }
14151
14152 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
14153 {
14154         unsigned int mute;
14155         unsigned int present;
14156
14157         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
14158         present = snd_hda_codec_read(codec, 0x14, 0,
14159                                      AC_VERB_GET_PIN_SENSE, 0);
14160         present = (present & 0x80000000) != 0;
14161         if (present) {
14162                 /* mute internal speaker */
14163                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
14164                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
14165         } else {
14166                 /* unmute internal speaker if necessary */
14167                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
14168                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
14169                                          HDA_AMP_MUTE, mute);
14170         }
14171 }
14172
14173 /* unsolicited event for HP jack sensing */
14174 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
14175                                           unsigned int res)
14176 {
14177         if ((res >> 26) == ALC880_HP_EVENT)
14178                 alc662_eeepc_ep20_automute(codec);
14179 }
14180
14181 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
14182 {
14183         alc662_eeepc_ep20_automute(codec);
14184 }
14185
14186 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
14187 {
14188         unsigned int present;
14189         unsigned char bits;
14190
14191         present = snd_hda_codec_read(codec, 0x21, 0,
14192                                      AC_VERB_GET_PIN_SENSE, 0)
14193                 & AC_PINSENSE_PRESENCE;
14194         bits = present ? HDA_AMP_MUTE : 0;
14195         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14196                                  HDA_AMP_MUTE, bits);
14197 }
14198
14199 static void alc663_m51va_mic_automute(struct hda_codec *codec)
14200 {
14201         unsigned int present;
14202
14203         present = snd_hda_codec_read(codec, 0x18, 0,
14204                                      AC_VERB_GET_PIN_SENSE, 0)
14205                 & AC_PINSENSE_PRESENCE;
14206         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14207                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14208         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14209                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
14210         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14211                             0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
14212         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14213                             0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
14214 }
14215
14216 static void alc663_m51va_unsol_event(struct hda_codec *codec,
14217                                            unsigned int res)
14218 {
14219         switch (res >> 26) {
14220         case ALC880_HP_EVENT:
14221                 alc663_m51va_speaker_automute(codec);
14222                 break;
14223         case ALC880_MIC_EVENT:
14224                 alc663_m51va_mic_automute(codec);
14225                 break;
14226         }
14227 }
14228
14229 static void alc663_m51va_inithook(struct hda_codec *codec)
14230 {
14231         alc663_m51va_speaker_automute(codec);
14232         alc663_m51va_mic_automute(codec);
14233 }
14234
14235 static void alc663_g71v_hp_automute(struct hda_codec *codec)
14236 {
14237         unsigned int present;
14238         unsigned char bits;
14239
14240         present = snd_hda_codec_read(codec, 0x21, 0,
14241                                      AC_VERB_GET_PIN_SENSE, 0)
14242                 & AC_PINSENSE_PRESENCE;
14243         bits = present ? HDA_AMP_MUTE : 0;
14244         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
14245                                  HDA_AMP_MUTE, bits);
14246         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14247                                  HDA_AMP_MUTE, bits);
14248 }
14249
14250 static void alc663_g71v_front_automute(struct hda_codec *codec)
14251 {
14252         unsigned int present;
14253         unsigned char bits;
14254
14255         present = snd_hda_codec_read(codec, 0x15, 0,
14256                                      AC_VERB_GET_PIN_SENSE, 0)
14257                 & AC_PINSENSE_PRESENCE;
14258         bits = present ? HDA_AMP_MUTE : 0;
14259         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14260                                  HDA_AMP_MUTE, bits);
14261 }
14262
14263 static void alc663_g71v_unsol_event(struct hda_codec *codec,
14264                                            unsigned int res)
14265 {
14266         switch (res >> 26) {
14267         case ALC880_HP_EVENT:
14268                 alc663_g71v_hp_automute(codec);
14269                 break;
14270         case ALC880_FRONT_EVENT:
14271                 alc663_g71v_front_automute(codec);
14272                 break;
14273         case ALC880_MIC_EVENT:
14274                 alc662_eeepc_mic_automute(codec);
14275                 break;
14276         }
14277 }
14278
14279 static void alc663_g71v_inithook(struct hda_codec *codec)
14280 {
14281         alc663_g71v_front_automute(codec);
14282         alc663_g71v_hp_automute(codec);
14283         alc662_eeepc_mic_automute(codec);
14284 }
14285
14286 static void alc663_g50v_unsol_event(struct hda_codec *codec,
14287                                            unsigned int res)
14288 {
14289         switch (res >> 26) {
14290         case ALC880_HP_EVENT:
14291                 alc663_m51va_speaker_automute(codec);
14292                 break;
14293         case ALC880_MIC_EVENT:
14294                 alc662_eeepc_mic_automute(codec);
14295                 break;
14296         }
14297 }
14298
14299 static void alc663_g50v_inithook(struct hda_codec *codec)
14300 {
14301         alc663_m51va_speaker_automute(codec);
14302         alc662_eeepc_mic_automute(codec);
14303 }
14304
14305 #ifdef CONFIG_SND_HDA_POWER_SAVE
14306 #define alc662_loopbacks        alc880_loopbacks
14307 #endif
14308
14309
14310 /* pcm configuration: identiacal with ALC880 */
14311 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
14312 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
14313 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
14314 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
14315
14316 /*
14317  * configuration and preset
14318  */
14319 static const char *alc662_models[ALC662_MODEL_LAST] = {
14320         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
14321         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
14322         [ALC662_3ST_6ch]        = "3stack-6ch",
14323         [ALC662_5ST_DIG]        = "6stack-dig",
14324         [ALC662_LENOVO_101E]    = "lenovo-101e",
14325         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
14326         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
14327         [ALC663_ASUS_M51VA] = "m51va",
14328         [ALC663_ASUS_G71V] = "g71v",
14329         [ALC663_ASUS_H13] = "h13",
14330         [ALC663_ASUS_G50V] = "g50v",
14331         [ALC662_AUTO]           = "auto",
14332 };
14333
14334 static struct snd_pci_quirk alc662_cfg_tbl[] = {
14335         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS G71V", ALC663_ASUS_G71V),
14336         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
14337         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS M51VA", ALC663_ASUS_G50V),
14338         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
14339         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
14340         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
14341         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
14342         SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
14343         SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
14344         SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
14345         {}
14346 };
14347
14348 static struct alc_config_preset alc662_presets[] = {
14349         [ALC662_3ST_2ch_DIG] = {
14350                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
14351                 .init_verbs = { alc662_init_verbs },
14352                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14353                 .dac_nids = alc662_dac_nids,
14354                 .dig_out_nid = ALC662_DIGOUT_NID,
14355                 .dig_in_nid = ALC662_DIGIN_NID,
14356                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14357                 .channel_mode = alc662_3ST_2ch_modes,
14358                 .input_mux = &alc662_capture_source,
14359         },
14360         [ALC662_3ST_6ch_DIG] = {
14361                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
14362                             alc662_capture_mixer },
14363                 .init_verbs = { alc662_init_verbs },
14364                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14365                 .dac_nids = alc662_dac_nids,
14366                 .dig_out_nid = ALC662_DIGOUT_NID,
14367                 .dig_in_nid = ALC662_DIGIN_NID,
14368                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14369                 .channel_mode = alc662_3ST_6ch_modes,
14370                 .need_dac_fix = 1,
14371                 .input_mux = &alc662_capture_source,
14372         },
14373         [ALC662_3ST_6ch] = {
14374                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
14375                             alc662_capture_mixer },
14376                 .init_verbs = { alc662_init_verbs },
14377                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14378                 .dac_nids = alc662_dac_nids,
14379                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14380                 .channel_mode = alc662_3ST_6ch_modes,
14381                 .need_dac_fix = 1,
14382                 .input_mux = &alc662_capture_source,
14383         },
14384         [ALC662_5ST_DIG] = {
14385                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
14386                             alc662_capture_mixer },
14387                 .init_verbs = { alc662_init_verbs },
14388                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14389                 .dac_nids = alc662_dac_nids,
14390                 .dig_out_nid = ALC662_DIGOUT_NID,
14391                 .dig_in_nid = ALC662_DIGIN_NID,
14392                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
14393                 .channel_mode = alc662_5stack_modes,
14394                 .input_mux = &alc662_capture_source,
14395         },
14396         [ALC662_LENOVO_101E] = {
14397                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
14398                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
14399                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14400                 .dac_nids = alc662_dac_nids,
14401                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14402                 .channel_mode = alc662_3ST_2ch_modes,
14403                 .input_mux = &alc662_lenovo_101e_capture_source,
14404                 .unsol_event = alc662_lenovo_101e_unsol_event,
14405                 .init_hook = alc662_lenovo_101e_all_automute,
14406         },
14407         [ALC662_ASUS_EEEPC_P701] = {
14408                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
14409                 .init_verbs = { alc662_init_verbs,
14410                                 alc662_eeepc_sue_init_verbs },
14411                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14412                 .dac_nids = alc662_dac_nids,
14413                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14414                 .channel_mode = alc662_3ST_2ch_modes,
14415                 .input_mux = &alc662_eeepc_capture_source,
14416                 .unsol_event = alc662_eeepc_unsol_event,
14417                 .init_hook = alc662_eeepc_inithook,
14418         },
14419         [ALC662_ASUS_EEEPC_EP20] = {
14420                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
14421                             alc662_chmode_mixer },
14422                 .init_verbs = { alc662_init_verbs,
14423                                 alc662_eeepc_ep20_sue_init_verbs },
14424                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14425                 .dac_nids = alc662_dac_nids,
14426                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14427                 .channel_mode = alc662_3ST_6ch_modes,
14428                 .input_mux = &alc662_lenovo_101e_capture_source,
14429                 .unsol_event = alc662_eeepc_ep20_unsol_event,
14430                 .init_hook = alc662_eeepc_ep20_inithook,
14431         },
14432         [ALC663_ASUS_M51VA] = {
14433                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
14434                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
14435                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14436                 .dac_nids = alc662_dac_nids,
14437                 .dig_out_nid = ALC662_DIGOUT_NID,
14438                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14439                 .channel_mode = alc662_3ST_2ch_modes,
14440                 .input_mux = &alc663_m51va_capture_source,
14441                 .unsol_event = alc663_m51va_unsol_event,
14442                 .init_hook = alc663_m51va_inithook,
14443         },
14444         [ALC663_ASUS_G71V] = {
14445                 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
14446                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
14447                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14448                 .dac_nids = alc662_dac_nids,
14449                 .dig_out_nid = ALC662_DIGOUT_NID,
14450                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14451                 .channel_mode = alc662_3ST_2ch_modes,
14452                 .input_mux = &alc662_eeepc_capture_source,
14453                 .unsol_event = alc663_g71v_unsol_event,
14454                 .init_hook = alc663_g71v_inithook,
14455         },
14456         [ALC663_ASUS_H13] = {
14457                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
14458                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
14459                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14460                 .dac_nids = alc662_dac_nids,
14461                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
14462                 .channel_mode = alc662_3ST_2ch_modes,
14463                 .input_mux = &alc663_m51va_capture_source,
14464                 .unsol_event = alc663_m51va_unsol_event,
14465                 .init_hook = alc663_m51va_inithook,
14466         },
14467         [ALC663_ASUS_G50V] = {
14468                 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
14469                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
14470                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
14471                 .dac_nids = alc662_dac_nids,
14472                 .dig_out_nid = ALC662_DIGOUT_NID,
14473                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
14474                 .channel_mode = alc662_3ST_6ch_modes,
14475                 .input_mux = &alc663_capture_source,
14476                 .unsol_event = alc663_g50v_unsol_event,
14477                 .init_hook = alc663_g50v_inithook,
14478         },
14479 };
14480
14481
14482 /*
14483  * BIOS auto configuration
14484  */
14485
14486 /* add playback controls from the parsed DAC table */
14487 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
14488                                              const struct auto_pin_cfg *cfg)
14489 {
14490         char name[32];
14491         static const char *chname[4] = {
14492                 "Front", "Surround", NULL /*CLFE*/, "Side"
14493         };
14494         hda_nid_t nid;
14495         int i, err;
14496
14497         for (i = 0; i < cfg->line_outs; i++) {
14498                 if (!spec->multiout.dac_nids[i])
14499                         continue;
14500                 nid = alc880_idx_to_dac(i);
14501                 if (i == 2) {
14502                         /* Center/LFE */
14503                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14504                                           "Center Playback Volume",
14505                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
14506                                                               HDA_OUTPUT));
14507                         if (err < 0)
14508                                 return err;
14509                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14510                                           "LFE Playback Volume",
14511                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
14512                                                               HDA_OUTPUT));
14513                         if (err < 0)
14514                                 return err;
14515                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14516                                           "Center Playback Switch",
14517                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
14518                                                               HDA_INPUT));
14519                         if (err < 0)
14520                                 return err;
14521                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14522                                           "LFE Playback Switch",
14523                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
14524                                                               HDA_INPUT));
14525                         if (err < 0)
14526                                 return err;
14527                 } else {
14528                         sprintf(name, "%s Playback Volume", chname[i]);
14529                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14530                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
14531                                                               HDA_OUTPUT));
14532                         if (err < 0)
14533                                 return err;
14534                         sprintf(name, "%s Playback Switch", chname[i]);
14535                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14536                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
14537                                                               HDA_INPUT));
14538                         if (err < 0)
14539                                 return err;
14540                 }
14541         }
14542         return 0;
14543 }
14544
14545 /* add playback controls for speaker and HP outputs */
14546 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
14547                                         const char *pfx)
14548 {
14549         hda_nid_t nid;
14550         int err;
14551         char name[32];
14552
14553         if (!pin)
14554                 return 0;
14555
14556         if (alc880_is_fixed_pin(pin)) {
14557                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14558                 /* printk("DAC nid=%x\n",nid); */
14559                 /* specify the DAC as the extra output */
14560                 if (!spec->multiout.hp_nid)
14561                         spec->multiout.hp_nid = nid;
14562                 else
14563                         spec->multiout.extra_out_nid[0] = nid;
14564                 /* control HP volume/switch on the output mixer amp */
14565                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14566                 sprintf(name, "%s Playback Volume", pfx);
14567                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14568                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
14569                 if (err < 0)
14570                         return err;
14571                 sprintf(name, "%s Playback Switch", pfx);
14572                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14573                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
14574                 if (err < 0)
14575                         return err;
14576         } else if (alc880_is_multi_pin(pin)) {
14577                 /* set manual connection */
14578                 /* we have only a switch on HP-out PIN */
14579                 sprintf(name, "%s Playback Switch", pfx);
14580                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14581                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14582                 if (err < 0)
14583                         return err;
14584         }
14585         return 0;
14586 }
14587
14588 /* create playback/capture controls for input pins */
14589 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
14590                                                 const struct auto_pin_cfg *cfg)
14591 {
14592         struct hda_input_mux *imux = &spec->private_imux;
14593         int i, err, idx;
14594
14595         for (i = 0; i < AUTO_PIN_LAST; i++) {
14596                 if (alc880_is_input_pin(cfg->input_pins[i])) {
14597                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
14598                         err = new_analog_input(spec, cfg->input_pins[i],
14599                                                auto_pin_cfg_labels[i],
14600                                                idx, 0x0b);
14601                         if (err < 0)
14602                                 return err;
14603                         imux->items[imux->num_items].label =
14604                                 auto_pin_cfg_labels[i];
14605                         imux->items[imux->num_items].index =
14606                                 alc880_input_pin_idx(cfg->input_pins[i]);
14607                         imux->num_items++;
14608                 }
14609         }
14610         return 0;
14611 }
14612
14613 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
14614                                               hda_nid_t nid, int pin_type,
14615                                               int dac_idx)
14616 {
14617         alc_set_pin_output(codec, nid, pin_type);
14618         /* need the manual connection? */
14619         if (alc880_is_multi_pin(nid)) {
14620                 struct alc_spec *spec = codec->spec;
14621                 int idx = alc880_multi_pin_idx(nid);
14622                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
14623                                     AC_VERB_SET_CONNECT_SEL,
14624                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
14625         }
14626 }
14627
14628 static void alc662_auto_init_multi_out(struct hda_codec *codec)
14629 {
14630         struct alc_spec *spec = codec->spec;
14631         int i;
14632
14633         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14634         for (i = 0; i <= HDA_SIDE; i++) {
14635                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14636                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14637                 if (nid)
14638                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
14639                                                           i);
14640         }
14641 }
14642
14643 static void alc662_auto_init_hp_out(struct hda_codec *codec)
14644 {
14645         struct alc_spec *spec = codec->spec;
14646         hda_nid_t pin;
14647
14648         pin = spec->autocfg.hp_pins[0];
14649         if (pin) /* connect to front */
14650                 /* use dac 0 */
14651                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14652         pin = spec->autocfg.speaker_pins[0];
14653         if (pin)
14654                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14655 }
14656
14657 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
14658 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
14659
14660 static void alc662_auto_init_analog_input(struct hda_codec *codec)
14661 {
14662         struct alc_spec *spec = codec->spec;
14663         int i;
14664
14665         for (i = 0; i < AUTO_PIN_LAST; i++) {
14666                 hda_nid_t nid = spec->autocfg.input_pins[i];
14667                 if (alc662_is_input_pin(nid)) {
14668                         snd_hda_codec_write(codec, nid, 0,
14669                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
14670                                             (i <= AUTO_PIN_FRONT_MIC ?
14671                                              PIN_VREF80 : PIN_IN));
14672                         if (nid != ALC662_PIN_CD_NID)
14673                                 snd_hda_codec_write(codec, nid, 0,
14674                                                     AC_VERB_SET_AMP_GAIN_MUTE,
14675                                                     AMP_OUT_MUTE);
14676                 }
14677         }
14678 }
14679
14680 static int alc662_parse_auto_config(struct hda_codec *codec)
14681 {
14682         struct alc_spec *spec = codec->spec;
14683         int err;
14684         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
14685
14686         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14687                                            alc662_ignore);
14688         if (err < 0)
14689                 return err;
14690         if (!spec->autocfg.line_outs)
14691                 return 0; /* can't find valid BIOS pin config */
14692
14693         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14694         if (err < 0)
14695                 return err;
14696         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
14697         if (err < 0)
14698                 return err;
14699         err = alc662_auto_create_extra_out(spec,
14700                                            spec->autocfg.speaker_pins[0],
14701                                            "Speaker");
14702         if (err < 0)
14703                 return err;
14704         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
14705                                            "Headphone");
14706         if (err < 0)
14707                 return err;
14708         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
14709         if (err < 0)
14710                 return err;
14711
14712         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14713
14714         if (spec->autocfg.dig_out_pin)
14715                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
14716
14717         if (spec->kctl_alloc)
14718                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14719
14720         spec->num_mux_defs = 1;
14721         spec->input_mux = &spec->private_imux;
14722
14723         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
14724         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
14725         spec->num_mixers++;
14726         return 1;
14727 }
14728
14729 /* additional initialization for auto-configuration model */
14730 static void alc662_auto_init(struct hda_codec *codec)
14731 {
14732         struct alc_spec *spec = codec->spec;
14733         alc662_auto_init_multi_out(codec);
14734         alc662_auto_init_hp_out(codec);
14735         alc662_auto_init_analog_input(codec);
14736         if (spec->unsol_event)
14737                 alc_sku_automute(codec);
14738 }
14739
14740 static int patch_alc662(struct hda_codec *codec)
14741 {
14742         struct alc_spec *spec;
14743         int err, board_config;
14744
14745         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14746         if (!spec)
14747                 return -ENOMEM;
14748
14749         codec->spec = spec;
14750
14751         alc_fix_pll_init(codec, 0x20, 0x04, 15);
14752
14753         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
14754                                                   alc662_models,
14755                                                   alc662_cfg_tbl);
14756         if (board_config < 0) {
14757                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
14758                        "trying auto-probe from BIOS...\n");
14759                 board_config = ALC662_AUTO;
14760         }
14761
14762         if (board_config == ALC662_AUTO) {
14763                 /* automatic parse from the BIOS config */
14764                 err = alc662_parse_auto_config(codec);
14765                 if (err < 0) {
14766                         alc_free(codec);
14767                         return err;
14768                 } else if (!err) {
14769                         printk(KERN_INFO
14770                                "hda_codec: Cannot set up configuration "
14771                                "from BIOS.  Using base mode...\n");
14772                         board_config = ALC662_3ST_2ch_DIG;
14773                 }
14774         }
14775
14776         if (board_config != ALC662_AUTO)
14777                 setup_preset(spec, &alc662_presets[board_config]);
14778
14779         if (codec->vendor_id == 0x10ec0663) {
14780                 spec->stream_name_analog = "ALC663 Analog";
14781                 spec->stream_name_digital = "ALC663 Digital";
14782         } else {
14783                 spec->stream_name_analog = "ALC662 Analog";
14784                 spec->stream_name_digital = "ALC662 Digital";
14785         }
14786
14787         spec->stream_analog_playback = &alc662_pcm_analog_playback;
14788         spec->stream_analog_capture = &alc662_pcm_analog_capture;
14789
14790         spec->stream_digital_playback = &alc662_pcm_digital_playback;
14791         spec->stream_digital_capture = &alc662_pcm_digital_capture;
14792
14793         spec->adc_nids = alc662_adc_nids;
14794         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
14795         spec->capsrc_nids = alc662_capsrc_nids;
14796
14797         spec->vmaster_nid = 0x02;
14798
14799         codec->patch_ops = alc_patch_ops;
14800         if (board_config == ALC662_AUTO)
14801                 spec->init_hook = alc662_auto_init;
14802 #ifdef CONFIG_SND_HDA_POWER_SAVE
14803         if (!spec->loopback.amplist)
14804                 spec->loopback.amplist = alc662_loopbacks;
14805 #endif
14806
14807         return 0;
14808 }
14809
14810 /*
14811  * patch entries
14812  */
14813 struct hda_codec_preset snd_hda_preset_realtek[] = {
14814         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
14815         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
14816         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
14817         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
14818         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
14819         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
14820           .patch = patch_alc861 },
14821         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
14822         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
14823         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
14824         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
14825           .patch = patch_alc883 },
14826         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
14827           .patch = patch_alc662 },
14828         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
14829         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
14830         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
14831         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
14832         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
14833           .patch = patch_alc882 }, /* should be patch_alc883() in future */
14834         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
14835         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
14836         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
14837         {} /* terminator */
14838 };