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
  34 #define ALC880_FRONT_EVENT              0x01
  35 #define ALC880_DCVOL_EVENT              0x02
  36 #define ALC880_HP_EVENT                 0x04
  37 #define ALC880_MIC_EVENT                0x08
  38
  39 /* ALC880 board config type */
  40 enum {
  41         ALC880_3ST,
  42         ALC880_3ST_DIG,
  43         ALC880_5ST,
  44         ALC880_5ST_DIG,
  45         ALC880_W810,
  46         ALC880_Z71V,
  47         ALC880_6ST,
  48         ALC880_6ST_DIG,
  49         ALC880_F1734,
  50         ALC880_ASUS,
  51         ALC880_ASUS_DIG,
  52         ALC880_ASUS_W1V,
  53         ALC880_ASUS_DIG2,
  54         ALC880_FUJITSU,
  55         ALC880_UNIWILL_DIG,
  56         ALC880_UNIWILL,
  57         ALC880_UNIWILL_P53,
  58         ALC880_CLEVO,
  59         ALC880_TCL_S700,
  60         ALC880_LG,
  61         ALC880_LG_LW,
  62 #ifdef CONFIG_SND_DEBUG
  63         ALC880_TEST,
  64 #endif
  65         ALC880_AUTO,
  66         ALC880_MODEL_LAST /* last tag */
  67 };
  68
  69 /* ALC260 models */
  70 enum {
  71         ALC260_BASIC,
  72         ALC260_HP,
  73         ALC260_HP_3013,
  74         ALC260_FUJITSU_S702X,
  75         ALC260_ACER,
  76         ALC260_WILL,
  77         ALC260_REPLACER_672V,
  78 #ifdef CONFIG_SND_DEBUG
  79         ALC260_TEST,
  80 #endif
  81         ALC260_AUTO,
  82         ALC260_MODEL_LAST /* last tag */
  83 };
  84
  85 /* ALC262 models */
  86 enum {
  87         ALC262_BASIC,
  88         ALC262_HIPPO,
  89         ALC262_HIPPO_1,
  90         ALC262_FUJITSU,
  91         ALC262_HP_BPC,
  92         ALC262_HP_BPC_D7000_WL,
  93         ALC262_HP_BPC_D7000_WF,
  94         ALC262_HP_TC_T5735,
  95         ALC262_HP_RP5700,
  96         ALC262_BENQ_ED8,
  97         ALC262_SONY_ASSAMD,
  98         ALC262_BENQ_T31,
  99         ALC262_ULTRA,
 100         ALC262_AUTO,
 101         ALC262_MODEL_LAST /* last tag */
 102 };
 103
 104 /* ALC268 models */
 105 enum {
 106         ALC268_3ST,
 107         ALC268_TOSHIBA,
 108         ALC268_ACER,
 109         ALC268_DELL,
 110         ALC268_ZEPTO,
 111 #ifdef CONFIG_SND_DEBUG
 112         ALC268_TEST,
 113 #endif
 114         ALC268_AUTO,
 115         ALC268_MODEL_LAST /* last tag */
 116 };
 117
 118 /* ALC269 models */
 119 enum {
 120         ALC269_BASIC,
 121         ALC269_AUTO,
 122         ALC269_MODEL_LAST /* last tag */
 123 };
 124
 125 /* ALC861 models */
 126 enum {
 127         ALC861_3ST,
 128         ALC660_3ST,
 129         ALC861_3ST_DIG,
 130         ALC861_6ST_DIG,
 131         ALC861_UNIWILL_M31,
 132         ALC861_TOSHIBA,
 133         ALC861_ASUS,
 134         ALC861_ASUS_LAPTOP,
 135         ALC861_AUTO,
 136         ALC861_MODEL_LAST,
 137 };
 138
 139 /* ALC861-VD models */
 140 enum {
 141         ALC660VD_3ST,
 142         ALC660VD_3ST_DIG,
 143         ALC861VD_3ST,
 144         ALC861VD_3ST_DIG,
 145         ALC861VD_6ST_DIG,
 146         ALC861VD_LENOVO,
 147         ALC861VD_DALLAS,
 148         ALC861VD_HP,
 149         ALC861VD_AUTO,
 150         ALC861VD_MODEL_LAST,
 151 };
 152
 153 /* ALC662 models */
 154 enum {
 155         ALC662_3ST_2ch_DIG,
 156         ALC662_3ST_6ch_DIG,
 157         ALC662_3ST_6ch,
 158         ALC662_5ST_DIG,
 159         ALC662_LENOVO_101E,
 160         ALC662_ASUS_EEEPC_P701,
 161         ALC662_ASUS_EEEPC_EP20,
 162         ALC662_AUTO,
 163         ALC662_MODEL_LAST,
 164 };
 165
 166 /* ALC882 models */
 167 enum {
 168         ALC882_3ST_DIG,
 169         ALC882_6ST_DIG,
 170         ALC882_ARIMA,
 171         ALC882_W2JC,
 172         ALC882_TARGA,
 173         ALC882_ASUS_A7J,
 174         ALC882_ASUS_A7M,
 175         ALC885_MACPRO,
 176         ALC885_MBP3,
 177         ALC885_IMAC24,
 178         ALC882_AUTO,
 179         ALC882_MODEL_LAST,
 180 };
 181
 182 /* ALC883 models */
 183 enum {
 184         ALC883_3ST_2ch_DIG,
 185         ALC883_3ST_6ch_DIG,
 186         ALC883_3ST_6ch,
 187         ALC883_6ST_DIG,
 188         ALC883_TARGA_DIG,
 189         ALC883_TARGA_2ch_DIG,
 190         ALC883_ACER,
 191         ALC883_ACER_ASPIRE,
 192         ALC883_MEDION,
 193         ALC883_MEDION_MD2,
 194         ALC883_LAPTOP_EAPD,
 195         ALC883_LENOVO_101E_2ch,
 196         ALC883_LENOVO_NB0763,
 197         ALC888_LENOVO_MS7195_DIG,
 198         ALC883_HAIER_W66,
 199         ALC888_6ST_HP,
 200         ALC888_3ST_HP,
 201         ALC888_6ST_DELL,
 202         ALC883_MITAC,
 203         ALC883_AUTO,
 204         ALC883_MODEL_LAST,
 205 };
 206
 207 /* for GPIO Poll */
 208 #define GPIO_MASK       0x03
 209
 210 struct alc_spec {
 211         /* codec parameterization */
 212         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 213         unsigned int num_mixers;
 214
 215         const struct hda_verb *init_verbs[5];   /* initialization verbs
 216                                                  * don't forget NULL
 217                                                  * termination!
 218                                                  */
 219         unsigned int num_init_verbs;
 220
 221         char *stream_name_analog;       /* analog PCM stream */
 222         struct hda_pcm_stream *stream_analog_playback;
 223         struct hda_pcm_stream *stream_analog_capture;
 224         struct hda_pcm_stream *stream_analog_alt_playback;
 225         struct hda_pcm_stream *stream_analog_alt_capture;
 226
 227         char *stream_name_digital;      /* digital PCM stream */
 228         struct hda_pcm_stream *stream_digital_playback;
 229         struct hda_pcm_stream *stream_digital_capture;
 230
 231         /* playback */
 232         struct hda_multi_out multiout;  /* playback set-up
 233                                          * max_channels, dacs must be set
 234                                          * dig_out_nid and hp_nid are optional
 235                                          */
 236         hda_nid_t alt_dac_nid;
 237
 238         /* capture */
 239         unsigned int num_adc_nids;
 240         hda_nid_t *adc_nids;
 241         hda_nid_t *capsrc_nids;
 242         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 243
 244         /* capture source */
 245         unsigned int num_mux_defs;
 246         const struct hda_input_mux *input_mux;
 247         unsigned int cur_mux[3];
 248
 249         /* channel model */
 250         const struct hda_channel_mode *channel_mode;
 251         int num_channel_mode;
 252         int need_dac_fix;
 253
 254         /* PCM information */
 255         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 256
 257         /* dynamic controls, init_verbs and input_mux */
 258         struct auto_pin_cfg autocfg;
 259         unsigned int num_kctl_alloc, num_kctl_used;
 260         struct snd_kcontrol_new *kctl_alloc;
 261         struct hda_input_mux private_imux;
 262         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 263
 264         /* hooks */
 265         void (*init_hook)(struct hda_codec *codec);
 266         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 267
 268         /* for pin sensing */
 269         unsigned int sense_updated: 1;
 270         unsigned int jack_present: 1;
 271         unsigned int master_sw: 1;
 272
 273         /* for virtual master */
 274         hda_nid_t vmaster_nid;
 275         u32 vmaster_tlv[4];
 276 #ifdef CONFIG_SND_HDA_POWER_SAVE
 277         struct hda_loopback_check loopback;
 278 #endif
 279 };
 280
 281 /*
 282  * configuration template - to be copied to the spec instance
 283  */
 284 struct alc_config_preset {
 285         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 286                                              * with spec
 287                                              */
 288         const struct hda_verb *init_verbs[5];
 289         unsigned int num_dacs;
 290         hda_nid_t *dac_nids;
 291         hda_nid_t dig_out_nid;          /* optional */
 292         hda_nid_t hp_nid;               /* optional */
 293         unsigned int num_adc_nids;
 294         hda_nid_t *adc_nids;
 295         hda_nid_t *capsrc_nids;
 296         hda_nid_t dig_in_nid;
 297         unsigned int num_channel_mode;
 298         const struct hda_channel_mode *channel_mode;
 299         int need_dac_fix;
 300         unsigned int num_mux_defs;
 301         const struct hda_input_mux *input_mux;
 302         void (*unsol_event)(struct hda_codec *, unsigned int);
 303         void (*init_hook)(struct hda_codec *);
 304 #ifdef CONFIG_SND_HDA_POWER_SAVE
 305         struct hda_amp_list *loopbacks;
 306 #endif
 307 };
 308
 309
 310 /*
 311  * input MUX handling
 312  */
 313 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 314                              struct snd_ctl_elem_info *uinfo)
 315 {
 316         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 317         struct alc_spec *spec = codec->spec;
 318         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 319         if (mux_idx >= spec->num_mux_defs)
 320                 mux_idx = 0;
 321         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 322 }
 323
 324 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 325                             struct snd_ctl_elem_value *ucontrol)
 326 {
 327         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 328         struct alc_spec *spec = codec->spec;
 329         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 330
 331         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 332         return 0;
 333 }
 334
 335 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 336                             struct snd_ctl_elem_value *ucontrol)
 337 {
 338         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 339         struct alc_spec *spec = codec->spec;
 340         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 341         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 342         hda_nid_t nid = spec->capsrc_nids ?
 343                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 344         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
 345                                      nid, &spec->cur_mux[adc_idx]);
 346 }
 347
 348
 349 /*
 350  * channel mode setting
 351  */
 352 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 353                             struct snd_ctl_elem_info *uinfo)
 354 {
 355         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 356         struct alc_spec *spec = codec->spec;
 357         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 358                                     spec->num_channel_mode);
 359 }
 360
 361 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 362                            struct snd_ctl_elem_value *ucontrol)
 363 {
 364         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 365         struct alc_spec *spec = codec->spec;
 366         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 367                                    spec->num_channel_mode,
 368                                    spec->multiout.max_channels);
 369 }
 370
 371 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 372                            struct snd_ctl_elem_value *ucontrol)
 373 {
 374         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 375         struct alc_spec *spec = codec->spec;
 376         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 377                                       spec->num_channel_mode,
 378                                       &spec->multiout.max_channels);
 379         if (err >= 0 && spec->need_dac_fix)
 380                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 381         return err;
 382 }
 383
 384 /*
 385  * Control the mode of pin widget settings via the mixer.  "pc" is used
 386  * instead of "%" to avoid consequences of accidently treating the % as
 387  * being part of a format specifier.  Maximum allowed length of a value is
 388  * 63 characters plus NULL terminator.
 389  *
 390  * Note: some retasking pin complexes seem to ignore requests for input
 391  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 392  * are requested.  Therefore order this list so that this behaviour will not
 393  * cause problems when mixer clients move through the enum sequentially.
 394  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 395  * March 2006.
 396  */
 397 static char *alc_pin_mode_names[] = {
 398         "Mic 50pc bias", "Mic 80pc bias",
 399         "Line in", "Line out", "Headphone out",
 400 };
 401 static unsigned char alc_pin_mode_values[] = {
 402         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 403 };
 404 /* The control can present all 5 options, or it can limit the options based
 405  * in the pin being assumed to be exclusively an input or an output pin.  In
 406  * addition, "input" pins may or may not process the mic bias option
 407  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 408  * accept requests for bias as of chip versions up to March 2006) and/or
 409  * wiring in the computer.
 410  */
 411 #define ALC_PIN_DIR_IN              0x00
 412 #define ALC_PIN_DIR_OUT             0x01
 413 #define ALC_PIN_DIR_INOUT           0x02
 414 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 415 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 416
 417 /* Info about the pin modes supported by the different pin direction modes.
 418  * For each direction the minimum and maximum values are given.
 419  */
 420 static signed char alc_pin_mode_dir_info[5][2] = {
 421         { 0, 2 },    /* ALC_PIN_DIR_IN */
 422         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 423         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 424         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 425         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 426 };
 427 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 428 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 429 #define alc_pin_mode_n_items(_dir) \
 430         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 431
 432 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 433                              struct snd_ctl_elem_info *uinfo)
 434 {
 435         unsigned int item_num = uinfo->value.enumerated.item;
 436         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 437
 438         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 439         uinfo->count = 1;
 440         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 441
 442         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 443                 item_num = alc_pin_mode_min(dir);
 444         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 445         return 0;
 446 }
 447
 448 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 449                             struct snd_ctl_elem_value *ucontrol)
 450 {
 451         unsigned int i;
 452         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 453         hda_nid_t nid = kcontrol->private_value & 0xffff;
 454         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 455         long *valp = ucontrol->value.integer.value;
 456         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 457                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 458                                                  0x00);
 459
 460         /* Find enumerated value for current pinctl setting */
 461         i = alc_pin_mode_min(dir);
 462         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 463                 i++;
 464         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 465         return 0;
 466 }
 467
 468 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 469                             struct snd_ctl_elem_value *ucontrol)
 470 {
 471         signed int change;
 472         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 473         hda_nid_t nid = kcontrol->private_value & 0xffff;
 474         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 475         long val = *ucontrol->value.integer.value;
 476         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 477                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 478                                                  0x00);
 479
 480         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 481                 val = alc_pin_mode_min(dir);
 482
 483         change = pinctl != alc_pin_mode_values[val];
 484         if (change) {
 485                 /* Set pin mode to that requested */
 486                 snd_hda_codec_write_cache(codec, nid, 0,
 487                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 488                                           alc_pin_mode_values[val]);
 489
 490                 /* Also enable the retasking pin's input/output as required
 491                  * for the requested pin mode.  Enum values of 2 or less are
 492                  * input modes.
 493                  *
 494                  * Dynamically switching the input/output buffers probably
 495                  * reduces noise slightly (particularly on input) so we'll
 496                  * do it.  However, having both input and output buffers
 497                  * enabled simultaneously doesn't seem to be problematic if
 498                  * this turns out to be necessary in the future.
 499                  */
 500                 if (val <= 2) {
 501                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 502                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 503                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 504                                                  HDA_AMP_MUTE, 0);
 505                 } else {
 506                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 507                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 508                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 509                                                  HDA_AMP_MUTE, 0);
 510                 }
 511         }
 512         return change;
 513 }
 514
 515 #define ALC_PIN_MODE(xname, nid, dir) \
 516         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 517           .info = alc_pin_mode_info, \
 518           .get = alc_pin_mode_get, \
 519           .put = alc_pin_mode_put, \
 520           .private_value = nid | (dir<<16) }
 521
 522 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 523  * together using a mask with more than one bit set.  This control is
 524  * currently used only by the ALC260 test model.  At this stage they are not
 525  * needed for any "production" models.
 526  */
 527 #ifdef CONFIG_SND_DEBUG
 528 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 529
 530 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 531                              struct snd_ctl_elem_value *ucontrol)
 532 {
 533         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 534         hda_nid_t nid = kcontrol->private_value & 0xffff;
 535         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 536         long *valp = ucontrol->value.integer.value;
 537         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 538                                               AC_VERB_GET_GPIO_DATA, 0x00);
 539
 540         *valp = (val & mask) != 0;
 541         return 0;
 542 }
 543 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 544                              struct snd_ctl_elem_value *ucontrol)
 545 {
 546         signed int change;
 547         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 548         hda_nid_t nid = kcontrol->private_value & 0xffff;
 549         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 550         long val = *ucontrol->value.integer.value;
 551         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 552                                                     AC_VERB_GET_GPIO_DATA,
 553                                                     0x00);
 554
 555         /* Set/unset the masked GPIO bit(s) as needed */
 556         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 557         if (val == 0)
 558                 gpio_data &= ~mask;
 559         else
 560                 gpio_data |= mask;
 561         snd_hda_codec_write_cache(codec, nid, 0,
 562                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 563
 564         return change;
 565 }
 566 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 567         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 568           .info = alc_gpio_data_info, \
 569           .get = alc_gpio_data_get, \
 570           .put = alc_gpio_data_put, \
 571           .private_value = nid | (mask<<16) }
 572 #endif   /* CONFIG_SND_DEBUG */
 573
 574 /* A switch control to allow the enabling of the digital IO pins on the
 575  * ALC260.  This is incredibly simplistic; the intention of this control is
 576  * to provide something in the test model allowing digital outputs to be
 577  * identified if present.  If models are found which can utilise these
 578  * outputs a more complete mixer control can be devised for those models if
 579  * necessary.
 580  */
 581 #ifdef CONFIG_SND_DEBUG
 582 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 583
 584 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 585                               struct snd_ctl_elem_value *ucontrol)
 586 {
 587         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 588         hda_nid_t nid = kcontrol->private_value & 0xffff;
 589         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 590         long *valp = ucontrol->value.integer.value;
 591         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 592                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 593
 594         *valp = (val & mask) != 0;
 595         return 0;
 596 }
 597 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 598                               struct snd_ctl_elem_value *ucontrol)
 599 {
 600         signed int change;
 601         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 602         hda_nid_t nid = kcontrol->private_value & 0xffff;
 603         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 604         long val = *ucontrol->value.integer.value;
 605         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 606                                                     AC_VERB_GET_DIGI_CONVERT_1,
 607                                                     0x00);
 608
 609         /* Set/unset the masked control bit(s) as needed */
 610         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 611         if (val==0)
 612                 ctrl_data &= ~mask;
 613         else
 614                 ctrl_data |= mask;
 615         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 616                                   ctrl_data);
 617
 618         return change;
 619 }
 620 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 621         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 622           .info = alc_spdif_ctrl_info, \
 623           .get = alc_spdif_ctrl_get, \
 624           .put = alc_spdif_ctrl_put, \
 625           .private_value = nid | (mask<<16) }
 626 #endif   /* CONFIG_SND_DEBUG */
 627
 628 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 629  * Again, this is only used in the ALC26x test models to help identify when
 630  * the EAPD line must be asserted for features to work.
 631  */
 632 #ifdef CONFIG_SND_DEBUG
 633 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 634
 635 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 636                               struct snd_ctl_elem_value *ucontrol)
 637 {
 638         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 639         hda_nid_t nid = kcontrol->private_value & 0xffff;
 640         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 641         long *valp = ucontrol->value.integer.value;
 642         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 643                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 644
 645         *valp = (val & mask) != 0;
 646         return 0;
 647 }
 648
 649 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 650                               struct snd_ctl_elem_value *ucontrol)
 651 {
 652         int change;
 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 val = *ucontrol->value.integer.value;
 657         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 658                                                     AC_VERB_GET_EAPD_BTLENABLE,
 659                                                     0x00);
 660
 661         /* Set/unset the masked control bit(s) as needed */
 662         change = (!val ? 0 : mask) != (ctrl_data & mask);
 663         if (!val)
 664                 ctrl_data &= ~mask;
 665         else
 666                 ctrl_data |= mask;
 667         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 668                                   ctrl_data);
 669
 670         return change;
 671 }
 672
 673 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 674         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 675           .info = alc_eapd_ctrl_info, \
 676           .get = alc_eapd_ctrl_get, \
 677           .put = alc_eapd_ctrl_put, \
 678           .private_value = nid | (mask<<16) }
 679 #endif   /* CONFIG_SND_DEBUG */
 680
 681 /*
 682  * set up from the preset table
 683  */
 684 static void setup_preset(struct alc_spec *spec,
 685                          const struct alc_config_preset *preset)
 686 {
 687         int i;
 688
 689         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 690                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
 691         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 692              i++)
 693                 spec->init_verbs[spec->num_init_verbs++] =
 694                         preset->init_verbs[i];
 695
 696         spec->channel_mode = preset->channel_mode;
 697         spec->num_channel_mode = preset->num_channel_mode;
 698         spec->need_dac_fix = preset->need_dac_fix;
 699
 700         spec->multiout.max_channels = spec->channel_mode[0].channels;
 701
 702         spec->multiout.num_dacs = preset->num_dacs;
 703         spec->multiout.dac_nids = preset->dac_nids;
 704         spec->multiout.dig_out_nid = preset->dig_out_nid;
 705         spec->multiout.hp_nid = preset->hp_nid;
 706
 707         spec->num_mux_defs = preset->num_mux_defs;
 708         if (!spec->num_mux_defs)
 709                 spec->num_mux_defs = 1;
 710         spec->input_mux = preset->input_mux;
 711
 712         spec->num_adc_nids = preset->num_adc_nids;
 713         spec->adc_nids = preset->adc_nids;
 714         spec->capsrc_nids = preset->capsrc_nids;
 715         spec->dig_in_nid = preset->dig_in_nid;
 716
 717         spec->unsol_event = preset->unsol_event;
 718         spec->init_hook = preset->init_hook;
 719 #ifdef CONFIG_SND_HDA_POWER_SAVE
 720         spec->loopback.amplist = preset->loopbacks;
 721 #endif
 722 }
 723
 724 /* Enable GPIO mask and set output */
 725 static struct hda_verb alc_gpio1_init_verbs[] = {
 726         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 727         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 728         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 729         { }
 730 };
 731
 732 static struct hda_verb alc_gpio2_init_verbs[] = {
 733         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 734         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 735         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 736         { }
 737 };
 738
 739 static struct hda_verb alc_gpio3_init_verbs[] = {
 740         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 741         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 742         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 743         { }
 744 };
 745
 746 static void alc_sku_automute(struct hda_codec *codec)
 747 {
 748         struct alc_spec *spec = codec->spec;
 749         unsigned int present;
 750         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 751         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 752
 753         /* need to execute and sync at first */
 754         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 755         present = snd_hda_codec_read(codec, hp_nid, 0,
 756                                      AC_VERB_GET_PIN_SENSE, 0);
 757         spec->jack_present = (present & 0x80000000) != 0;
 758         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 759                             spec->jack_present ? 0 : PIN_OUT);
 760 }
 761
 762 /* unsolicited event for HP jack sensing */
 763 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 764 {
 765         if (codec->vendor_id == 0x10ec0880)
 766                 res >>= 28;
 767         else
 768                 res >>= 26;
 769         if (res != ALC880_HP_EVENT)
 770                 return;
 771
 772         alc_sku_automute(codec);
 773 }
 774
 775 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 776  *      31 ~ 16 :       Manufacture ID
 777  *      15 ~ 8  :       SKU ID
 778  *      7  ~ 0  :       Assembly ID
 779  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 780  */
 781 static void alc_subsystem_id(struct hda_codec *codec,
 782                              unsigned int porta, unsigned int porte,
 783                              unsigned int portd)
 784 {
 785         unsigned int ass, tmp, i;
 786         unsigned nid;
 787         struct alc_spec *spec = codec->spec;
 788
 789         ass = codec->subsystem_id & 0xffff;
 790         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
 791                 goto do_sku;
 792
 793         /*
 794          * 31~30        : port conetcivity
 795          * 29~21        : reserve
 796          * 20           : PCBEEP input
 797          * 19~16        : Check sum (15:1)
 798          * 15~1         : Custom
 799          * 0            : override
 800         */
 801         nid = 0x1d;
 802         if (codec->vendor_id == 0x10ec0260)
 803                 nid = 0x17;
 804         ass = snd_hda_codec_read(codec, nid, 0,
 805                                  AC_VERB_GET_CONFIG_DEFAULT, 0);
 806         if (!(ass & 1) && !(ass & 0x100000))
 807                 return;
 808         if ((ass >> 30) != 1)   /* no physical connection */
 809                 return;
 810
 811         /* check sum */
 812         tmp = 0;
 813         for (i = 1; i < 16; i++) {
 814                 if ((ass >> i) & 1)
 815                         tmp++;
 816         }
 817         if (((ass >> 16) & 0xf) != tmp)
 818                 return;
 819 do_sku:
 820         /*
 821          * 0 : override
 822          * 1 :  Swap Jack
 823          * 2 : 0 --> Desktop, 1 --> Laptop
 824          * 3~5 : External Amplifier control
 825          * 7~6 : Reserved
 826         */
 827         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 828         switch (tmp) {
 829         case 1:
 830                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 831                 break;
 832         case 3:
 833                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 834                 break;
 835         case 7:
 836                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 837                 break;
 838         case 5: /* set EAPD output high */
 839                 switch (codec->vendor_id) {
 840                 case 0x10ec0260:
 841                         snd_hda_codec_write(codec, 0x0f, 0,
 842                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 843                         snd_hda_codec_write(codec, 0x10, 0,
 844                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 845                         break;
 846                 case 0x10ec0262:
 847                 case 0x10ec0267:
 848                 case 0x10ec0268:
 849                 case 0x10ec0269:
 850                 case 0x10ec0862:
 851                 case 0x10ec0662:
 852                         snd_hda_codec_write(codec, 0x14, 0,
 853                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 854                         snd_hda_codec_write(codec, 0x15, 0,
 855                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 856                         break;
 857                 }
 858                 switch (codec->vendor_id) {
 859                 case 0x10ec0260:
 860                         snd_hda_codec_write(codec, 0x1a, 0,
 861                                             AC_VERB_SET_COEF_INDEX, 7);
 862                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 863                                                  AC_VERB_GET_PROC_COEF, 0);
 864                         snd_hda_codec_write(codec, 0x1a, 0,
 865                                             AC_VERB_SET_COEF_INDEX, 7);
 866                         snd_hda_codec_write(codec, 0x1a, 0,
 867                                             AC_VERB_SET_PROC_COEF,
 868                                             tmp | 0x2010);
 869                         break;
 870                 case 0x10ec0262:
 871                 case 0x10ec0880:
 872                 case 0x10ec0882:
 873                 case 0x10ec0883:
 874                 case 0x10ec0885:
 875                 case 0x10ec0888:
 876                         snd_hda_codec_write(codec, 0x20, 0,
 877                                             AC_VERB_SET_COEF_INDEX, 7);
 878                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 879                                                  AC_VERB_GET_PROC_COEF, 0);
 880                         snd_hda_codec_write(codec, 0x20, 0,
 881                                             AC_VERB_SET_COEF_INDEX, 7);
 882                         snd_hda_codec_write(codec, 0x20, 0,
 883                                             AC_VERB_SET_PROC_COEF,
 884                                             tmp | 0x2010);
 885                         break;
 886                 case 0x10ec0267:
 887                 case 0x10ec0268:
 888                         snd_hda_codec_write(codec, 0x20, 0,
 889                                             AC_VERB_SET_COEF_INDEX, 7);
 890                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 891                                                  AC_VERB_GET_PROC_COEF, 0);
 892                         snd_hda_codec_write(codec, 0x20, 0,
 893                                             AC_VERB_SET_COEF_INDEX, 7);
 894                         snd_hda_codec_write(codec, 0x20, 0,
 895                                             AC_VERB_SET_PROC_COEF,
 896                                             tmp | 0x3000);
 897                         break;
 898                 }
 899         default:
 900                 break;
 901         }
 902
 903         /* is laptop or Desktop and enable the function "Mute internal speaker
 904          * when the external headphone out jack is plugged"
 905          */
 906         if (!(ass & 0x8000))
 907                 return;
 908         /*
 909          * 10~8 : Jack location
 910          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 911          * 14~13: Resvered
 912          * 15   : 1 --> enable the function "Mute internal speaker
 913          *              when the external headphone out jack is plugged"
 914          */
 915         if (!spec->autocfg.speaker_pins[0]) {
 916                 if (spec->autocfg.line_out_pins[0])
 917                         spec->autocfg.speaker_pins[0] =
 918                                 spec->autocfg.line_out_pins[0];
 919                 else
 920                         return;
 921         }
 922
 923         if (!spec->autocfg.hp_pins[0]) {
 924                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 925                 if (tmp == 0)
 926                         spec->autocfg.hp_pins[0] = porta;
 927                 else if (tmp == 1)
 928                         spec->autocfg.hp_pins[0] = porte;
 929                 else if (tmp == 2)
 930                         spec->autocfg.hp_pins[0] = portd;
 931                 else
 932                         return;
 933         }
 934
 935         snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
 936                             AC_VERB_SET_UNSOLICITED_ENABLE,
 937                             AC_USRSP_EN | ALC880_HP_EVENT);
 938         spec->unsol_event = alc_sku_unsol_event;
 939         spec->init_hook = alc_sku_automute;
 940 }
 941
 942 /*
 943  * Fix-up pin default configurations
 944  */
 945
 946 struct alc_pincfg {
 947         hda_nid_t nid;
 948         u32 val;
 949 };
 950
 951 static void alc_fix_pincfg(struct hda_codec *codec,
 952                            const struct snd_pci_quirk *quirk,
 953                            const struct alc_pincfg **pinfix)
 954 {
 955         const struct alc_pincfg *cfg;
 956
 957         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
 958         if (!quirk)
 959                 return;
 960
 961         cfg = pinfix[quirk->value];
 962         for (; cfg->nid; cfg++) {
 963                 int i;
 964                 u32 val = cfg->val;
 965                 for (i = 0; i < 4; i++) {
 966                         snd_hda_codec_write(codec, cfg->nid, 0,
 967                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
 968                                     val & 0xff);
 969                         val >>= 8;
 970                 }
 971         }
 972 }
 973
 974 /*
 975  * ALC880 3-stack model
 976  *
 977  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
 978  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
 979  *                 F-Mic = 0x1b, HP = 0x19
 980  */
 981
 982 static hda_nid_t alc880_dac_nids[4] = {
 983         /* front, rear, clfe, rear_surr */
 984         0x02, 0x05, 0x04, 0x03
 985 };
 986
 987 static hda_nid_t alc880_adc_nids[3] = {
 988         /* ADC0-2 */
 989         0x07, 0x08, 0x09,
 990 };
 991
 992 /* The datasheet says the node 0x07 is connected from inputs,
 993  * but it shows zero connection in the real implementation on some devices.
 994  * Note: this is a 915GAV bug, fixed on 915GLV
 995  */
 996 static hda_nid_t alc880_adc_nids_alt[2] = {
 997         /* ADC1-2 */
 998         0x08, 0x09,
 999 };
1000
1001 #define ALC880_DIGOUT_NID       0x06
1002 #define ALC880_DIGIN_NID        0x0a
1003
1004 static struct hda_input_mux alc880_capture_source = {
1005         .num_items = 4,
1006         .items = {
1007                 { "Mic", 0x0 },
1008                 { "Front Mic", 0x3 },
1009                 { "Line", 0x2 },
1010                 { "CD", 0x4 },
1011         },
1012 };
1013
1014 /* channel source setting (2/6 channel selection for 3-stack) */
1015 /* 2ch mode */
1016 static struct hda_verb alc880_threestack_ch2_init[] = {
1017         /* set line-in to input, mute it */
1018         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1019         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1020         /* set mic-in to input vref 80%, mute it */
1021         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1022         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1023         { } /* end */
1024 };
1025
1026 /* 6ch mode */
1027 static struct hda_verb alc880_threestack_ch6_init[] = {
1028         /* set line-in to output, unmute it */
1029         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1030         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1031         /* set mic-in to output, unmute it */
1032         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1033         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1034         { } /* end */
1035 };
1036
1037 static struct hda_channel_mode alc880_threestack_modes[2] = {
1038         { 2, alc880_threestack_ch2_init },
1039         { 6, alc880_threestack_ch6_init },
1040 };
1041
1042 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1043         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1044         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1045         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1046         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1047         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1048         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1049         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1050         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1051         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1052         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1053         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1054         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1055         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1056         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1057         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1058         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1059         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1060         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1061         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1062         {
1063                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1064                 .name = "Channel Mode",
1065                 .info = alc_ch_mode_info,
1066                 .get = alc_ch_mode_get,
1067                 .put = alc_ch_mode_put,
1068         },
1069         { } /* end */
1070 };
1071
1072 /* capture mixer elements */
1073 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1074         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1075         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1076         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1077         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1078         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1079         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1080         {
1081                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1082                 /* The multiple "Capture Source" controls confuse alsamixer
1083                  * So call somewhat different..
1084                  */
1085                 /* .name = "Capture Source", */
1086                 .name = "Input Source",
1087                 .count = 3,
1088                 .info = alc_mux_enum_info,
1089                 .get = alc_mux_enum_get,
1090                 .put = alc_mux_enum_put,
1091         },
1092         { } /* end */
1093 };
1094
1095 /* capture mixer elements (in case NID 0x07 not available) */
1096 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1097         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1098         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1099         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1100         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1101         {
1102                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1103                 /* The multiple "Capture Source" controls confuse alsamixer
1104                  * So call somewhat different..
1105                  */
1106                 /* .name = "Capture Source", */
1107                 .name = "Input Source",
1108                 .count = 2,
1109                 .info = alc_mux_enum_info,
1110                 .get = alc_mux_enum_get,
1111                 .put = alc_mux_enum_put,
1112         },
1113         { } /* end */
1114 };
1115
1116
1117
1118 /*
1119  * ALC880 5-stack model
1120  *
1121  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1122  *      Side = 0x02 (0xd)
1123  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1124  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1125  */
1126
1127 /* additional mixers to alc880_three_stack_mixer */
1128 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1129         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1130         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1131         { } /* end */
1132 };
1133
1134 /* channel source setting (6/8 channel selection for 5-stack) */
1135 /* 6ch mode */
1136 static struct hda_verb alc880_fivestack_ch6_init[] = {
1137         /* set line-in to input, mute it */
1138         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1139         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1140         { } /* end */
1141 };
1142
1143 /* 8ch mode */
1144 static struct hda_verb alc880_fivestack_ch8_init[] = {
1145         /* set line-in to output, unmute it */
1146         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1147         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1148         { } /* end */
1149 };
1150
1151 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1152         { 6, alc880_fivestack_ch6_init },
1153         { 8, alc880_fivestack_ch8_init },
1154 };
1155
1156
1157 /*
1158  * ALC880 6-stack model
1159  *
1160  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1161  *      Side = 0x05 (0x0f)
1162  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1163  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1164  */
1165
1166 static hda_nid_t alc880_6st_dac_nids[4] = {
1167         /* front, rear, clfe, rear_surr */
1168         0x02, 0x03, 0x04, 0x05
1169 };
1170
1171 static struct hda_input_mux alc880_6stack_capture_source = {
1172         .num_items = 4,
1173         .items = {
1174                 { "Mic", 0x0 },
1175                 { "Front Mic", 0x1 },
1176                 { "Line", 0x2 },
1177                 { "CD", 0x4 },
1178         },
1179 };
1180
1181 /* fixed 8-channels */
1182 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1183         { 8, NULL },
1184 };
1185
1186 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1187         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1188         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1189         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1190         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1191         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1192         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1193         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1194         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1195         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1196         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1197         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1198         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1199         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1200         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1201         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1202         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1203         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1204         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1205         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1206         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1207         {
1208                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1209                 .name = "Channel Mode",
1210                 .info = alc_ch_mode_info,
1211                 .get = alc_ch_mode_get,
1212                 .put = alc_ch_mode_put,
1213         },
1214         { } /* end */
1215 };
1216
1217
1218 /*
1219  * ALC880 W810 model
1220  *
1221  * W810 has rear IO for:
1222  * Front (DAC 02)
1223  * Surround (DAC 03)
1224  * Center/LFE (DAC 04)
1225  * Digital out (06)
1226  *
1227  * The system also has a pair of internal speakers, and a headphone jack.
1228  * These are both connected to Line2 on the codec, hence to DAC 02.
1229  *
1230  * There is a variable resistor to control the speaker or headphone
1231  * volume. This is a hardware-only device without a software API.
1232  *
1233  * Plugging headphones in will disable the internal speakers. This is
1234  * implemented in hardware, not via the driver using jack sense. In
1235  * a similar fashion, plugging into the rear socket marked "front" will
1236  * disable both the speakers and headphones.
1237  *
1238  * For input, there's a microphone jack, and an "audio in" jack.
1239  * These may not do anything useful with this driver yet, because I
1240  * haven't setup any initialization verbs for these yet...
1241  */
1242
1243 static hda_nid_t alc880_w810_dac_nids[3] = {
1244         /* front, rear/surround, clfe */
1245         0x02, 0x03, 0x04
1246 };
1247
1248 /* fixed 6 channels */
1249 static struct hda_channel_mode alc880_w810_modes[1] = {
1250         { 6, NULL }
1251 };
1252
1253 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1254 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1255         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1256         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1257         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1258         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1259         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1260         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1261         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1262         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1263         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1264         { } /* end */
1265 };
1266
1267
1268 /*
1269  * Z710V model
1270  *
1271  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1272  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1273  *                 Line = 0x1a
1274  */
1275
1276 static hda_nid_t alc880_z71v_dac_nids[1] = {
1277         0x02
1278 };
1279 #define ALC880_Z71V_HP_DAC      0x03
1280
1281 /* fixed 2 channels */
1282 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1283         { 2, NULL }
1284 };
1285
1286 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1287         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1288         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1289         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1290         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1291         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1292         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1293         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1294         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1295         { } /* end */
1296 };
1297
1298
1299 /*
1300  * ALC880 F1734 model
1301  *
1302  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1303  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1304  */
1305
1306 static hda_nid_t alc880_f1734_dac_nids[1] = {
1307         0x03
1308 };
1309 #define ALC880_F1734_HP_DAC     0x02
1310
1311 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1312         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1313         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1314         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1315         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1316         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1317         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1318         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1319         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1320         { } /* end */
1321 };
1322
1323 static struct hda_input_mux alc880_f1734_capture_source = {
1324         .num_items = 2,
1325         .items = {
1326                 { "Mic", 0x1 },
1327                 { "CD", 0x4 },
1328         },
1329 };
1330
1331
1332 /*
1333  * ALC880 ASUS model
1334  *
1335  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1336  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1337  *  Mic = 0x18, Line = 0x1a
1338  */
1339
1340 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1341 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1342
1343 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1344         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1345         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1346         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1347         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1348         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1349         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1350         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1351         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1352         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1353         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1354         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1355         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1356         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1357         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1358         {
1359                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1360                 .name = "Channel Mode",
1361                 .info = alc_ch_mode_info,
1362                 .get = alc_ch_mode_get,
1363                 .put = alc_ch_mode_put,
1364         },
1365         { } /* end */
1366 };
1367
1368 /*
1369  * ALC880 ASUS W1V model
1370  *
1371  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1372  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1373  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1374  */
1375
1376 /* additional mixers to alc880_asus_mixer */
1377 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1378         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1379         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1380         { } /* end */
1381 };
1382
1383 /* additional mixers to alc880_asus_mixer */
1384 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1385         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1386         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1387         { } /* end */
1388 };
1389
1390 /* TCL S700 */
1391 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1392         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1393         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1394         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1395         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1396         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1397         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1398         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1399         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1400         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1401         {
1402                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1403                 /* The multiple "Capture Source" controls confuse alsamixer
1404                  * So call somewhat different..
1405                  */
1406                 /* .name = "Capture Source", */
1407                 .name = "Input Source",
1408                 .count = 1,
1409                 .info = alc_mux_enum_info,
1410                 .get = alc_mux_enum_get,
1411                 .put = alc_mux_enum_put,
1412         },
1413         { } /* end */
1414 };
1415
1416 /* Uniwill */
1417 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1418         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1419         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1420         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1421         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1422         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1423         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1424         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1425         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1426         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1427         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1428         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1429         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1430         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1431         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1432         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1433         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1434         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1435         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1436         {
1437                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1438                 .name = "Channel Mode",
1439                 .info = alc_ch_mode_info,
1440                 .get = alc_ch_mode_get,
1441                 .put = alc_ch_mode_put,
1442         },
1443         { } /* end */
1444 };
1445
1446 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1447         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1448         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1449         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1450         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1451         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1452         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1453         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1454         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1455         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1456         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1457         { } /* end */
1458 };
1459
1460 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1461         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1462         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1463         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1464         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1465         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1466         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1467         { } /* end */
1468 };
1469
1470 /*
1471  * virtual master controls
1472  */
1473
1474 /*
1475  * slave controls for virtual master
1476  */
1477 static const char *alc_slave_vols[] = {
1478         "Front Playback Volume",
1479         "Surround Playback Volume",
1480         "Center Playback Volume",
1481         "LFE Playback Volume",
1482         "Side Playback Volume",
1483         "Headphone Playback Volume",
1484         "Speaker Playback Volume",
1485         "Mono Playback Volume",
1486         "Line-Out Playback Volume",
1487         NULL,
1488 };
1489
1490 static const char *alc_slave_sws[] = {
1491         "Front Playback Switch",
1492         "Surround Playback Switch",
1493         "Center Playback Switch",
1494         "LFE Playback Switch",
1495         "Side Playback Switch",
1496         "Headphone Playback Switch",
1497         "Speaker Playback Switch",
1498         "Mono Playback Switch",
1499         "IEC958 Playback Switch",
1500         NULL,
1501 };
1502
1503 /*
1504  * build control elements
1505  */
1506 static int alc_build_controls(struct hda_codec *codec)
1507 {
1508         struct alc_spec *spec = codec->spec;
1509         int err;
1510         int i;
1511
1512         for (i = 0; i < spec->num_mixers; i++) {
1513                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1514                 if (err < 0)
1515                         return err;
1516         }
1517
1518         if (spec->multiout.dig_out_nid) {
1519                 err = snd_hda_create_spdif_out_ctls(codec,
1520                                                     spec->multiout.dig_out_nid);
1521                 if (err < 0)
1522                         return err;
1523                 err = snd_hda_create_spdif_share_sw(codec,
1524                                                     &spec->multiout);
1525                 if (err < 0)
1526                         return err;
1527                 spec->multiout.share_spdif = 1;
1528         }
1529         if (spec->dig_in_nid) {
1530                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1531                 if (err < 0)
1532                         return err;
1533         }
1534
1535         /* if we have no master control, let's create it */
1536         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1537                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1538                                         HDA_OUTPUT, spec->vmaster_tlv);
1539                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1540                                           spec->vmaster_tlv, alc_slave_vols);
1541                 if (err < 0)
1542                         return err;
1543         }
1544         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1545                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1546                                           NULL, alc_slave_sws);
1547                 if (err < 0)
1548                         return err;
1549         }
1550
1551         return 0;
1552 }
1553
1554
1555 /*
1556  * initialize the codec volumes, etc
1557  */
1558
1559 /*
1560  * generic initialization of ADC, input mixers and output mixers
1561  */
1562 static struct hda_verb alc880_volume_init_verbs[] = {
1563         /*
1564          * Unmute ADC0-2 and set the default input to mic-in
1565          */
1566         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1567         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1568         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1569         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1570         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1571         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1572
1573         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1574          * mixer widget
1575          * Note: PASD motherboards uses the Line In 2 as the input for front
1576          * panel mic (mic 2)
1577          */
1578         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1579         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1580         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1581         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1582         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1583         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1584         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1585         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1586
1587         /*
1588          * Set up output mixers (0x0c - 0x0f)
1589          */
1590         /* set vol=0 to output mixers */
1591         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1592         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1593         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1594         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1595         /* set up input amps for analog loopback */
1596         /* Amp Indices: DAC = 0, mixer = 1 */
1597         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1599         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1600         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1601         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1602         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1603         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1604         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1605
1606         { }
1607 };
1608
1609 /*
1610  * 3-stack pin configuration:
1611  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1612  */
1613 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1614         /*
1615          * preset connection lists of input pins
1616          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1617          */
1618         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1619         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1620         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1621
1622         /*
1623          * Set pin mode and muting
1624          */
1625         /* set front pin widgets 0x14 for output */
1626         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1627         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1628         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1629         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1630         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1631         /* Mic2 (as headphone out) for HP output */
1632         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1633         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1634         /* Line In pin widget for input */
1635         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1636         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1637         /* Line2 (as front mic) pin widget for input and vref at 80% */
1638         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1639         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1640         /* CD pin widget for input */
1641         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1642
1643         { }
1644 };
1645
1646 /*
1647  * 5-stack pin configuration:
1648  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1649  * line-in/side = 0x1a, f-mic = 0x1b
1650  */
1651 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1652         /*
1653          * preset connection lists of input pins
1654          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1655          */
1656         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1657         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1658
1659         /*
1660          * Set pin mode and muting
1661          */
1662         /* set pin widgets 0x14-0x17 for output */
1663         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1664         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1665         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1666         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1667         /* unmute pins for output (no gain on this amp) */
1668         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1669         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1670         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1671         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1672
1673         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1674         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1675         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1676         /* Mic2 (as headphone out) for HP output */
1677         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1678         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1679         /* Line In pin widget for input */
1680         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1681         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1682         /* Line2 (as front mic) pin widget for input and vref at 80% */
1683         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1684         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1685         /* CD pin widget for input */
1686         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1687
1688         { }
1689 };
1690
1691 /*
1692  * W810 pin configuration:
1693  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1694  */
1695 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1696         /* hphone/speaker input selector: front DAC */
1697         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1698
1699         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1700         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1701         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1702         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1703         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1704         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1705
1706         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1707         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1708
1709         { }
1710 };
1711
1712 /*
1713  * Z71V pin configuration:
1714  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1715  */
1716 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1717         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1718         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1719         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1720         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1721
1722         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1723         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1724         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1725         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1726
1727         { }
1728 };
1729
1730 /*
1731  * 6-stack pin configuration:
1732  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1733  * f-mic = 0x19, line = 0x1a, HP = 0x1b
1734  */
1735 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1736         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1737
1738         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1739         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1740         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1741         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1742         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1743         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1744         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1745         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1746
1747         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1748         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1749         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1750         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1751         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1752         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1753         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1754         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1755         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1756
1757         { }
1758 };
1759
1760 /*
1761  * Uniwill pin configuration:
1762  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1763  * line = 0x1a
1764  */
1765 static struct hda_verb alc880_uniwill_init_verbs[] = {
1766         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1767
1768         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1769         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1770         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1771         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1772         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1773         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1774         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1775         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1776         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1777         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1778         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1779         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1780         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1781         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1782
1783         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1784         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1785         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1786         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1787         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1788         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1789         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1790         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1791         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1792
1793         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1794         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1795
1796         { }
1797 };
1798
1799 /*
1800 * Uniwill P53
1801 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1802  */
1803 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1804         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1805
1806         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1807         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1808         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1809         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1810         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1811         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1812         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1813         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1814         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1815         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1816         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1817         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1818
1819         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1820         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1821         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1822         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1823         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1824         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1825
1826         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1827         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1828
1829         { }
1830 };
1831
1832 static struct hda_verb alc880_beep_init_verbs[] = {
1833         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1834         { }
1835 };
1836
1837 /* toggle speaker-output according to the hp-jack state */
1838 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1839 {
1840         unsigned int present;
1841         unsigned char bits;
1842
1843         present = snd_hda_codec_read(codec, 0x14, 0,
1844                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1845         bits = present ? HDA_AMP_MUTE : 0;
1846         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1847                                  HDA_AMP_MUTE, bits);
1848         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1849                                  HDA_AMP_MUTE, bits);
1850 }
1851
1852 /* auto-toggle front mic */
1853 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1854 {
1855         unsigned int present;
1856         unsigned char bits;
1857
1858         present = snd_hda_codec_read(codec, 0x18, 0,
1859                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1860         bits = present ? HDA_AMP_MUTE : 0;
1861         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1862 }
1863
1864 static void alc880_uniwill_automute(struct hda_codec *codec)
1865 {
1866         alc880_uniwill_hp_automute(codec);
1867         alc880_uniwill_mic_automute(codec);
1868 }
1869
1870 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
1871                                        unsigned int res)
1872 {
1873         /* Looks like the unsol event is incompatible with the standard
1874          * definition.  4bit tag is placed at 28 bit!
1875          */
1876         switch (res >> 28) {
1877         case ALC880_HP_EVENT:
1878                 alc880_uniwill_hp_automute(codec);
1879                 break;
1880         case ALC880_MIC_EVENT:
1881                 alc880_uniwill_mic_automute(codec);
1882                 break;
1883         }
1884 }
1885
1886 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
1887 {
1888         unsigned int present;
1889         unsigned char bits;
1890
1891         present = snd_hda_codec_read(codec, 0x14, 0,
1892                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1893         bits = present ? HDA_AMP_MUTE : 0;
1894         snd_hda_codec_amp_stereo(codec, 0x15, HDA_INPUT, 0, HDA_AMP_MUTE, bits);
1895 }
1896
1897 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
1898 {
1899         unsigned int present;
1900
1901         present = snd_hda_codec_read(codec, 0x21, 0,
1902                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
1903         present &= HDA_AMP_VOLMASK;
1904         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
1905                                  HDA_AMP_VOLMASK, present);
1906         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
1907                                  HDA_AMP_VOLMASK, present);
1908 }
1909
1910 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
1911                                            unsigned int res)
1912 {
1913         /* Looks like the unsol event is incompatible with the standard
1914          * definition.  4bit tag is placed at 28 bit!
1915          */
1916         if ((res >> 28) == ALC880_HP_EVENT)
1917                 alc880_uniwill_p53_hp_automute(codec);
1918         if ((res >> 28) == ALC880_DCVOL_EVENT)
1919                 alc880_uniwill_p53_dcvol_automute(codec);
1920 }
1921
1922 /*
1923  * F1734 pin configuration:
1924  * HP = 0x14, speaker-out = 0x15, mic = 0x18
1925  */
1926 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
1927         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1928         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1929         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1930         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1931
1932         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1933         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1934         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1935         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1936
1937         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1938         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1939         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1940         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1941         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1942         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1943         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1944         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1945         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1946
1947         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
1948         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
1949
1950         { }
1951 };
1952
1953 /*
1954  * ASUS pin configuration:
1955  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
1956  */
1957 static struct hda_verb alc880_pin_asus_init_verbs[] = {
1958         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1959         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1960         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1961         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1962
1963         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1964         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1965         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1966         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1967         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1968         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1969         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1970         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1971
1972         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1973         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1974         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1975         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1976         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1977         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1978         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1979         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1980         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1981
1982         { }
1983 };
1984
1985 /* Enable GPIO mask and set output */
1986 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
1987 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
1988
1989 /* Clevo m520g init */
1990 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
1991         /* headphone output */
1992         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1993         /* line-out */
1994         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1995         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1996         /* Line-in */
1997         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1998         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1999         /* CD */
2000         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2001         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2002         /* Mic1 (rear panel) */
2003         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2004         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2005         /* Mic2 (front panel) */
2006         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2007         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2008         /* headphone */
2009         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2010         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2011         /* change to EAPD mode */
2012         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2013         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2014
2015         { }
2016 };
2017
2018 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2019         /* change to EAPD mode */
2020         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2021         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2022
2023         /* Headphone output */
2024         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2025         /* Front output*/
2026         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2027         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2028
2029         /* Line In pin widget for input */
2030         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2031         /* CD pin widget for input */
2032         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2033         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2034         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2035
2036         /* change to EAPD mode */
2037         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2038         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2039
2040         { }
2041 };
2042
2043 /*
2044  * LG m1 express dual
2045  *
2046  * Pin assignment:
2047  *   Rear Line-In/Out (blue): 0x14
2048  *   Build-in Mic-In: 0x15
2049  *   Speaker-out: 0x17
2050  *   HP-Out (green): 0x1b
2051  *   Mic-In/Out (red): 0x19
2052  *   SPDIF-Out: 0x1e
2053  */
2054
2055 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2056 static hda_nid_t alc880_lg_dac_nids[3] = {
2057         0x05, 0x02, 0x03
2058 };
2059
2060 /* seems analog CD is not working */
2061 static struct hda_input_mux alc880_lg_capture_source = {
2062         .num_items = 3,
2063         .items = {
2064                 { "Mic", 0x1 },
2065                 { "Line", 0x5 },
2066                 { "Internal Mic", 0x6 },
2067         },
2068 };
2069
2070 /* 2,4,6 channel modes */
2071 static struct hda_verb alc880_lg_ch2_init[] = {
2072         /* set line-in and mic-in to input */
2073         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2074         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2075         { }
2076 };
2077
2078 static struct hda_verb alc880_lg_ch4_init[] = {
2079         /* set line-in to out and mic-in to input */
2080         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2081         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2082         { }
2083 };
2084
2085 static struct hda_verb alc880_lg_ch6_init[] = {
2086         /* set line-in and mic-in to output */
2087         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2088         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2089         { }
2090 };
2091
2092 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2093         { 2, alc880_lg_ch2_init },
2094         { 4, alc880_lg_ch4_init },
2095         { 6, alc880_lg_ch6_init },
2096 };
2097
2098 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2099         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2100         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2101         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2102         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2103         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2104         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2105         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2106         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2109         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2110         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2111         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2112         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2113         {
2114                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2115                 .name = "Channel Mode",
2116                 .info = alc_ch_mode_info,
2117                 .get = alc_ch_mode_get,
2118                 .put = alc_ch_mode_put,
2119         },
2120         { } /* end */
2121 };
2122
2123 static struct hda_verb alc880_lg_init_verbs[] = {
2124         /* set capture source to mic-in */
2125         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2126         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2127         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2128         /* mute all amp mixer inputs */
2129         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2130         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2131         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2132         /* line-in to input */
2133         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2134         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2135         /* built-in mic */
2136         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2137         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2138         /* speaker-out */
2139         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2140         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2141         /* mic-in to input */
2142         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2143         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2144         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2145         /* HP-out */
2146         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2147         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2148         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2149         /* jack sense */
2150         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2151         { }
2152 };
2153
2154 /* toggle speaker-output according to the hp-jack state */
2155 static void alc880_lg_automute(struct hda_codec *codec)
2156 {
2157         unsigned int present;
2158         unsigned char bits;
2159
2160         present = snd_hda_codec_read(codec, 0x1b, 0,
2161                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2162         bits = present ? HDA_AMP_MUTE : 0;
2163         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2164                                  HDA_AMP_MUTE, bits);
2165 }
2166
2167 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2168 {
2169         /* Looks like the unsol event is incompatible with the standard
2170          * definition.  4bit tag is placed at 28 bit!
2171          */
2172         if ((res >> 28) == 0x01)
2173                 alc880_lg_automute(codec);
2174 }
2175
2176 /*
2177  * LG LW20
2178  *
2179  * Pin assignment:
2180  *   Speaker-out: 0x14
2181  *   Mic-In: 0x18
2182  *   Built-in Mic-In: 0x19
2183  *   Line-In: 0x1b
2184  *   HP-Out: 0x1a
2185  *   SPDIF-Out: 0x1e
2186  */
2187
2188 static struct hda_input_mux alc880_lg_lw_capture_source = {
2189         .num_items = 3,
2190         .items = {
2191                 { "Mic", 0x0 },
2192                 { "Internal Mic", 0x1 },
2193                 { "Line In", 0x2 },
2194         },
2195 };
2196
2197 #define alc880_lg_lw_modes alc880_threestack_modes
2198
2199 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2200         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2201         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2202         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2203         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2204         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2205         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2206         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2207         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2208         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2209         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2210         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2211         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2212         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2213         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2214         {
2215                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2216                 .name = "Channel Mode",
2217                 .info = alc_ch_mode_info,
2218                 .get = alc_ch_mode_get,
2219                 .put = alc_ch_mode_put,
2220         },
2221         { } /* end */
2222 };
2223
2224 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2225         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2226         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2227         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2228
2229         /* set capture source to mic-in */
2230         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2231         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2232         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2233         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2234         /* speaker-out */
2235         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2236         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2237         /* HP-out */
2238         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2239         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2240         /* mic-in to input */
2241         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2242         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2243         /* built-in mic */
2244         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2245         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2246         /* jack sense */
2247         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2248         { }
2249 };
2250
2251 /* toggle speaker-output according to the hp-jack state */
2252 static void alc880_lg_lw_automute(struct hda_codec *codec)
2253 {
2254         unsigned int present;
2255         unsigned char bits;
2256
2257         present = snd_hda_codec_read(codec, 0x1b, 0,
2258                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2259         bits = present ? HDA_AMP_MUTE : 0;
2260         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2261                                  HDA_AMP_MUTE, bits);
2262 }
2263
2264 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2265 {
2266         /* Looks like the unsol event is incompatible with the standard
2267          * definition.  4bit tag is placed at 28 bit!
2268          */
2269         if ((res >> 28) == 0x01)
2270                 alc880_lg_lw_automute(codec);
2271 }
2272
2273 #ifdef CONFIG_SND_HDA_POWER_SAVE
2274 static struct hda_amp_list alc880_loopbacks[] = {
2275         { 0x0b, HDA_INPUT, 0 },
2276         { 0x0b, HDA_INPUT, 1 },
2277         { 0x0b, HDA_INPUT, 2 },
2278         { 0x0b, HDA_INPUT, 3 },
2279         { 0x0b, HDA_INPUT, 4 },
2280         { } /* end */
2281 };
2282
2283 static struct hda_amp_list alc880_lg_loopbacks[] = {
2284         { 0x0b, HDA_INPUT, 1 },
2285         { 0x0b, HDA_INPUT, 6 },
2286         { 0x0b, HDA_INPUT, 7 },
2287         { } /* end */
2288 };
2289 #endif
2290
2291 /*
2292  * Common callbacks
2293  */
2294
2295 static int alc_init(struct hda_codec *codec)
2296 {
2297         struct alc_spec *spec = codec->spec;
2298         unsigned int i;
2299
2300         for (i = 0; i < spec->num_init_verbs; i++)
2301                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2302
2303         if (spec->init_hook)
2304                 spec->init_hook(codec);
2305
2306         return 0;
2307 }
2308
2309 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2310 {
2311         struct alc_spec *spec = codec->spec;
2312
2313         if (spec->unsol_event)
2314                 spec->unsol_event(codec, res);
2315 }
2316
2317 #ifdef CONFIG_SND_HDA_POWER_SAVE
2318 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2319 {
2320         struct alc_spec *spec = codec->spec;
2321         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2322 }
2323 #endif
2324
2325 /*
2326  * Analog playback callbacks
2327  */
2328 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2329                                     struct hda_codec *codec,
2330                                     struct snd_pcm_substream *substream)
2331 {
2332         struct alc_spec *spec = codec->spec;
2333         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2334                                              hinfo);
2335 }
2336
2337 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2338                                        struct hda_codec *codec,
2339                                        unsigned int stream_tag,
2340                                        unsigned int format,
2341                                        struct snd_pcm_substream *substream)
2342 {
2343         struct alc_spec *spec = codec->spec;
2344         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2345                                                 stream_tag, format, substream);
2346 }
2347
2348 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2349                                        struct hda_codec *codec,
2350                                        struct snd_pcm_substream *substream)
2351 {
2352         struct alc_spec *spec = codec->spec;
2353         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2354 }
2355
2356 /*
2357  * Digital out
2358  */
2359 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2360                                         struct hda_codec *codec,
2361                                         struct snd_pcm_substream *substream)
2362 {
2363         struct alc_spec *spec = codec->spec;
2364         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2365 }
2366
2367 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2368                                            struct hda_codec *codec,
2369                                            unsigned int stream_tag,
2370                                            unsigned int format,
2371                                            struct snd_pcm_substream *substream)
2372 {
2373         struct alc_spec *spec = codec->spec;
2374         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2375                                              stream_tag, format, substream);
2376 }
2377
2378 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2379                                          struct hda_codec *codec,
2380                                          struct snd_pcm_substream *substream)
2381 {
2382         struct alc_spec *spec = codec->spec;
2383         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2384 }
2385
2386 /*
2387  * Analog capture
2388  */
2389 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2390                                       struct hda_codec *codec,
2391                                       unsigned int stream_tag,
2392                                       unsigned int format,
2393                                       struct snd_pcm_substream *substream)
2394 {
2395         struct alc_spec *spec = codec->spec;
2396
2397         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2398                                    stream_tag, 0, format);
2399         return 0;
2400 }
2401
2402 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2403                                       struct hda_codec *codec,
2404                                       struct snd_pcm_substream *substream)
2405 {
2406         struct alc_spec *spec = codec->spec;
2407
2408         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2409                                    0, 0, 0);
2410         return 0;
2411 }
2412
2413
2414 /*
2415  */
2416 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2417         .substreams = 1,
2418         .channels_min = 2,
2419         .channels_max = 8,
2420         /* NID is set in alc_build_pcms */
2421         .ops = {
2422                 .open = alc880_playback_pcm_open,
2423                 .prepare = alc880_playback_pcm_prepare,
2424                 .cleanup = alc880_playback_pcm_cleanup
2425         },
2426 };
2427
2428 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2429         .substreams = 1,
2430         .channels_min = 2,
2431         .channels_max = 2,
2432         /* NID is set in alc_build_pcms */
2433 };
2434
2435 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2436         .substreams = 1,
2437         .channels_min = 2,
2438         .channels_max = 2,
2439         /* NID is set in alc_build_pcms */
2440 };
2441
2442 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2443         .substreams = 2, /* can be overridden */
2444         .channels_min = 2,
2445         .channels_max = 2,
2446         /* NID is set in alc_build_pcms */
2447         .ops = {
2448                 .prepare = alc880_alt_capture_pcm_prepare,
2449                 .cleanup = alc880_alt_capture_pcm_cleanup
2450         },
2451 };
2452
2453 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2454         .substreams = 1,
2455         .channels_min = 2,
2456         .channels_max = 2,
2457         /* NID is set in alc_build_pcms */
2458         .ops = {
2459                 .open = alc880_dig_playback_pcm_open,
2460                 .close = alc880_dig_playback_pcm_close,
2461                 .prepare = alc880_dig_playback_pcm_prepare
2462         },
2463 };
2464
2465 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2466         .substreams = 1,
2467         .channels_min = 2,
2468         .channels_max = 2,
2469         /* NID is set in alc_build_pcms */
2470 };
2471
2472 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2473 static struct hda_pcm_stream alc_pcm_null_stream = {
2474         .substreams = 0,
2475         .channels_min = 0,
2476         .channels_max = 0,
2477 };
2478
2479 static int alc_build_pcms(struct hda_codec *codec)
2480 {
2481         struct alc_spec *spec = codec->spec;
2482         struct hda_pcm *info = spec->pcm_rec;
2483         int i;
2484
2485         codec->num_pcms = 1;
2486         codec->pcm_info = info;
2487
2488         info->name = spec->stream_name_analog;
2489         if (spec->stream_analog_playback) {
2490                 snd_assert(spec->multiout.dac_nids, return -EINVAL);
2491                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2492                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2493         }
2494         if (spec->stream_analog_capture) {
2495                 snd_assert(spec->adc_nids, return -EINVAL);
2496                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2497                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2498         }
2499
2500         if (spec->channel_mode) {
2501                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2502                 for (i = 0; i < spec->num_channel_mode; i++) {
2503                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2504                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2505                         }
2506                 }
2507         }
2508
2509         /* SPDIF for stream index #1 */
2510         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2511                 codec->num_pcms = 2;
2512                 info = spec->pcm_rec + 1;
2513                 info->name = spec->stream_name_digital;
2514                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2515                 if (spec->multiout.dig_out_nid &&
2516                     spec->stream_digital_playback) {
2517                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2518                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2519                 }
2520                 if (spec->dig_in_nid &&
2521                     spec->stream_digital_capture) {
2522                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2523                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2524                 }
2525         }
2526
2527         /* If the use of more than one ADC is requested for the current
2528          * model, configure a second analog capture-only PCM.
2529          */
2530         /* Additional Analaog capture for index #2 */
2531         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2532             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2533                 codec->num_pcms = 3;
2534                 info = spec->pcm_rec + 2;
2535                 info->name = spec->stream_name_analog;
2536                 if (spec->alt_dac_nid) {
2537                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2538                                 *spec->stream_analog_alt_playback;
2539                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2540                                 spec->alt_dac_nid;
2541                 } else {
2542                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2543                                 alc_pcm_null_stream;
2544                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2545                 }
2546                 if (spec->num_adc_nids > 1) {
2547                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2548                                 *spec->stream_analog_alt_capture;
2549                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2550                                 spec->adc_nids[1];
2551                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2552                                 spec->num_adc_nids - 1;
2553                 } else {
2554                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2555                                 alc_pcm_null_stream;
2556                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2557                 }
2558         }
2559
2560         return 0;
2561 }
2562
2563 static void alc_free(struct hda_codec *codec)
2564 {
2565         struct alc_spec *spec = codec->spec;
2566         unsigned int i;
2567
2568         if (!spec)
2569                 return;
2570
2571         if (spec->kctl_alloc) {
2572                 for (i = 0; i < spec->num_kctl_used; i++)
2573                         kfree(spec->kctl_alloc[i].name);
2574                 kfree(spec->kctl_alloc);
2575         }
2576         kfree(spec);
2577 }
2578
2579 /*
2580  */
2581 static struct hda_codec_ops alc_patch_ops = {
2582         .build_controls = alc_build_controls,
2583         .build_pcms = alc_build_pcms,
2584         .init = alc_init,
2585         .free = alc_free,
2586         .unsol_event = alc_unsol_event,
2587 #ifdef CONFIG_SND_HDA_POWER_SAVE
2588         .check_power_status = alc_check_power_status,
2589 #endif
2590 };
2591
2592
2593 /*
2594  * Test configuration for debugging
2595  *
2596  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
2597  * enum controls.
2598  */
2599 #ifdef CONFIG_SND_DEBUG
2600 static hda_nid_t alc880_test_dac_nids[4] = {
2601         0x02, 0x03, 0x04, 0x05
2602 };
2603
2604 static struct hda_input_mux alc880_test_capture_source = {
2605         .num_items = 7,
2606         .items = {
2607                 { "In-1", 0x0 },
2608                 { "In-2", 0x1 },
2609                 { "In-3", 0x2 },
2610                 { "In-4", 0x3 },
2611                 { "CD", 0x4 },
2612                 { "Front", 0x5 },
2613                 { "Surround", 0x6 },
2614         },
2615 };
2616
2617 static struct hda_channel_mode alc880_test_modes[4] = {
2618         { 2, NULL },
2619         { 4, NULL },
2620         { 6, NULL },
2621         { 8, NULL },
2622 };
2623
2624 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2625                                  struct snd_ctl_elem_info *uinfo)
2626 {
2627         static char *texts[] = {
2628                 "N/A", "Line Out", "HP Out",
2629                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2630         };
2631         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2632         uinfo->count = 1;
2633         uinfo->value.enumerated.items = 8;
2634         if (uinfo->value.enumerated.item >= 8)
2635                 uinfo->value.enumerated.item = 7;
2636         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2637         return 0;
2638 }
2639
2640 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2641                                 struct snd_ctl_elem_value *ucontrol)
2642 {
2643         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2644         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2645         unsigned int pin_ctl, item = 0;
2646
2647         pin_ctl = snd_hda_codec_read(codec, nid, 0,
2648                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2649         if (pin_ctl & AC_PINCTL_OUT_EN) {
2650                 if (pin_ctl & AC_PINCTL_HP_EN)
2651                         item = 2;
2652                 else
2653                         item = 1;
2654         } else if (pin_ctl & AC_PINCTL_IN_EN) {
2655                 switch (pin_ctl & AC_PINCTL_VREFEN) {
2656                 case AC_PINCTL_VREF_HIZ: item = 3; break;
2657                 case AC_PINCTL_VREF_50:  item = 4; break;
2658                 case AC_PINCTL_VREF_GRD: item = 5; break;
2659                 case AC_PINCTL_VREF_80:  item = 6; break;
2660                 case AC_PINCTL_VREF_100: item = 7; break;
2661                 }
2662         }
2663         ucontrol->value.enumerated.item[0] = item;
2664         return 0;
2665 }
2666
2667 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2668                                 struct snd_ctl_elem_value *ucontrol)
2669 {
2670         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2671         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2672         static unsigned int ctls[] = {
2673                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2674                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2675                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2676                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2677                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2678                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2679         };
2680         unsigned int old_ctl, new_ctl;
2681
2682         old_ctl = snd_hda_codec_read(codec, nid, 0,
2683                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2684         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2685         if (old_ctl != new_ctl) {
2686                 int val;
2687                 snd_hda_codec_write_cache(codec, nid, 0,
2688                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
2689                                           new_ctl);
2690                 val = ucontrol->value.enumerated.item[0] >= 3 ?
2691                         HDA_AMP_MUTE : 0;
2692                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2693                                          HDA_AMP_MUTE, val);
2694                 return 1;
2695         }
2696         return 0;
2697 }
2698
2699 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2700                                  struct snd_ctl_elem_info *uinfo)
2701 {
2702         static char *texts[] = {
2703                 "Front", "Surround", "CLFE", "Side"
2704         };
2705         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2706         uinfo->count = 1;
2707         uinfo->value.enumerated.items = 4;
2708         if (uinfo->value.enumerated.item >= 4)
2709                 uinfo->value.enumerated.item = 3;
2710         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2711         return 0;
2712 }
2713
2714 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2715                                 struct snd_ctl_elem_value *ucontrol)
2716 {
2717         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2718         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2719         unsigned int sel;
2720
2721         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2722         ucontrol->value.enumerated.item[0] = sel & 3;
2723         return 0;
2724 }
2725
2726 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2727                                 struct snd_ctl_elem_value *ucontrol)
2728 {
2729         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2730         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2731         unsigned int sel;
2732
2733         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
2734         if (ucontrol->value.enumerated.item[0] != sel) {
2735                 sel = ucontrol->value.enumerated.item[0] & 3;
2736                 snd_hda_codec_write_cache(codec, nid, 0,
2737                                           AC_VERB_SET_CONNECT_SEL, sel);
2738                 return 1;
2739         }
2740         return 0;
2741 }
2742
2743 #define PIN_CTL_TEST(xname,nid) {                       \
2744                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
2745                         .name = xname,                 \
2746                         .info = alc_test_pin_ctl_info, \
2747                         .get = alc_test_pin_ctl_get,   \
2748                         .put = alc_test_pin_ctl_put,   \
2749                         .private_value = nid           \
2750                         }
2751
2752 #define PIN_SRC_TEST(xname,nid) {                       \
2753                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
2754                         .name = xname,                 \
2755                         .info = alc_test_pin_src_info, \
2756                         .get = alc_test_pin_src_get,   \
2757                         .put = alc_test_pin_src_put,   \
2758                         .private_value = nid           \
2759                         }
2760
2761 static struct snd_kcontrol_new alc880_test_mixer[] = {
2762         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2763         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2764         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2765         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2766         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2767         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2768         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
2769         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2770         PIN_CTL_TEST("Front Pin Mode", 0x14),
2771         PIN_CTL_TEST("Surround Pin Mode", 0x15),
2772         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2773         PIN_CTL_TEST("Side Pin Mode", 0x17),
2774         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2775         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2776         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2777         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2778         PIN_SRC_TEST("In-1 Pin Source", 0x18),
2779         PIN_SRC_TEST("In-2 Pin Source", 0x19),
2780         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2781         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2782         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
2783         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
2784         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
2785         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
2786         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
2787         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
2788         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
2789         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
2790         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
2791         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
2792         {
2793                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2794                 .name = "Channel Mode",
2795                 .info = alc_ch_mode_info,
2796                 .get = alc_ch_mode_get,
2797                 .put = alc_ch_mode_put,
2798         },
2799         { } /* end */
2800 };
2801
2802 static struct hda_verb alc880_test_init_verbs[] = {
2803         /* Unmute inputs of 0x0c - 0x0f */
2804         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2805         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2806         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2807         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2808         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2809         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2810         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2811         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2812         /* Vol output for 0x0c-0x0f */
2813         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2814         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2815         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2816         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2817         /* Set output pins 0x14-0x17 */
2818         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2819         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2820         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2821         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2822         /* Unmute output pins 0x14-0x17 */
2823         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2824         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2825         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2826         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2827         /* Set input pins 0x18-0x1c */
2828         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2829         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2830         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2831         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2832         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2833         /* Mute input pins 0x18-0x1b */
2834         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2835         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2836         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2837         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2838         /* ADC set up */
2839         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2840         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2841         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2842         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2843         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2844         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2845         /* Analog input/passthru */
2846         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2847         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2848         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2849         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2850         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2851         { }
2852 };
2853 #endif
2854
2855 /*
2856  */
2857
2858 static const char *alc880_models[ALC880_MODEL_LAST] = {
2859         [ALC880_3ST]            = "3stack",
2860         [ALC880_TCL_S700]       = "tcl",
2861         [ALC880_3ST_DIG]        = "3stack-digout",
2862         [ALC880_CLEVO]          = "clevo",
2863         [ALC880_5ST]            = "5stack",
2864         [ALC880_5ST_DIG]        = "5stack-digout",
2865         [ALC880_W810]           = "w810",
2866         [ALC880_Z71V]           = "z71v",
2867         [ALC880_6ST]            = "6stack",
2868         [ALC880_6ST_DIG]        = "6stack-digout",
2869         [ALC880_ASUS]           = "asus",
2870         [ALC880_ASUS_W1V]       = "asus-w1v",
2871         [ALC880_ASUS_DIG]       = "asus-dig",
2872         [ALC880_ASUS_DIG2]      = "asus-dig2",
2873         [ALC880_UNIWILL_DIG]    = "uniwill",
2874         [ALC880_UNIWILL_P53]    = "uniwill-p53",
2875         [ALC880_FUJITSU]        = "fujitsu",
2876         [ALC880_F1734]          = "F1734",
2877         [ALC880_LG]             = "lg",
2878         [ALC880_LG_LW]          = "lg-lw",
2879 #ifdef CONFIG_SND_DEBUG
2880         [ALC880_TEST]           = "test",
2881 #endif
2882         [ALC880_AUTO]           = "auto",
2883 };
2884
2885 static struct snd_pci_quirk alc880_cfg_tbl[] = {
2886         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
2887         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
2888         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
2889         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
2890         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
2891         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
2892         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
2893         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
2894         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
2895         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
2896         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
2897         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
2898         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
2899         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
2900         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
2901         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
2902         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
2903         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
2904         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
2905         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
2906         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
2907         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS", ALC880_ASUS),
2908         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
2909         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
2910         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
2911         SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
2912         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
2913         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
2914         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
2915         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
2916         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
2917         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
2918         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
2919         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
2920         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
2921         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
2922         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
2923         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
2924         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
2925         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
2926         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
2927         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
2928         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
2929         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
2930         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
2931         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
2932         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
2933         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
2934         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
2935         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
2936         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
2937         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
2938         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
2939         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
2940         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
2941         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
2942         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
2943         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
2944         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
2945         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
2946         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
2947         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
2948         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
2949         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
2950         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
2951         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
2952         SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
2953         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
2954         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
2955         {}
2956 };
2957
2958 /*
2959  * ALC880 codec presets
2960  */
2961 static struct alc_config_preset alc880_presets[] = {
2962         [ALC880_3ST] = {
2963                 .mixers = { alc880_three_stack_mixer },
2964                 .init_verbs = { alc880_volume_init_verbs,
2965                                 alc880_pin_3stack_init_verbs },
2966                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2967                 .dac_nids = alc880_dac_nids,
2968                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2969                 .channel_mode = alc880_threestack_modes,
2970                 .need_dac_fix = 1,
2971                 .input_mux = &alc880_capture_source,
2972         },
2973         [ALC880_3ST_DIG] = {
2974                 .mixers = { alc880_three_stack_mixer },
2975                 .init_verbs = { alc880_volume_init_verbs,
2976                                 alc880_pin_3stack_init_verbs },
2977                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2978                 .dac_nids = alc880_dac_nids,
2979                 .dig_out_nid = ALC880_DIGOUT_NID,
2980                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2981                 .channel_mode = alc880_threestack_modes,
2982                 .need_dac_fix = 1,
2983                 .input_mux = &alc880_capture_source,
2984         },
2985         [ALC880_TCL_S700] = {
2986                 .mixers = { alc880_tcl_s700_mixer },
2987                 .init_verbs = { alc880_volume_init_verbs,
2988                                 alc880_pin_tcl_S700_init_verbs,
2989                                 alc880_gpio2_init_verbs },
2990                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2991                 .dac_nids = alc880_dac_nids,
2992                 .hp_nid = 0x03,
2993                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2994                 .channel_mode = alc880_2_jack_modes,
2995                 .input_mux = &alc880_capture_source,
2996         },
2997         [ALC880_5ST] = {
2998                 .mixers = { alc880_three_stack_mixer,
2999                             alc880_five_stack_mixer},
3000                 .init_verbs = { alc880_volume_init_verbs,
3001                                 alc880_pin_5stack_init_verbs },
3002                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3003                 .dac_nids = alc880_dac_nids,
3004                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3005                 .channel_mode = alc880_fivestack_modes,
3006                 .input_mux = &alc880_capture_source,
3007         },
3008         [ALC880_5ST_DIG] = {
3009                 .mixers = { alc880_three_stack_mixer,
3010                             alc880_five_stack_mixer },
3011                 .init_verbs = { alc880_volume_init_verbs,
3012                                 alc880_pin_5stack_init_verbs },
3013                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3014                 .dac_nids = alc880_dac_nids,
3015                 .dig_out_nid = ALC880_DIGOUT_NID,
3016                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3017                 .channel_mode = alc880_fivestack_modes,
3018                 .input_mux = &alc880_capture_source,
3019         },
3020         [ALC880_6ST] = {
3021                 .mixers = { alc880_six_stack_mixer },
3022                 .init_verbs = { alc880_volume_init_verbs,
3023                                 alc880_pin_6stack_init_verbs },
3024                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3025                 .dac_nids = alc880_6st_dac_nids,
3026                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3027                 .channel_mode = alc880_sixstack_modes,
3028                 .input_mux = &alc880_6stack_capture_source,
3029         },
3030         [ALC880_6ST_DIG] = {
3031                 .mixers = { alc880_six_stack_mixer },
3032                 .init_verbs = { alc880_volume_init_verbs,
3033                                 alc880_pin_6stack_init_verbs },
3034                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3035                 .dac_nids = alc880_6st_dac_nids,
3036                 .dig_out_nid = ALC880_DIGOUT_NID,
3037                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3038                 .channel_mode = alc880_sixstack_modes,
3039                 .input_mux = &alc880_6stack_capture_source,
3040         },
3041         [ALC880_W810] = {
3042                 .mixers = { alc880_w810_base_mixer },
3043                 .init_verbs = { alc880_volume_init_verbs,
3044                                 alc880_pin_w810_init_verbs,
3045                                 alc880_gpio2_init_verbs },
3046                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3047                 .dac_nids = alc880_w810_dac_nids,
3048                 .dig_out_nid = ALC880_DIGOUT_NID,
3049                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3050                 .channel_mode = alc880_w810_modes,
3051                 .input_mux = &alc880_capture_source,
3052         },
3053         [ALC880_Z71V] = {
3054                 .mixers = { alc880_z71v_mixer },
3055                 .init_verbs = { alc880_volume_init_verbs,
3056                                 alc880_pin_z71v_init_verbs },
3057                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3058                 .dac_nids = alc880_z71v_dac_nids,
3059                 .dig_out_nid = ALC880_DIGOUT_NID,
3060                 .hp_nid = 0x03,
3061                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3062                 .channel_mode = alc880_2_jack_modes,
3063                 .input_mux = &alc880_capture_source,
3064         },
3065         [ALC880_F1734] = {
3066                 .mixers = { alc880_f1734_mixer },
3067                 .init_verbs = { alc880_volume_init_verbs,
3068                                 alc880_pin_f1734_init_verbs },
3069                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3070                 .dac_nids = alc880_f1734_dac_nids,
3071                 .hp_nid = 0x02,
3072                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3073                 .channel_mode = alc880_2_jack_modes,
3074                 .input_mux = &alc880_f1734_capture_source,
3075                 .unsol_event = alc880_uniwill_p53_unsol_event,
3076                 .init_hook = alc880_uniwill_p53_hp_automute,
3077         },
3078         [ALC880_ASUS] = {
3079                 .mixers = { alc880_asus_mixer },
3080                 .init_verbs = { alc880_volume_init_verbs,
3081                                 alc880_pin_asus_init_verbs,
3082                                 alc880_gpio1_init_verbs },
3083                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3084                 .dac_nids = alc880_asus_dac_nids,
3085                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3086                 .channel_mode = alc880_asus_modes,
3087                 .need_dac_fix = 1,
3088                 .input_mux = &alc880_capture_source,
3089         },
3090         [ALC880_ASUS_DIG] = {
3091                 .mixers = { alc880_asus_mixer },
3092                 .init_verbs = { alc880_volume_init_verbs,
3093                                 alc880_pin_asus_init_verbs,
3094                                 alc880_gpio1_init_verbs },
3095                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3096                 .dac_nids = alc880_asus_dac_nids,
3097                 .dig_out_nid = ALC880_DIGOUT_NID,
3098                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3099                 .channel_mode = alc880_asus_modes,
3100                 .need_dac_fix = 1,
3101                 .input_mux = &alc880_capture_source,
3102         },
3103         [ALC880_ASUS_DIG2] = {
3104                 .mixers = { alc880_asus_mixer },
3105                 .init_verbs = { alc880_volume_init_verbs,
3106                                 alc880_pin_asus_init_verbs,
3107                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3108                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3109                 .dac_nids = alc880_asus_dac_nids,
3110                 .dig_out_nid = ALC880_DIGOUT_NID,
3111                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3112                 .channel_mode = alc880_asus_modes,
3113                 .need_dac_fix = 1,
3114                 .input_mux = &alc880_capture_source,
3115         },
3116         [ALC880_ASUS_W1V] = {
3117                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3118                 .init_verbs = { alc880_volume_init_verbs,
3119                                 alc880_pin_asus_init_verbs,
3120                                 alc880_gpio1_init_verbs },
3121                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3122                 .dac_nids = alc880_asus_dac_nids,
3123                 .dig_out_nid = ALC880_DIGOUT_NID,
3124                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3125                 .channel_mode = alc880_asus_modes,
3126                 .need_dac_fix = 1,
3127                 .input_mux = &alc880_capture_source,
3128         },
3129         [ALC880_UNIWILL_DIG] = {
3130                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3131                 .init_verbs = { alc880_volume_init_verbs,
3132                                 alc880_pin_asus_init_verbs },
3133                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3134                 .dac_nids = alc880_asus_dac_nids,
3135                 .dig_out_nid = ALC880_DIGOUT_NID,
3136                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3137                 .channel_mode = alc880_asus_modes,
3138                 .need_dac_fix = 1,
3139                 .input_mux = &alc880_capture_source,
3140         },
3141         [ALC880_UNIWILL] = {
3142                 .mixers = { alc880_uniwill_mixer },
3143                 .init_verbs = { alc880_volume_init_verbs,
3144                                 alc880_uniwill_init_verbs },
3145                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3146                 .dac_nids = alc880_asus_dac_nids,
3147                 .dig_out_nid = ALC880_DIGOUT_NID,
3148                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3149                 .channel_mode = alc880_threestack_modes,
3150                 .need_dac_fix = 1,
3151                 .input_mux = &alc880_capture_source,
3152                 .unsol_event = alc880_uniwill_unsol_event,
3153                 .init_hook = alc880_uniwill_automute,
3154         },
3155         [ALC880_UNIWILL_P53] = {
3156                 .mixers = { alc880_uniwill_p53_mixer },
3157                 .init_verbs = { alc880_volume_init_verbs,
3158                                 alc880_uniwill_p53_init_verbs },
3159                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3160                 .dac_nids = alc880_asus_dac_nids,
3161                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3162                 .channel_mode = alc880_threestack_modes,
3163                 .input_mux = &alc880_capture_source,
3164                 .unsol_event = alc880_uniwill_p53_unsol_event,
3165                 .init_hook = alc880_uniwill_p53_hp_automute,
3166         },
3167         [ALC880_FUJITSU] = {
3168                 .mixers = { alc880_fujitsu_mixer,
3169                             alc880_pcbeep_mixer, },
3170                 .init_verbs = { alc880_volume_init_verbs,
3171                                 alc880_uniwill_p53_init_verbs,
3172                                 alc880_beep_init_verbs },
3173                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3174                 .dac_nids = alc880_dac_nids,
3175                 .dig_out_nid = ALC880_DIGOUT_NID,
3176                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3177                 .channel_mode = alc880_2_jack_modes,
3178                 .input_mux = &alc880_capture_source,
3179                 .unsol_event = alc880_uniwill_p53_unsol_event,
3180                 .init_hook = alc880_uniwill_p53_hp_automute,
3181         },
3182         [ALC880_CLEVO] = {
3183                 .mixers = { alc880_three_stack_mixer },
3184                 .init_verbs = { alc880_volume_init_verbs,
3185                                 alc880_pin_clevo_init_verbs },
3186                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3187                 .dac_nids = alc880_dac_nids,
3188                 .hp_nid = 0x03,
3189                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3190                 .channel_mode = alc880_threestack_modes,
3191                 .need_dac_fix = 1,
3192                 .input_mux = &alc880_capture_source,
3193         },
3194         [ALC880_LG] = {
3195                 .mixers = { alc880_lg_mixer },
3196                 .init_verbs = { alc880_volume_init_verbs,
3197                                 alc880_lg_init_verbs },
3198                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3199                 .dac_nids = alc880_lg_dac_nids,
3200                 .dig_out_nid = ALC880_DIGOUT_NID,
3201                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3202                 .channel_mode = alc880_lg_ch_modes,
3203                 .need_dac_fix = 1,
3204                 .input_mux = &alc880_lg_capture_source,
3205                 .unsol_event = alc880_lg_unsol_event,
3206                 .init_hook = alc880_lg_automute,
3207 #ifdef CONFIG_SND_HDA_POWER_SAVE
3208                 .loopbacks = alc880_lg_loopbacks,
3209 #endif
3210         },
3211         [ALC880_LG_LW] = {
3212                 .mixers = { alc880_lg_lw_mixer },
3213                 .init_verbs = { alc880_volume_init_verbs,
3214                                 alc880_lg_lw_init_verbs },
3215                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3216                 .dac_nids = alc880_dac_nids,
3217                 .dig_out_nid = ALC880_DIGOUT_NID,
3218                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3219                 .channel_mode = alc880_lg_lw_modes,
3220                 .input_mux = &alc880_lg_lw_capture_source,
3221                 .unsol_event = alc880_lg_lw_unsol_event,
3222                 .init_hook = alc880_lg_lw_automute,
3223         },
3224 #ifdef CONFIG_SND_DEBUG
3225         [ALC880_TEST] = {
3226                 .mixers = { alc880_test_mixer },
3227                 .init_verbs = { alc880_test_init_verbs },
3228                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3229                 .dac_nids = alc880_test_dac_nids,
3230                 .dig_out_nid = ALC880_DIGOUT_NID,
3231                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3232                 .channel_mode = alc880_test_modes,
3233                 .input_mux = &alc880_test_capture_source,
3234         },
3235 #endif
3236 };
3237
3238 /*
3239  * Automatic parse of I/O pins from the BIOS configuration
3240  */
3241
3242 #define NUM_CONTROL_ALLOC       32
3243 #define NUM_VERB_ALLOC          32
3244
3245 enum {
3246         ALC_CTL_WIDGET_VOL,
3247         ALC_CTL_WIDGET_MUTE,
3248         ALC_CTL_BIND_MUTE,
3249 };
3250 static struct snd_kcontrol_new alc880_control_templates[] = {
3251         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3252         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3253         HDA_BIND_MUTE(NULL, 0, 0, 0),
3254 };
3255
3256 /* add dynamic controls */
3257 static int add_control(struct alc_spec *spec, int type, const char *name,
3258                        unsigned long val)
3259 {
3260         struct snd_kcontrol_new *knew;
3261
3262         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3263                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3264
3265                 /* array + terminator */
3266                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3267                 if (!knew)
3268                         return -ENOMEM;
3269                 if (spec->kctl_alloc) {
3270                         memcpy(knew, spec->kctl_alloc,
3271                                sizeof(*knew) * spec->num_kctl_alloc);
3272                         kfree(spec->kctl_alloc);
3273                 }
3274                 spec->kctl_alloc = knew;
3275                 spec->num_kctl_alloc = num;
3276         }
3277
3278         knew = &spec->kctl_alloc[spec->num_kctl_used];
3279         *knew = alc880_control_templates[type];
3280         knew->name = kstrdup(name, GFP_KERNEL);
3281         if (!knew->name)
3282                 return -ENOMEM;
3283         knew->private_value = val;
3284         spec->num_kctl_used++;
3285         return 0;
3286 }
3287
3288 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3289 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3290 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3291 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3292 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3293 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3294 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3295 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3296 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3297 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3298 #define ALC880_PIN_CD_NID               0x1c
3299
3300 /* fill in the dac_nids table from the parsed pin configuration */
3301 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3302                                      const struct auto_pin_cfg *cfg)
3303 {
3304         hda_nid_t nid;
3305         int assigned[4];
3306         int i, j;
3307
3308         memset(assigned, 0, sizeof(assigned));
3309         spec->multiout.dac_nids = spec->private_dac_nids;
3310
3311         /* check the pins hardwired to audio widget */
3312         for (i = 0; i < cfg->line_outs; i++) {
3313                 nid = cfg->line_out_pins[i];
3314                 if (alc880_is_fixed_pin(nid)) {
3315                         int idx = alc880_fixed_pin_idx(nid);
3316                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3317                         assigned[idx] = 1;
3318                 }
3319         }
3320         /* left pins can be connect to any audio widget */
3321         for (i = 0; i < cfg->line_outs; i++) {
3322                 nid = cfg->line_out_pins[i];
3323                 if (alc880_is_fixed_pin(nid))
3324                         continue;
3325                 /* search for an empty channel */
3326                 for (j = 0; j < cfg->line_outs; j++) {
3327                         if (!assigned[j]) {
3328                                 spec->multiout.dac_nids[i] =
3329                                         alc880_idx_to_dac(j);
3330                                 assigned[j] = 1;
3331                                 break;
3332                         }
3333                 }
3334         }
3335         spec->multiout.num_dacs = cfg->line_outs;
3336         return 0;
3337 }
3338
3339 /* add playback controls from the parsed DAC table */
3340 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3341                                              const struct auto_pin_cfg *cfg)
3342 {
3343         char name[32];
3344         static const char *chname[4] = {
3345                 "Front", "Surround", NULL /*CLFE*/, "Side"
3346         };
3347         hda_nid_t nid;
3348         int i, err;
3349
3350         for (i = 0; i < cfg->line_outs; i++) {
3351                 if (!spec->multiout.dac_nids[i])
3352                         continue;
3353                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3354                 if (i == 2) {
3355                         /* Center/LFE */
3356                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3357                                           "Center Playback Volume",
3358                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3359                                                               HDA_OUTPUT));
3360                         if (err < 0)
3361                                 return err;
3362                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3363                                           "LFE Playback Volume",
3364                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3365                                                               HDA_OUTPUT));
3366                         if (err < 0)
3367                                 return err;
3368                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3369                                           "Center Playback Switch",
3370                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3371                                                               HDA_INPUT));
3372                         if (err < 0)
3373                                 return err;
3374                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3375                                           "LFE Playback Switch",
3376                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3377                                                               HDA_INPUT));
3378                         if (err < 0)
3379                                 return err;
3380                 } else {
3381                         sprintf(name, "%s Playback Volume", chname[i]);
3382                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3383                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3384                                                               HDA_OUTPUT));
3385                         if (err < 0)
3386                                 return err;
3387                         sprintf(name, "%s Playback Switch", chname[i]);
3388                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3389                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3390                                                               HDA_INPUT));
3391                         if (err < 0)
3392                                 return err;
3393                 }
3394         }
3395         return 0;
3396 }
3397
3398 /* add playback controls for speaker and HP outputs */
3399 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3400                                         const char *pfx)
3401 {
3402         hda_nid_t nid;
3403         int err;
3404         char name[32];
3405
3406         if (!pin)
3407                 return 0;
3408
3409         if (alc880_is_fixed_pin(pin)) {
3410                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3411                 /* specify the DAC as the extra output */
3412                 if (!spec->multiout.hp_nid)
3413                         spec->multiout.hp_nid = nid;
3414                 else
3415                         spec->multiout.extra_out_nid[0] = nid;
3416                 /* control HP volume/switch on the output mixer amp */
3417                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3418                 sprintf(name, "%s Playback Volume", pfx);
3419                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3420                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3421                 if (err < 0)
3422                         return err;
3423                 sprintf(name, "%s Playback Switch", pfx);
3424                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3425                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3426                 if (err < 0)
3427                         return err;
3428         } else if (alc880_is_multi_pin(pin)) {
3429                 /* set manual connection */
3430                 /* we have only a switch on HP-out PIN */
3431                 sprintf(name, "%s Playback Switch", pfx);
3432                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3433                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3434                 if (err < 0)
3435                         return err;
3436         }
3437         return 0;
3438 }
3439
3440 /* create input playback/capture controls for the given pin */
3441 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3442                             const char *ctlname,
3443                             int idx, hda_nid_t mix_nid)
3444 {
3445         char name[32];
3446         int err;
3447
3448         sprintf(name, "%s Playback Volume", ctlname);
3449         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3450                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3451         if (err < 0)
3452                 return err;
3453         sprintf(name, "%s Playback Switch", ctlname);
3454         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3455                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3456         if (err < 0)
3457                 return err;
3458         return 0;
3459 }
3460
3461 /* create playback/capture controls for input pins */
3462 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3463                                                 const struct auto_pin_cfg *cfg)
3464 {
3465         struct hda_input_mux *imux = &spec->private_imux;
3466         int i, err, idx;
3467
3468         for (i = 0; i < AUTO_PIN_LAST; i++) {
3469                 if (alc880_is_input_pin(cfg->input_pins[i])) {
3470                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
3471                         err = new_analog_input(spec, cfg->input_pins[i],
3472                                                auto_pin_cfg_labels[i],
3473                                                idx, 0x0b);
3474                         if (err < 0)
3475                                 return err;
3476                         imux->items[imux->num_items].label =
3477                                 auto_pin_cfg_labels[i];
3478                         imux->items[imux->num_items].index =
3479                                 alc880_input_pin_idx(cfg->input_pins[i]);
3480                         imux->num_items++;
3481                 }
3482         }
3483         return 0;
3484 }
3485
3486 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3487                                unsigned int pin_type)
3488 {
3489         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3490                             pin_type);
3491         /* unmute pin */
3492         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 0xff, 0x00);
3493 }
3494
3495 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3496                                               hda_nid_t nid, int pin_type,
3497                                               int dac_idx)
3498 {
3499         alc_set_pin_output(codec, nid, pin_type);
3500         /* need the manual connection? */
3501         if (alc880_is_multi_pin(nid)) {
3502                 struct alc_spec *spec = codec->spec;
3503                 int idx = alc880_multi_pin_idx(nid);
3504                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3505                                     AC_VERB_SET_CONNECT_SEL,
3506                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3507         }
3508 }
3509
3510 static int get_pin_type(int line_out_type)
3511 {
3512         if (line_out_type == AUTO_PIN_HP_OUT)
3513                 return PIN_HP;
3514         else
3515                 return PIN_OUT;
3516 }
3517
3518 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3519 {
3520         struct alc_spec *spec = codec->spec;
3521         int i;
3522
3523         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3524         for (i = 0; i < spec->autocfg.line_outs; i++) {
3525                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3526                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3527                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3528         }
3529 }
3530
3531 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3532 {
3533         struct alc_spec *spec = codec->spec;
3534         hda_nid_t pin;
3535
3536         pin = spec->autocfg.speaker_pins[0];
3537         if (pin) /* connect to front */
3538                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3539         pin = spec->autocfg.hp_pins[0];
3540         if (pin) /* connect to front */
3541                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3542 }
3543
3544 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3545 {
3546         struct alc_spec *spec = codec->spec;
3547         int i;
3548
3549         for (i = 0; i < AUTO_PIN_LAST; i++) {
3550                 hda_nid_t nid = spec->autocfg.input_pins[i];
3551                 if (alc880_is_input_pin(nid)) {
3552                         snd_hda_codec_write(codec, nid, 0,
3553                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
3554                                             i <= AUTO_PIN_FRONT_MIC ?
3555                                             PIN_VREF80 : PIN_IN);
3556                         if (nid != ALC880_PIN_CD_NID)
3557                                 snd_hda_codec_write(codec, nid, 0,
3558                                                     AC_VERB_SET_AMP_GAIN_MUTE,
3559                                                     AMP_OUT_MUTE);
3560                 }
3561         }
3562 }
3563
3564 /* parse the BIOS configuration and set up the alc_spec */
3565 /* return 1 if successful, 0 if the proper config is not found,
3566  * or a negative error code
3567  */
3568 static int alc880_parse_auto_config(struct hda_codec *codec)
3569 {
3570         struct alc_spec *spec = codec->spec;
3571         int err;
3572         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3573
3574         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3575                                            alc880_ignore);
3576         if (err < 0)
3577                 return err;
3578         if (!spec->autocfg.line_outs)
3579                 return 0; /* can't find valid BIOS pin config */
3580
3581         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3582         if (err < 0)
3583                 return err;
3584         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3585         if (err < 0)
3586                 return err;
3587         err = alc880_auto_create_extra_out(spec,
3588                                            spec->autocfg.speaker_pins[0],
3589                                            "Speaker");
3590         if (err < 0)
3591                 return err;
3592         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3593                                            "Headphone");
3594         if (err < 0)
3595                 return err;
3596         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3597         if (err < 0)
3598                 return err;
3599
3600         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3601
3602         if (spec->autocfg.dig_out_pin)
3603                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3604         if (spec->autocfg.dig_in_pin)
3605                 spec->dig_in_nid = ALC880_DIGIN_NID;
3606
3607         if (spec->kctl_alloc)
3608                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3609
3610         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3611
3612         spec->num_mux_defs = 1;
3613         spec->input_mux = &spec->private_imux;
3614
3615         return 1;
3616 }
3617
3618 /* additional initialization for auto-configuration model */
3619 static void alc880_auto_init(struct hda_codec *codec)
3620 {
3621         struct alc_spec *spec = codec->spec;
3622         alc880_auto_init_multi_out(codec);
3623         alc880_auto_init_extra_out(codec);
3624         alc880_auto_init_analog_input(codec);
3625         if (spec->unsol_event)
3626                 alc_sku_automute(codec);
3627 }
3628
3629 /*
3630  * OK, here we have finally the patch for ALC880
3631  */
3632
3633 static int patch_alc880(struct hda_codec *codec)
3634 {
3635         struct alc_spec *spec;
3636         int board_config;
3637         int err;
3638
3639         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3640         if (spec == NULL)
3641                 return -ENOMEM;
3642
3643         codec->spec = spec;
3644
3645         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3646                                                   alc880_models,
3647                                                   alc880_cfg_tbl);
3648         if (board_config < 0) {
3649                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3650                        "trying auto-probe from BIOS...\n");
3651                 board_config = ALC880_AUTO;
3652         }
3653
3654         if (board_config == ALC880_AUTO) {
3655                 /* automatic parse from the BIOS config */
3656                 err = alc880_parse_auto_config(codec);
3657                 if (err < 0) {
3658                         alc_free(codec);
3659                         return err;
3660                 } else if (!err) {
3661                         printk(KERN_INFO
3662                                "hda_codec: Cannot set up configuration "
3663                                "from BIOS.  Using 3-stack mode...\n");
3664                         board_config = ALC880_3ST;
3665                 }
3666         }
3667
3668         if (board_config != ALC880_AUTO)
3669                 setup_preset(spec, &alc880_presets[board_config]);
3670
3671         spec->stream_name_analog = "ALC880 Analog";
3672         spec->stream_analog_playback = &alc880_pcm_analog_playback;
3673         spec->stream_analog_capture = &alc880_pcm_analog_capture;
3674         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3675
3676         spec->stream_name_digital = "ALC880 Digital";
3677         spec->stream_digital_playback = &alc880_pcm_digital_playback;
3678         spec->stream_digital_capture = &alc880_pcm_digital_capture;
3679
3680         if (!spec->adc_nids && spec->input_mux) {
3681                 /* check whether NID 0x07 is valid */
3682                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3683                 /* get type */
3684                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3685                 if (wcap != AC_WID_AUD_IN) {
3686                         spec->adc_nids = alc880_adc_nids_alt;
3687                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3688                         spec->mixers[spec->num_mixers] =
3689                                 alc880_capture_alt_mixer;
3690                         spec->num_mixers++;
3691                 } else {
3692                         spec->adc_nids = alc880_adc_nids;
3693                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3694                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3695                         spec->num_mixers++;
3696                 }
3697         }
3698
3699         spec->vmaster_nid = 0x0c;
3700
3701         codec->patch_ops = alc_patch_ops;
3702         if (board_config == ALC880_AUTO)
3703                 spec->init_hook = alc880_auto_init;
3704 #ifdef CONFIG_SND_HDA_POWER_SAVE
3705         if (!spec->loopback.amplist)
3706                 spec->loopback.amplist = alc880_loopbacks;
3707 #endif
3708
3709         return 0;
3710 }
3711
3712
3713 /*
3714  * ALC260 support
3715  */
3716
3717 static hda_nid_t alc260_dac_nids[1] = {
3718         /* front */
3719         0x02,
3720 };
3721
3722 static hda_nid_t alc260_adc_nids[1] = {
3723         /* ADC0 */
3724         0x04,
3725 };
3726
3727 static hda_nid_t alc260_adc_nids_alt[1] = {
3728         /* ADC1 */
3729         0x05,
3730 };
3731
3732 static hda_nid_t alc260_hp_adc_nids[2] = {
3733         /* ADC1, 0 */
3734         0x05, 0x04
3735 };
3736
3737 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
3738  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
3739  */
3740 static hda_nid_t alc260_dual_adc_nids[2] = {
3741         /* ADC0, ADC1 */
3742         0x04, 0x05
3743 };
3744
3745 #define ALC260_DIGOUT_NID       0x03
3746 #define ALC260_DIGIN_NID        0x06
3747
3748 static struct hda_input_mux alc260_capture_source = {
3749         .num_items = 4,
3750         .items = {
3751                 { "Mic", 0x0 },
3752                 { "Front Mic", 0x1 },
3753                 { "Line", 0x2 },
3754                 { "CD", 0x4 },
3755         },
3756 };
3757
3758 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
3759  * headphone jack and the internal CD lines since these are the only pins at
3760  * which audio can appear.  For flexibility, also allow the option of
3761  * recording the mixer output on the second ADC (ADC0 doesn't have a
3762  * connection to the mixer output).
3763  */
3764 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
3765         {
3766                 .num_items = 3,
3767                 .items = {
3768                         { "Mic/Line", 0x0 },
3769                         { "CD", 0x4 },
3770                         { "Headphone", 0x2 },
3771                 },
3772         },
3773         {
3774                 .num_items = 4,
3775                 .items = {
3776                         { "Mic/Line", 0x0 },
3777                         { "CD", 0x4 },
3778                         { "Headphone", 0x2 },
3779                         { "Mixer", 0x5 },
3780                 },
3781         },
3782
3783 };
3784
3785 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
3786  * the Fujitsu S702x, but jacks are marked differently.
3787  */
3788 static struct hda_input_mux alc260_acer_capture_sources[2] = {
3789         {
3790                 .num_items = 4,
3791                 .items = {
3792                         { "Mic", 0x0 },
3793                         { "Line", 0x2 },
3794                         { "CD", 0x4 },
3795                         { "Headphone", 0x5 },
3796                 },
3797         },
3798         {
3799                 .num_items = 5,
3800                 .items = {
3801                         { "Mic", 0x0 },
3802                         { "Line", 0x2 },
3803                         { "CD", 0x4 },
3804                         { "Headphone", 0x6 },
3805                         { "Mixer", 0x5 },
3806                 },
3807         },
3808 };
3809 /*
3810  * This is just place-holder, so there's something for alc_build_pcms to look
3811  * at when it calculates the maximum number of channels. ALC260 has no mixer
3812  * element which allows changing the channel mode, so the verb list is
3813  * never used.
3814  */
3815 static struct hda_channel_mode alc260_modes[1] = {
3816         { 2, NULL },
3817 };
3818
3819
3820 /* Mixer combinations
3821  *
3822  * basic: base_output + input + pc_beep + capture
3823  * HP: base_output + input + capture_alt
3824  * HP_3013: hp_3013 + input + capture
3825  * fujitsu: fujitsu + capture
3826  * acer: acer + capture
3827  */
3828
3829 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
3830         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3831         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
3832         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3833         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
3834         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3835         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3836         { } /* end */
3837 };
3838
3839 static struct snd_kcontrol_new alc260_input_mixer[] = {
3840         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3841         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3842         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
3843         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
3844         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
3845         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
3846         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
3847         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
3848         { } /* end */
3849 };
3850
3851 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
3852         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
3853         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
3854         { } /* end */
3855 };
3856
3857 /* update HP, line and mono out pins according to the master switch */
3858 static void alc260_hp_master_update(struct hda_codec *codec,
3859                                     hda_nid_t hp, hda_nid_t line,
3860                                     hda_nid_t mono)
3861 {
3862         struct alc_spec *spec = codec->spec;
3863         unsigned int val = spec->master_sw ? PIN_HP : 0;
3864         /* change HP and line-out pins */
3865         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3866                             val);
3867         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3868                             val);
3869         /* mono (speaker) depending on the HP jack sense */
3870         val = (val && !spec->jack_present) ? PIN_OUT : 0;
3871         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3872                             val);
3873 }
3874
3875 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
3876                                    struct snd_ctl_elem_value *ucontrol)
3877 {
3878         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3879         struct alc_spec *spec = codec->spec;
3880         *ucontrol->value.integer.value = spec->master_sw;
3881         return 0;
3882 }
3883
3884 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
3885                                    struct snd_ctl_elem_value *ucontrol)
3886 {
3887         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3888         struct alc_spec *spec = codec->spec;
3889         int val = !!*ucontrol->value.integer.value;
3890         hda_nid_t hp, line, mono;
3891
3892         if (val == spec->master_sw)
3893                 return 0;
3894         spec->master_sw = val;
3895         hp = (kcontrol->private_value >> 16) & 0xff;
3896         line = (kcontrol->private_value >> 8) & 0xff;
3897         mono = kcontrol->private_value & 0xff;
3898         alc260_hp_master_update(codec, hp, line, mono);
3899         return 1;
3900 }
3901
3902 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
3903         {
3904                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3905                 .name = "Master Playback Switch",
3906                 .info = snd_ctl_boolean_mono_info,
3907                 .get = alc260_hp_master_sw_get,
3908                 .put = alc260_hp_master_sw_put,
3909                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
3910         },
3911         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3912         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
3913         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3914         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
3915         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
3916                               HDA_OUTPUT),
3917         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3918         { } /* end */
3919 };
3920
3921 static struct hda_verb alc260_hp_unsol_verbs[] = {
3922         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3923         {},
3924 };
3925
3926 static void alc260_hp_automute(struct hda_codec *codec)
3927 {
3928         struct alc_spec *spec = codec->spec;
3929         unsigned int present;
3930
3931         present = snd_hda_codec_read(codec, 0x10, 0,
3932                                      AC_VERB_GET_PIN_SENSE, 0);
3933         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
3934         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
3935 }
3936
3937 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
3938 {
3939         if ((res >> 26) == ALC880_HP_EVENT)
3940                 alc260_hp_automute(codec);
3941 }
3942
3943 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
3944         {
3945                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3946                 .name = "Master Playback Switch",
3947                 .info = snd_ctl_boolean_mono_info,
3948                 .get = alc260_hp_master_sw_get,
3949                 .put = alc260_hp_master_sw_put,
3950                 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
3951         },
3952         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3953         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
3954         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
3955         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
3956         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3957         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
3958         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3959         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
3960         { } /* end */
3961 };
3962
3963 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
3964         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3965         {},
3966 };
3967
3968 static void alc260_hp_3013_automute(struct hda_codec *codec)
3969 {
3970         struct alc_spec *spec = codec->spec;
3971         unsigned int present;
3972
3973         present = snd_hda_codec_read(codec, 0x15, 0,
3974                                      AC_VERB_GET_PIN_SENSE, 0);
3975         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
3976         alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
3977 }
3978
3979 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
3980                                        unsigned int res)
3981 {
3982         if ((res >> 26) == ALC880_HP_EVENT)
3983                 alc260_hp_3013_automute(codec);
3984 }
3985
3986 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
3987  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
3988  */
3989 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
3990         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3991         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
3992         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
3993         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3994         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3995         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
3996         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
3997         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
3998         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3999         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4000         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4001         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4002         { } /* end */
4003 };
4004
4005 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4006  * versions of the ALC260 don't act on requests to enable mic bias from NID
4007  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4008  * datasheet doesn't mention this restriction.  At this stage it's not clear
4009  * whether this behaviour is intentional or is a hardware bug in chip
4010  * revisions available in early 2006.  Therefore for now allow the
4011  * "Headphone Jack Mode" control to span all choices, but if it turns out
4012  * that the lack of mic bias for this NID is intentional we could change the
4013  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4014  *
4015  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4016  * don't appear to make the mic bias available from the "line" jack, even
4017  * though the NID used for this jack (0x14) can supply it.  The theory is
4018  * that perhaps Acer have included blocking capacitors between the ALC260
4019  * and the output jack.  If this turns out to be the case for all such
4020  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4021  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4022  *
4023  * The C20x Tablet series have a mono internal speaker which is controlled
4024  * via the chip's Mono sum widget and pin complex, so include the necessary
4025  * controls for such models.  On models without a "mono speaker" the control
4026  * won't do anything.
4027  */
4028 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4029         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4030         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4031         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4032         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4033                               HDA_OUTPUT),
4034         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4035                            HDA_INPUT),
4036         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4037         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4038         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4039         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4040         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4041         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4042         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4043         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4044         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4045         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4046         { } /* end */
4047 };
4048
4049 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4050  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4051  */
4052 static struct snd_kcontrol_new alc260_will_mixer[] = {
4053         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4054         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4055         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4056         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4057         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4058         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4059         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4060         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4061         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4062         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4063         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4064         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4065         { } /* end */
4066 };
4067
4068 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4069  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4070  */
4071 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4072         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4073         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4074         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4075         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4076         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4077         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4078         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4079         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4080         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4081         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4082         { } /* end */
4083 };
4084
4085 /* capture mixer elements */
4086 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4087         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4088         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4089         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4090         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4091         {
4092                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4093                 /* The multiple "Capture Source" controls confuse alsamixer
4094                  * So call somewhat different..
4095                  */
4096                 /* .name = "Capture Source", */
4097                 .name = "Input Source",
4098                 .count = 2,
4099                 .info = alc_mux_enum_info,
4100                 .get = alc_mux_enum_get,
4101                 .put = alc_mux_enum_put,
4102         },
4103         { } /* end */
4104 };
4105
4106 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4107         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4108         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4109         {
4110                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4111                 /* The multiple "Capture Source" controls confuse alsamixer
4112                  * So call somewhat different..
4113                  */
4114                 /* .name = "Capture Source", */
4115                 .name = "Input Source",
4116                 .count = 1,
4117                 .info = alc_mux_enum_info,
4118                 .get = alc_mux_enum_get,
4119                 .put = alc_mux_enum_put,
4120         },
4121         { } /* end */
4122 };
4123
4124 /*
4125  * initialization verbs
4126  */
4127 static struct hda_verb alc260_init_verbs[] = {
4128         /* Line In pin widget for input */
4129         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4130         /* CD pin widget for input */
4131         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4132         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4133         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4134         /* Mic2 (front panel) pin widget for input and vref at 80% */
4135         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4136         /* LINE-2 is used for line-out in rear */
4137         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4138         /* select line-out */
4139         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4140         /* LINE-OUT pin */
4141         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4142         /* enable HP */
4143         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4144         /* enable Mono */
4145         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4146         /* mute capture amp left and right */
4147         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4148         /* set connection select to line in (default select for this ADC) */
4149         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4150         /* mute capture amp left and right */
4151         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4152         /* set connection select to line in (default select for this ADC) */
4153         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4154         /* set vol=0 Line-Out mixer amp left and right */
4155         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4156         /* unmute pin widget amp left and right (no gain on this amp) */
4157         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4158         /* set vol=0 HP mixer amp left and right */
4159         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4160         /* unmute pin widget amp left and right (no gain on this amp) */
4161         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4162         /* set vol=0 Mono mixer amp left and right */
4163         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4164         /* unmute pin widget amp left and right (no gain on this amp) */
4165         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4166         /* unmute LINE-2 out pin */
4167         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4168         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4169          * Line In 2 = 0x03
4170          */
4171         /* mute analog inputs */
4172         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4173         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4174         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4175         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4176         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4177         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4178         /* mute Front out path */
4179         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4180         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4181         /* mute Headphone out path */
4182         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4183         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4184         /* mute Mono out path */
4185         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4186         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4187         { }
4188 };
4189
4190 #if 0 /* should be identical with alc260_init_verbs? */
4191 static struct hda_verb alc260_hp_init_verbs[] = {
4192         /* Headphone and output */
4193         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4194         /* mono output */
4195         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4196         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4197         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4198         /* Mic2 (front panel) pin widget for input and vref at 80% */
4199         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4200         /* Line In pin widget for input */
4201         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4202         /* Line-2 pin widget for output */
4203         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4204         /* CD pin widget for input */
4205         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4206         /* unmute amp left and right */
4207         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4208         /* set connection select to line in (default select for this ADC) */
4209         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4210         /* unmute Line-Out mixer amp left and right (volume = 0) */
4211         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4212         /* mute pin widget amp left and right (no gain on this amp) */
4213         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4214         /* unmute HP mixer amp left and right (volume = 0) */
4215         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4216         /* mute pin widget amp left and right (no gain on this amp) */
4217         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4218         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4219          * Line In 2 = 0x03
4220          */
4221         /* mute analog inputs */
4222         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4223         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4224         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4225         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4226         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4227         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4228         /* Unmute Front out path */
4229         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4230         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4231         /* Unmute Headphone out path */
4232         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4233         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4234         /* Unmute Mono out path */
4235         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4236         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4237         { }
4238 };
4239 #endif
4240
4241 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4242         /* Line out and output */
4243         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4244         /* mono output */
4245         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4246         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4247         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4248         /* Mic2 (front panel) pin widget for input and vref at 80% */
4249         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4250         /* Line In pin widget for input */
4251         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4252         /* Headphone pin widget for output */
4253         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4254         /* CD pin widget for input */
4255         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4256         /* unmute amp left and right */
4257         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4258         /* set connection select to line in (default select for this ADC) */
4259         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4260         /* unmute Line-Out mixer amp left and right (volume = 0) */
4261         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4262         /* mute pin widget amp left and right (no gain on this amp) */
4263         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4264         /* unmute HP mixer amp left and right (volume = 0) */
4265         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4266         /* mute pin widget amp left and right (no gain on this amp) */
4267         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4268         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4269          * Line In 2 = 0x03
4270          */
4271         /* mute analog inputs */
4272         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4273         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4274         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4275         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4276         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4277         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4278         /* Unmute Front out path */
4279         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4280         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4281         /* Unmute Headphone out path */
4282         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4283         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4284         /* Unmute Mono out path */
4285         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4286         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4287         { }
4288 };
4289
4290 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4291  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4292  * audio = 0x16, internal speaker = 0x10.
4293  */
4294 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4295         /* Disable all GPIOs */
4296         {0x01, AC_VERB_SET_GPIO_MASK, 0},
4297         /* Internal speaker is connected to headphone pin */
4298         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4299         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4300         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4301         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4302         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4303         /* Ensure all other unused pins are disabled and muted. */
4304         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4305         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4306         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4307         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4308         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4309         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4310         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4311         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4312
4313         /* Disable digital (SPDIF) pins */
4314         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4315         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4316
4317         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4318          * when acting as an output.
4319          */
4320         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4321
4322         /* Start with output sum widgets muted and their output gains at min */
4323         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4324         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4326         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4327         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4328         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4329         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4330         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4331         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4332
4333         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4334         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4335         /* Unmute Line1 pin widget output buffer since it starts as an output.
4336          * If the pin mode is changed by the user the pin mode control will
4337          * take care of enabling the pin's input/output buffers as needed.
4338          * Therefore there's no need to enable the input buffer at this
4339          * stage.
4340          */
4341         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4342         /* Unmute input buffer of pin widget used for Line-in (no equiv
4343          * mixer ctrl)
4344          */
4345         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4346
4347         /* Mute capture amp left and right */
4348         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4349         /* Set ADC connection select to match default mixer setting - line
4350          * in (on mic1 pin)
4351          */
4352         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4353
4354         /* Do the same for the second ADC: mute capture input amp and
4355          * set ADC connection to line in (on mic1 pin)
4356          */
4357         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4358         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4359
4360         /* Mute all inputs to mixer widget (even unconnected ones) */
4361         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4362         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4363         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4364         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4365         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4366         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4367         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4368         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4369
4370         { }
4371 };
4372
4373 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4374  * similar laptops (adapted from Fujitsu init verbs).
4375  */
4376 static struct hda_verb alc260_acer_init_verbs[] = {
4377         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4378          * the headphone jack.  Turn this on and rely on the standard mute
4379          * methods whenever the user wants to turn these outputs off.
4380          */
4381         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4382         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4383         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4384         /* Internal speaker/Headphone jack is connected to Line-out pin */
4385         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4386         /* Internal microphone/Mic jack is connected to Mic1 pin */
4387         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4388         /* Line In jack is connected to Line1 pin */
4389         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4390         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4391         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4392         /* Ensure all other unused pins are disabled and muted. */
4393         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4394         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4395         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4396         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4397         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4398         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4399         /* Disable digital (SPDIF) pins */
4400         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4401         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4402
4403         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4404          * bus when acting as outputs.
4405          */
4406         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4407         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4408
4409         /* Start with output sum widgets muted and their output gains at min */
4410         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4411         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4412         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4413         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4414         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4415         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4416         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4417         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4418         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4419
4420         /* Unmute Line-out pin widget amp left and right
4421          * (no equiv mixer ctrl)
4422          */
4423         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4424         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4425         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4426         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4427          * inputs. If the pin mode is changed by the user the pin mode control
4428          * will take care of enabling the pin's input/output buffers as needed.
4429          * Therefore there's no need to enable the input buffer at this
4430          * stage.
4431          */
4432         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4433         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4434
4435         /* Mute capture amp left and right */
4436         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4437         /* Set ADC connection select to match default mixer setting - mic
4438          * (on mic1 pin)
4439          */
4440         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4441
4442         /* Do similar with the second ADC: mute capture input amp and
4443          * set ADC connection to mic to match ALSA's default state.
4444          */
4445         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4446         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4447
4448         /* Mute all inputs to mixer widget (even unconnected ones) */
4449         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4450         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4451         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4453         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4454         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4455         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4456         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4457
4458         { }
4459 };
4460
4461 static struct hda_verb alc260_will_verbs[] = {
4462         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4463         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4464         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4465         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4466         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4467         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4468         {}
4469 };
4470
4471 static struct hda_verb alc260_replacer_672v_verbs[] = {
4472         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4473         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4474         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4475
4476         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4477         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4478         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4479
4480         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4481         {}
4482 };
4483
4484 /* toggle speaker-output according to the hp-jack state */
4485 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4486 {
4487         unsigned int present;
4488
4489         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4490         present = snd_hda_codec_read(codec, 0x0f, 0,
4491                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4492         if (present) {
4493                 snd_hda_codec_write_cache(codec, 0x01, 0,
4494                                           AC_VERB_SET_GPIO_DATA, 1);
4495                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4496                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4497                                           PIN_HP);
4498         } else {
4499                 snd_hda_codec_write_cache(codec, 0x01, 0,
4500                                           AC_VERB_SET_GPIO_DATA, 0);
4501                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4502                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4503                                           PIN_OUT);
4504         }
4505 }
4506
4507 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4508                                        unsigned int res)
4509 {
4510         if ((res >> 26) == ALC880_HP_EVENT)
4511                 alc260_replacer_672v_automute(codec);
4512 }
4513
4514 /* Test configuration for debugging, modelled after the ALC880 test
4515  * configuration.
4516  */
4517 #ifdef CONFIG_SND_DEBUG
4518 static hda_nid_t alc260_test_dac_nids[1] = {
4519         0x02,
4520 };
4521 static hda_nid_t alc260_test_adc_nids[2] = {
4522         0x04, 0x05,
4523 };
4524 /* For testing the ALC260, each input MUX needs its own definition since
4525  * the signal assignments are different.  This assumes that the first ADC
4526  * is NID 0x04.
4527  */
4528 static struct hda_input_mux alc260_test_capture_sources[2] = {
4529         {
4530                 .num_items = 7,
4531                 .items = {
4532                         { "MIC1 pin", 0x0 },
4533                         { "MIC2 pin", 0x1 },
4534                         { "LINE1 pin", 0x2 },
4535                         { "LINE2 pin", 0x3 },
4536                         { "CD pin", 0x4 },
4537                         { "LINE-OUT pin", 0x5 },
4538                         { "HP-OUT pin", 0x6 },
4539                 },
4540         },
4541         {
4542                 .num_items = 8,
4543                 .items = {
4544                         { "MIC1 pin", 0x0 },
4545                         { "MIC2 pin", 0x1 },
4546                         { "LINE1 pin", 0x2 },
4547                         { "LINE2 pin", 0x3 },
4548                         { "CD pin", 0x4 },
4549                         { "Mixer", 0x5 },
4550                         { "LINE-OUT pin", 0x6 },
4551                         { "HP-OUT pin", 0x7 },
4552                 },
4553         },
4554 };
4555 static struct snd_kcontrol_new alc260_test_mixer[] = {
4556         /* Output driver widgets */
4557         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4558         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4559         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4560         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4561         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4562         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4563
4564         /* Modes for retasking pin widgets
4565          * Note: the ALC260 doesn't seem to act on requests to enable mic
4566          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
4567          * mention this restriction.  At this stage it's not clear whether
4568          * this behaviour is intentional or is a hardware bug in chip
4569          * revisions available at least up until early 2006.  Therefore for
4570          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4571          * choices, but if it turns out that the lack of mic bias for these
4572          * NIDs is intentional we could change their modes from
4573          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4574          */
4575         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4576         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4577         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4578         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4579         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4580         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4581
4582         /* Loopback mixer controls */
4583         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4584         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4585         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4586         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4587         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4588         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4589         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4590         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4591         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4592         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4593         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4594         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4595         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4596         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4597         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4598         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4599
4600         /* Controls for GPIO pins, assuming they are configured as outputs */
4601         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4602         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4603         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4604         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4605
4606         /* Switches to allow the digital IO pins to be enabled.  The datasheet
4607          * is ambigious as to which NID is which; testing on laptops which
4608          * make this output available should provide clarification.
4609          */
4610         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4611         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4612
4613         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
4614          * this output to turn on an external amplifier.
4615          */
4616         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4617         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4618
4619         { } /* end */
4620 };
4621 static struct hda_verb alc260_test_init_verbs[] = {
4622         /* Enable all GPIOs as outputs with an initial value of 0 */
4623         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4624         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4625         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4626
4627         /* Enable retasking pins as output, initially without power amp */
4628         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4629         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4630         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4631         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4632         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4633         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4634
4635         /* Disable digital (SPDIF) pins initially, but users can enable
4636          * them via a mixer switch.  In the case of SPDIF-out, this initverb
4637          * payload also sets the generation to 0, output to be in "consumer"
4638          * PCM format, copyright asserted, no pre-emphasis and no validity
4639          * control.
4640          */
4641         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4642         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4643
4644         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4645          * OUT1 sum bus when acting as an output.
4646          */
4647         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4648         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
4649         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4650         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
4651
4652         /* Start with output sum widgets muted and their output gains at min */
4653         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4654         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4655         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4656         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4657         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4658         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4659         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4660         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4661         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4662
4663         /* Unmute retasking pin widget output buffers since the default
4664          * state appears to be output.  As the pin mode is changed by the
4665          * user the pin mode control will take care of enabling the pin's
4666          * input/output buffers as needed.
4667          */
4668         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4669         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4670         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4671         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4672         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4673         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4674         /* Also unmute the mono-out pin widget */
4675         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4676
4677         /* Mute capture amp left and right */
4678         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4679         /* Set ADC connection select to match default mixer setting (mic1
4680          * pin)
4681          */
4682         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4683
4684         /* Do the same for the second ADC: mute capture input amp and
4685          * set ADC connection to mic1 pin
4686          */
4687         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4688         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4689
4690         /* Mute all inputs to mixer widget (even unconnected ones) */
4691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4692         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4693         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4694         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4695         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4696         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4697         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4698         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4699
4700         { }
4701 };
4702 #endif
4703
4704 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
4705 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
4706
4707 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
4708 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
4709
4710 /*
4711  * for BIOS auto-configuration
4712  */
4713
4714 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
4715                                         const char *pfx)
4716 {
4717         hda_nid_t nid_vol;
4718         unsigned long vol_val, sw_val;
4719         char name[32];
4720         int err;
4721
4722         if (nid >= 0x0f && nid < 0x11) {
4723                 nid_vol = nid - 0x7;
4724                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4725                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4726         } else if (nid == 0x11) {
4727                 nid_vol = nid - 0x7;
4728                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
4729                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
4730         } else if (nid >= 0x12 && nid <= 0x15) {
4731                 nid_vol = 0x08;
4732                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
4733                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
4734         } else
4735                 return 0; /* N/A */
4736
4737         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
4738         err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
4739         if (err < 0)
4740                 return err;
4741         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
4742         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
4743         if (err < 0)
4744                 return err;
4745         return 1;
4746 }
4747
4748 /* add playback controls from the parsed DAC table */
4749 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
4750                                              const struct auto_pin_cfg *cfg)
4751 {
4752         hda_nid_t nid;
4753         int err;
4754
4755         spec->multiout.num_dacs = 1;
4756         spec->multiout.dac_nids = spec->private_dac_nids;
4757         spec->multiout.dac_nids[0] = 0x02;
4758
4759         nid = cfg->line_out_pins[0];
4760         if (nid) {
4761                 err = alc260_add_playback_controls(spec, nid, "Front");
4762                 if (err < 0)
4763                         return err;
4764         }
4765
4766         nid = cfg->speaker_pins[0];
4767         if (nid) {
4768                 err = alc260_add_playback_controls(spec, nid, "Speaker");
4769                 if (err < 0)
4770                         return err;
4771         }
4772
4773         nid = cfg->hp_pins[0];
4774         if (nid) {
4775                 err = alc260_add_playback_controls(spec, nid, "Headphone");
4776                 if (err < 0)
4777                         return err;
4778         }
4779         return 0;
4780 }
4781
4782 /* create playback/capture controls for input pins */
4783 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
4784                                                 const struct auto_pin_cfg *cfg)
4785 {
4786         struct hda_input_mux *imux = &spec->private_imux;
4787         int i, err, idx;
4788
4789         for (i = 0; i < AUTO_PIN_LAST; i++) {
4790                 if (cfg->input_pins[i] >= 0x12) {
4791                         idx = cfg->input_pins[i] - 0x12;
4792                         err = new_analog_input(spec, cfg->input_pins[i],
4793                                                auto_pin_cfg_labels[i], idx,
4794                                                0x07);
4795                         if (err < 0)
4796                                 return err;
4797                         imux->items[imux->num_items].label =
4798                                 auto_pin_cfg_labels[i];
4799                         imux->items[imux->num_items].index = idx;
4800                         imux->num_items++;
4801                 }
4802                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
4803                         idx = cfg->input_pins[i] - 0x09;
4804                         err = new_analog_input(spec, cfg->input_pins[i],
4805                                                auto_pin_cfg_labels[i], idx,
4806                                                0x07);
4807                         if (err < 0)
4808                                 return err;
4809                         imux->items[imux->num_items].label =
4810                                 auto_pin_cfg_labels[i];
4811                         imux->items[imux->num_items].index = idx;
4812                         imux->num_items++;
4813                 }
4814         }
4815         return 0;
4816 }
4817
4818 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
4819                                               hda_nid_t nid, int pin_type,
4820                                               int sel_idx)
4821 {
4822         alc_set_pin_output(codec, nid, pin_type);
4823         /* need the manual connection? */
4824         if (nid >= 0x12) {
4825                 int idx = nid - 0x12;
4826                 snd_hda_codec_write(codec, idx + 0x0b, 0,
4827                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
4828         }
4829 }
4830
4831 static void alc260_auto_init_multi_out(struct hda_codec *codec)
4832 {
4833         struct alc_spec *spec = codec->spec;
4834         hda_nid_t nid;
4835
4836         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
4837         nid = spec->autocfg.line_out_pins[0];
4838         if (nid) {
4839                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4840                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
4841         }
4842
4843         nid = spec->autocfg.speaker_pins[0];
4844         if (nid)
4845                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
4846
4847         nid = spec->autocfg.hp_pins[0];
4848         if (nid)
4849                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
4850 }
4851
4852 #define ALC260_PIN_CD_NID               0x16
4853 static void alc260_auto_init_analog_input(struct hda_codec *codec)
4854 {
4855         struct alc_spec *spec = codec->spec;
4856         int i;
4857
4858         for (i = 0; i < AUTO_PIN_LAST; i++) {
4859                 hda_nid_t nid = spec->autocfg.input_pins[i];
4860                 if (nid >= 0x12) {
4861                         snd_hda_codec_write(codec, nid, 0,
4862                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
4863                                             i <= AUTO_PIN_FRONT_MIC ?
4864                                             PIN_VREF80 : PIN_IN);
4865                         if (nid != ALC260_PIN_CD_NID)
4866                                 snd_hda_codec_write(codec, nid, 0,
4867                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4868                                                     AMP_OUT_MUTE);
4869                 }
4870         }
4871 }
4872
4873 /*
4874  * generic initialization of ADC, input mixers and output mixers
4875  */
4876 static struct hda_verb alc260_volume_init_verbs[] = {
4877         /*
4878          * Unmute ADC0-1 and set the default input to mic-in
4879          */
4880         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4881         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4882         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4883         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4884
4885         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4886          * mixer widget
4887          * Note: PASD motherboards uses the Line In 2 as the input for
4888          * front panel mic (mic 2)
4889          */
4890         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
4891         /* mute analog inputs */
4892         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4893         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4894         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4895         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4896         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4897
4898         /*
4899          * Set up output mixers (0x08 - 0x0a)
4900          */
4901         /* set vol=0 to output mixers */
4902         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4903         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4904         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4905         /* set up input amps for analog loopback */
4906         /* Amp Indices: DAC = 0, mixer = 1 */
4907         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4908         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4909         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4910         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4911         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4912         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4913
4914         { }
4915 };
4916
4917 static int alc260_parse_auto_config(struct hda_codec *codec)
4918 {
4919         struct alc_spec *spec = codec->spec;
4920         unsigned int wcap;
4921         int err;
4922         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
4923
4924         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4925                                            alc260_ignore);
4926         if (err < 0)
4927                 return err;
4928         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
4929         if (err < 0)
4930                 return err;
4931         if (!spec->kctl_alloc)
4932                 return 0; /* can't find valid BIOS pin config */
4933         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
4934         if (err < 0)
4935                 return err;
4936
4937         spec->multiout.max_channels = 2;
4938
4939         if (spec->autocfg.dig_out_pin)
4940                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
4941         if (spec->kctl_alloc)
4942                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
4943
4944         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
4945
4946         spec->num_mux_defs = 1;
4947         spec->input_mux = &spec->private_imux;
4948
4949         /* check whether NID 0x04 is valid */
4950         wcap = get_wcaps(codec, 0x04);
4951         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
4952         if (wcap != AC_WID_AUD_IN) {
4953                 spec->adc_nids = alc260_adc_nids_alt;
4954                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
4955                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
4956         } else {
4957                 spec->adc_nids = alc260_adc_nids;
4958                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
4959                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
4960         }
4961         spec->num_mixers++;
4962
4963         return 1;
4964 }
4965
4966 /* additional initialization for auto-configuration model */
4967 static void alc260_auto_init(struct hda_codec *codec)
4968 {
4969         struct alc_spec *spec = codec->spec;
4970         alc260_auto_init_multi_out(codec);
4971         alc260_auto_init_analog_input(codec);
4972         if (spec->unsol_event)
4973                 alc_sku_automute(codec);
4974 }
4975
4976 #ifdef CONFIG_SND_HDA_POWER_SAVE
4977 static struct hda_amp_list alc260_loopbacks[] = {
4978         { 0x07, HDA_INPUT, 0 },
4979         { 0x07, HDA_INPUT, 1 },
4980         { 0x07, HDA_INPUT, 2 },
4981         { 0x07, HDA_INPUT, 3 },
4982         { 0x07, HDA_INPUT, 4 },
4983         { } /* end */
4984 };
4985 #endif
4986
4987 /*
4988  * ALC260 configurations
4989  */
4990 static const char *alc260_models[ALC260_MODEL_LAST] = {
4991         [ALC260_BASIC]          = "basic",
4992         [ALC260_HP]             = "hp",
4993         [ALC260_HP_3013]        = "hp-3013",
4994         [ALC260_FUJITSU_S702X]  = "fujitsu",
4995         [ALC260_ACER]           = "acer",
4996         [ALC260_WILL]           = "will",
4997         [ALC260_REPLACER_672V]  = "replacer",
4998 #ifdef CONFIG_SND_DEBUG
4999         [ALC260_TEST]           = "test",
5000 #endif
5001         [ALC260_AUTO]           = "auto",
5002 };
5003
5004 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5005         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5006         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5007         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5008         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5009         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5010         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP),
5011         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_3013),
5012         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5013         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5014         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5015         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5016         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5017         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5018         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5019         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5020         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5021         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5022         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5023         {}
5024 };
5025
5026 static struct alc_config_preset alc260_presets[] = {
5027         [ALC260_BASIC] = {
5028                 .mixers = { alc260_base_output_mixer,
5029                             alc260_input_mixer,
5030                             alc260_pc_beep_mixer,
5031                             alc260_capture_mixer },
5032                 .init_verbs = { alc260_init_verbs },
5033                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5034                 .dac_nids = alc260_dac_nids,
5035                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5036                 .adc_nids = alc260_adc_nids,
5037                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5038                 .channel_mode = alc260_modes,
5039                 .input_mux = &alc260_capture_source,
5040         },
5041         [ALC260_HP] = {
5042                 .mixers = { alc260_hp_output_mixer,
5043                             alc260_input_mixer,
5044                             alc260_capture_alt_mixer },
5045                 .init_verbs = { alc260_init_verbs,
5046                                 alc260_hp_unsol_verbs },
5047                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5048                 .dac_nids = alc260_dac_nids,
5049                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5050                 .adc_nids = alc260_hp_adc_nids,
5051                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5052                 .channel_mode = alc260_modes,
5053                 .input_mux = &alc260_capture_source,
5054                 .unsol_event = alc260_hp_unsol_event,
5055                 .init_hook = alc260_hp_automute,
5056         },
5057         [ALC260_HP_3013] = {
5058                 .mixers = { alc260_hp_3013_mixer,
5059                             alc260_input_mixer,
5060                             alc260_capture_alt_mixer },
5061                 .init_verbs = { alc260_hp_3013_init_verbs,
5062                                 alc260_hp_3013_unsol_verbs },
5063                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5064                 .dac_nids = alc260_dac_nids,
5065                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5066                 .adc_nids = alc260_hp_adc_nids,
5067                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5068                 .channel_mode = alc260_modes,
5069                 .input_mux = &alc260_capture_source,
5070                 .unsol_event = alc260_hp_3013_unsol_event,
5071                 .init_hook = alc260_hp_3013_automute,
5072         },
5073         [ALC260_FUJITSU_S702X] = {
5074                 .mixers = { alc260_fujitsu_mixer,
5075                             alc260_capture_mixer },
5076                 .init_verbs = { alc260_fujitsu_init_verbs },
5077                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5078                 .dac_nids = alc260_dac_nids,
5079                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5080                 .adc_nids = alc260_dual_adc_nids,
5081                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5082                 .channel_mode = alc260_modes,
5083                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5084                 .input_mux = alc260_fujitsu_capture_sources,
5085         },
5086         [ALC260_ACER] = {
5087                 .mixers = { alc260_acer_mixer,
5088                             alc260_capture_mixer },
5089                 .init_verbs = { alc260_acer_init_verbs },
5090                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5091                 .dac_nids = alc260_dac_nids,
5092                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5093                 .adc_nids = alc260_dual_adc_nids,
5094                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5095                 .channel_mode = alc260_modes,
5096                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5097                 .input_mux = alc260_acer_capture_sources,
5098         },
5099         [ALC260_WILL] = {
5100                 .mixers = { alc260_will_mixer,
5101                             alc260_capture_mixer },
5102                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5103                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5104                 .dac_nids = alc260_dac_nids,
5105                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5106                 .adc_nids = alc260_adc_nids,
5107                 .dig_out_nid = ALC260_DIGOUT_NID,
5108                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5109                 .channel_mode = alc260_modes,
5110                 .input_mux = &alc260_capture_source,
5111         },
5112         [ALC260_REPLACER_672V] = {
5113                 .mixers = { alc260_replacer_672v_mixer,
5114                             alc260_capture_mixer },
5115                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5116                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5117                 .dac_nids = alc260_dac_nids,
5118                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5119                 .adc_nids = alc260_adc_nids,
5120                 .dig_out_nid = ALC260_DIGOUT_NID,
5121                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5122                 .channel_mode = alc260_modes,
5123                 .input_mux = &alc260_capture_source,
5124                 .unsol_event = alc260_replacer_672v_unsol_event,
5125                 .init_hook = alc260_replacer_672v_automute,
5126         },
5127 #ifdef CONFIG_SND_DEBUG
5128         [ALC260_TEST] = {
5129                 .mixers = { alc260_test_mixer,
5130                             alc260_capture_mixer },
5131                 .init_verbs = { alc260_test_init_verbs },
5132                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5133                 .dac_nids = alc260_test_dac_nids,
5134                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5135                 .adc_nids = alc260_test_adc_nids,
5136                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5137                 .channel_mode = alc260_modes,
5138                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5139                 .input_mux = alc260_test_capture_sources,
5140         },
5141 #endif
5142 };
5143
5144 static int patch_alc260(struct hda_codec *codec)
5145 {
5146         struct alc_spec *spec;
5147         int err, board_config;
5148
5149         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5150         if (spec == NULL)
5151                 return -ENOMEM;
5152
5153         codec->spec = spec;
5154
5155         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5156                                                   alc260_models,
5157                                                   alc260_cfg_tbl);
5158         if (board_config < 0) {
5159                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5160                            "trying auto-probe from BIOS...\n");
5161                 board_config = ALC260_AUTO;
5162         }
5163
5164         if (board_config == ALC260_AUTO) {
5165                 /* automatic parse from the BIOS config */
5166                 err = alc260_parse_auto_config(codec);
5167                 if (err < 0) {
5168                         alc_free(codec);
5169                         return err;
5170                 } else if (!err) {
5171                         printk(KERN_INFO
5172                                "hda_codec: Cannot set up configuration "
5173                                "from BIOS.  Using base mode...\n");
5174                         board_config = ALC260_BASIC;
5175                 }
5176         }
5177
5178         if (board_config != ALC260_AUTO)
5179                 setup_preset(spec, &alc260_presets[board_config]);
5180
5181         spec->stream_name_analog = "ALC260 Analog";
5182         spec->stream_analog_playback = &alc260_pcm_analog_playback;
5183         spec->stream_analog_capture = &alc260_pcm_analog_capture;
5184
5185         spec->stream_name_digital = "ALC260 Digital";
5186         spec->stream_digital_playback = &alc260_pcm_digital_playback;
5187         spec->stream_digital_capture = &alc260_pcm_digital_capture;
5188
5189         spec->vmaster_nid = 0x08;
5190
5191         codec->patch_ops = alc_patch_ops;
5192         if (board_config == ALC260_AUTO)
5193                 spec->init_hook = alc260_auto_init;
5194 #ifdef CONFIG_SND_HDA_POWER_SAVE
5195         if (!spec->loopback.amplist)
5196                 spec->loopback.amplist = alc260_loopbacks;
5197 #endif
5198
5199         return 0;
5200 }
5201
5202
5203 /*
5204  * ALC882 support
5205  *
5206  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5207  * configuration.  Each pin widget can choose any input DACs and a mixer.
5208  * Each ADC is connected from a mixer of all inputs.  This makes possible
5209  * 6-channel independent captures.
5210  *
5211  * In addition, an independent DAC for the multi-playback (not used in this
5212  * driver yet).
5213  */
5214 #define ALC882_DIGOUT_NID       0x06
5215 #define ALC882_DIGIN_NID        0x0a
5216
5217 static struct hda_channel_mode alc882_ch_modes[1] = {
5218         { 8, NULL }
5219 };
5220
5221 static hda_nid_t alc882_dac_nids[4] = {
5222         /* front, rear, clfe, rear_surr */
5223         0x02, 0x03, 0x04, 0x05
5224 };
5225
5226 /* identical with ALC880 */
5227 #define alc882_adc_nids         alc880_adc_nids
5228 #define alc882_adc_nids_alt     alc880_adc_nids_alt
5229
5230 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5231 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5232
5233 /* input MUX */
5234 /* FIXME: should be a matrix-type input source selection */
5235
5236 static struct hda_input_mux alc882_capture_source = {
5237         .num_items = 4,
5238         .items = {
5239                 { "Mic", 0x0 },
5240                 { "Front Mic", 0x1 },
5241                 { "Line", 0x2 },
5242                 { "CD", 0x4 },
5243         },
5244 };
5245 #define alc882_mux_enum_info alc_mux_enum_info
5246 #define alc882_mux_enum_get alc_mux_enum_get
5247
5248 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5249                                struct snd_ctl_elem_value *ucontrol)
5250 {
5251         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5252         struct alc_spec *spec = codec->spec;
5253         const struct hda_input_mux *imux = spec->input_mux;
5254         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5255         hda_nid_t nid = spec->capsrc_nids[adc_idx];
5256         unsigned int *cur_val = &spec->cur_mux[adc_idx];
5257         unsigned int i, idx;
5258
5259         idx = ucontrol->value.enumerated.item[0];
5260         if (idx >= imux->num_items)
5261                 idx = imux->num_items - 1;
5262         if (*cur_val == idx)
5263                 return 0;
5264         for (i = 0; i < imux->num_items; i++) {
5265                 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5266                 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5267                                          imux->items[i].index,
5268                                          HDA_AMP_MUTE, v);
5269         }
5270         *cur_val = idx;
5271         return 1;
5272 }
5273
5274 /*
5275  * 2ch mode
5276  */
5277 static struct hda_verb alc882_3ST_ch2_init[] = {
5278         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5279         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5280         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5281         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5282         { } /* end */
5283 };
5284
5285 /*
5286  * 6ch mode
5287  */
5288 static struct hda_verb alc882_3ST_ch6_init[] = {
5289         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5290         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5291         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5292         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5293         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5294         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5295         { } /* end */
5296 };
5297
5298 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5299         { 2, alc882_3ST_ch2_init },
5300         { 6, alc882_3ST_ch6_init },
5301 };
5302
5303 /*
5304  * 6ch mode
5305  */
5306 static struct hda_verb alc882_sixstack_ch6_init[] = {
5307         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5308         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5309         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5310         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5311         { } /* end */
5312 };
5313
5314 /*
5315  * 8ch mode
5316  */
5317 static struct hda_verb alc882_sixstack_ch8_init[] = {
5318         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5319         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5320         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5321         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5322         { } /* end */
5323 };
5324
5325 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5326         { 6, alc882_sixstack_ch6_init },
5327         { 8, alc882_sixstack_ch8_init },
5328 };
5329
5330 /*
5331  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5332  */
5333
5334 /*
5335  * 2ch mode
5336  */
5337 static struct hda_verb alc885_mbp_ch2_init[] = {
5338         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5339         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5340         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5341         { } /* end */
5342 };
5343
5344 /*
5345  * 6ch mode
5346  */
5347 static struct hda_verb alc885_mbp_ch6_init[] = {
5348         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5349         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5350         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5351         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5352         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5353         { } /* end */
5354 };
5355
5356 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5357         { 2, alc885_mbp_ch2_init },
5358         { 6, alc885_mbp_ch6_init },
5359 };
5360
5361
5362 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5363  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5364  */
5365 static struct snd_kcontrol_new alc882_base_mixer[] = {
5366         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5367         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5368         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5369         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5370         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5371         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5372         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5373         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5374         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5375         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5376         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5377         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5378         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5379         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5380         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5381         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5382         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5383         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5384         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5385         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5386         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5387         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5388         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5389         { } /* end */
5390 };
5391
5392 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5393         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5394         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5395         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5396         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5397         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5398         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5399         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5400         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5401         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5402         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5403         { } /* end */
5404 };
5405 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5406         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5407         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5408         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5409         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5410         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5411         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5412         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5413         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5414         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5415         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5416         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5417         { } /* end */
5418 };
5419
5420 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5421         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5422         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5423         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5424         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5425         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5426         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5427         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5428         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5429         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5430         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5431         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5432         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5433         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5434         { } /* end */
5435 };
5436
5437 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5438  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5439  */
5440 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5441         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5442         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5443         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5444         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5445         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5446         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5447         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5448         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5449         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5450         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5451         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5452         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5453         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5454         { } /* end */
5455 };
5456
5457 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5458         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5459         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5460         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5461         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5462         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5463         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5464         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5465         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5466         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5467         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5468         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5469         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5470         { } /* end */
5471 };
5472
5473 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5474         {
5475                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5476                 .name = "Channel Mode",
5477                 .info = alc_ch_mode_info,
5478                 .get = alc_ch_mode_get,
5479                 .put = alc_ch_mode_put,
5480         },
5481         { } /* end */
5482 };
5483
5484 static struct hda_verb alc882_init_verbs[] = {
5485         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5486         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5487         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5488         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5489         /* Rear mixer */
5490         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5491         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5492         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5493         /* CLFE mixer */
5494         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5495         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5496         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5497         /* Side mixer */
5498         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5499         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5500         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5501
5502         /* Front Pin: output 0 (0x0c) */
5503         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5504         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5505         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5506         /* Rear Pin: output 1 (0x0d) */
5507         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5508         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5509         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5510         /* CLFE Pin: output 2 (0x0e) */
5511         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5512         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5513         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5514         /* Side Pin: output 3 (0x0f) */
5515         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5516         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5517         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5518         /* Mic (rear) pin: input vref at 80% */
5519         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5520         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5521         /* Front Mic pin: input vref at 80% */
5522         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5523         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5524         /* Line In pin: input */
5525         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5526         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5527         /* Line-2 In: Headphone output (output 0 - 0x0c) */
5528         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5529         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5530         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5531         /* CD pin widget for input */
5532         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5533
5534         /* FIXME: use matrix-type input source selection */
5535         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5536         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5537         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5538         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5539         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5540         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5541         /* Input mixer2 */
5542         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5543         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5544         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5545         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5546         /* Input mixer3 */
5547         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5548         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5549         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5550         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5551         /* ADC1: mute amp left and right */
5552         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5553         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5554         /* ADC2: mute amp left and right */
5555         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5556         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5557         /* ADC3: mute amp left and right */
5558         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5559         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5560
5561         { }
5562 };
5563
5564 static struct hda_verb alc882_eapd_verbs[] = {
5565         /* change to EAPD mode */
5566         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5567         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5568         { }
5569 };
5570
5571 /* Mac Pro test */
5572 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5573         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5574         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5575         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5576         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5577         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5578         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5579         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5580         { } /* end */
5581 };
5582
5583 static struct hda_verb alc882_macpro_init_verbs[] = {
5584         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5585         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5586         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5587         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5588         /* Front Pin: output 0 (0x0c) */
5589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5590         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5591         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5592         /* Front Mic pin: input vref at 80% */
5593         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5594         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5595         /* Speaker:  output */
5596         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5597         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5598         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5599         /* Headphone output (output 0 - 0x0c) */
5600         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5601         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5602         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5603
5604         /* FIXME: use matrix-type input source selection */
5605         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5606         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5607         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5608         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5609         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5611         /* Input mixer2 */
5612         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5613         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5614         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5616         /* Input mixer3 */
5617         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5621         /* ADC1: mute amp left and right */
5622         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5623         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5624         /* ADC2: mute amp left and right */
5625         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5626         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5627         /* ADC3: mute amp left and right */
5628         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5629         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5630
5631         { }
5632 };
5633
5634 /* Macbook Pro rev3 */
5635 static struct hda_verb alc885_mbp3_init_verbs[] = {
5636         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5637         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5638         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5639         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5640         /* Rear mixer */
5641         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5642         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5643         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5644         /* Front Pin: output 0 (0x0c) */
5645         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5646         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5647         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5648         /* HP Pin: output 0 (0x0d) */
5649         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
5650         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5651         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5652         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5653         /* Mic (rear) pin: input vref at 80% */
5654         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5655         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5656         /* Front Mic pin: input vref at 80% */
5657         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5658         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5659         /* Line In pin: use output 1 when in LineOut mode */
5660         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5661         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5662         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
5663
5664         /* FIXME: use matrix-type input source selection */
5665         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5666         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5667         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5668         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5669         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5670         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5671         /* Input mixer2 */
5672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5673         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5674         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5675         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5676         /* Input mixer3 */
5677         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5678         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5679         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5680         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5681         /* ADC1: mute amp left and right */
5682         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5683         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5684         /* ADC2: mute amp left and right */
5685         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5686         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5687         /* ADC3: mute amp left and right */
5688         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5689         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5690
5691         { }
5692 };
5693
5694 /* iMac 24 mixer. */
5695 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
5696         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5697         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
5698         { } /* end */
5699 };
5700
5701 /* iMac 24 init verbs. */
5702 static struct hda_verb alc885_imac24_init_verbs[] = {
5703         /* Internal speakers: output 0 (0x0c) */
5704         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5705         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5706         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5707         /* Internal speakers: output 0 (0x0c) */
5708         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5709         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5710         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
5711         /* Headphone: output 0 (0x0c) */
5712         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5713         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5714         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5715         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5716         /* Front Mic: input vref at 80% */
5717         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5718         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5719         { }
5720 };
5721
5722 /* Toggle speaker-output according to the hp-jack state */
5723 static void alc885_imac24_automute(struct hda_codec *codec)
5724 {
5725         unsigned int present;
5726
5727         present = snd_hda_codec_read(codec, 0x14, 0,
5728                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5729         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
5730                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5731         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
5732                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5733 }
5734
5735 /* Processes unsolicited events. */
5736 static void alc885_imac24_unsol_event(struct hda_codec *codec,
5737                                       unsigned int res)
5738 {
5739         /* Headphone insertion or removal. */
5740         if ((res >> 26) == ALC880_HP_EVENT)
5741                 alc885_imac24_automute(codec);
5742 }
5743
5744 static void alc885_mbp3_automute(struct hda_codec *codec)
5745 {
5746         unsigned int present;
5747
5748         present = snd_hda_codec_read(codec, 0x15, 0,
5749                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5750         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
5751                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5752         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
5753                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
5754
5755 }
5756 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
5757                                     unsigned int res)
5758 {
5759         /* Headphone insertion or removal. */
5760         if ((res >> 26) == ALC880_HP_EVENT)
5761                 alc885_mbp3_automute(codec);
5762 }
5763
5764
5765 static struct hda_verb alc882_targa_verbs[] = {
5766         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5767         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5768
5769         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5770         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5771
5772         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5773         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5774         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5775
5776         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5777         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5778         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
5779         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
5780         { } /* end */
5781 };
5782
5783 /* toggle speaker-output according to the hp-jack state */
5784 static void alc882_targa_automute(struct hda_codec *codec)
5785 {
5786         unsigned int present;
5787
5788         present = snd_hda_codec_read(codec, 0x14, 0,
5789                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5790         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
5791                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
5792         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
5793                                   present ? 1 : 3);
5794 }
5795
5796 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
5797 {
5798         /* Looks like the unsol event is incompatible with the standard
5799          * definition.  4bit tag is placed at 26 bit!
5800          */
5801         if (((res >> 26) == ALC880_HP_EVENT)) {
5802                 alc882_targa_automute(codec);
5803         }
5804 }
5805
5806 static struct hda_verb alc882_asus_a7j_verbs[] = {
5807         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5808         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5809
5810         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5811         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5812         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5813
5814         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5815         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5816         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5817
5818         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5819         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5820         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5821         { } /* end */
5822 };
5823
5824 static struct hda_verb alc882_asus_a7m_verbs[] = {
5825         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5826         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5827
5828         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5829         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5830         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5831
5832         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5833         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5834         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
5835
5836         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
5837         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
5838         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
5839         { } /* end */
5840 };
5841
5842 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
5843 {
5844         unsigned int gpiostate, gpiomask, gpiodir;
5845
5846         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
5847                                        AC_VERB_GET_GPIO_DATA, 0);
5848
5849         if (!muted)
5850                 gpiostate |= (1 << pin);
5851         else
5852                 gpiostate &= ~(1 << pin);
5853
5854         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
5855                                       AC_VERB_GET_GPIO_MASK, 0);
5856         gpiomask |= (1 << pin);
5857
5858         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
5859                                      AC_VERB_GET_GPIO_DIRECTION, 0);
5860         gpiodir |= (1 << pin);
5861
5862
5863         snd_hda_codec_write(codec, codec->afg, 0,
5864                             AC_VERB_SET_GPIO_MASK, gpiomask);
5865         snd_hda_codec_write(codec, codec->afg, 0,
5866                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
5867
5868         msleep(1);
5869
5870         snd_hda_codec_write(codec, codec->afg, 0,
5871                             AC_VERB_SET_GPIO_DATA, gpiostate);
5872 }
5873
5874 /* set up GPIO at initialization */
5875 static void alc885_macpro_init_hook(struct hda_codec *codec)
5876 {
5877         alc882_gpio_mute(codec, 0, 0);
5878         alc882_gpio_mute(codec, 1, 0);
5879 }
5880
5881 /* set up GPIO and update auto-muting at initialization */
5882 static void alc885_imac24_init_hook(struct hda_codec *codec)
5883 {
5884         alc885_macpro_init_hook(codec);
5885         alc885_imac24_automute(codec);
5886 }
5887
5888 /*
5889  * generic initialization of ADC, input mixers and output mixers
5890  */
5891 static struct hda_verb alc882_auto_init_verbs[] = {
5892         /*
5893          * Unmute ADC0-2 and set the default input to mic-in
5894          */
5895         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5896         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5897         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5898         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5899         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5900         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5901
5902         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5903          * mixer widget
5904          * Note: PASD motherboards uses the Line In 2 as the input for
5905          * front panel mic (mic 2)
5906          */
5907         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5908         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5909         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5910         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5911         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5912         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5913
5914         /*
5915          * Set up output mixers (0x0c - 0x0f)
5916          */
5917         /* set vol=0 to output mixers */
5918         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5919         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5920         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5921         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5922         /* set up input amps for analog loopback */
5923         /* Amp Indices: DAC = 0, mixer = 1 */
5924         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5925         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5926         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5927         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5928         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5929         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5930         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5931         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5932         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5933         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5934
5935         /* FIXME: use matrix-type input source selection */
5936         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5937         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5938         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5939         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
5940         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
5941         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
5942         /* Input mixer2 */
5943         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5944         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
5945         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
5946         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
5947         /* Input mixer3 */
5948         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5949         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
5950         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
5951         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
5952
5953         { }
5954 };
5955
5956 /* capture mixer elements */
5957 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
5958         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
5959         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
5960         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
5961         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
5962         {
5963                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5964                 /* The multiple "Capture Source" controls confuse alsamixer
5965                  * So call somewhat different..
5966                  */
5967                 /* .name = "Capture Source", */
5968                 .name = "Input Source",
5969                 .count = 2,
5970                 .info = alc882_mux_enum_info,
5971                 .get = alc882_mux_enum_get,
5972                 .put = alc882_mux_enum_put,
5973         },
5974         { } /* end */
5975 };
5976
5977 static struct snd_kcontrol_new alc882_capture_mixer[] = {
5978         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
5979         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
5980         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
5981         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
5982         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
5983         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
5984         {
5985                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5986                 /* The multiple "Capture Source" controls confuse alsamixer
5987                  * So call somewhat different..
5988                  */
5989                 /* .name = "Capture Source", */
5990                 .name = "Input Source",
5991                 .count = 3,
5992                 .info = alc882_mux_enum_info,
5993                 .get = alc882_mux_enum_get,
5994                 .put = alc882_mux_enum_put,
5995         },
5996         { } /* end */
5997 };
5998
5999 #ifdef CONFIG_SND_HDA_POWER_SAVE
6000 #define alc882_loopbacks        alc880_loopbacks
6001 #endif
6002
6003 /* pcm configuration: identiacal with ALC880 */
6004 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6005 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6006 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6007 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6008
6009 /*
6010  * configuration and preset
6011  */
6012 static const char *alc882_models[ALC882_MODEL_LAST] = {
6013         [ALC882_3ST_DIG]        = "3stack-dig",
6014         [ALC882_6ST_DIG]        = "6stack-dig",
6015         [ALC882_ARIMA]          = "arima",
6016         [ALC882_W2JC]           = "w2jc",
6017         [ALC882_TARGA]          = "targa",
6018         [ALC882_ASUS_A7J]       = "asus-a7j",
6019         [ALC882_ASUS_A7M]       = "asus-a7m",
6020         [ALC885_MACPRO]         = "macpro",
6021         [ALC885_MBP3]           = "mbp3",
6022         [ALC885_IMAC24]         = "imac24",
6023         [ALC882_AUTO]           = "auto",
6024 };
6025
6026 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6027         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6028         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6029         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6030         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6031         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6032         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6033         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6034         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6035         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6036         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6037         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6038         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6039         {}
6040 };
6041
6042 static struct alc_config_preset alc882_presets[] = {
6043         [ALC882_3ST_DIG] = {
6044                 .mixers = { alc882_base_mixer },
6045                 .init_verbs = { alc882_init_verbs },
6046                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6047                 .dac_nids = alc882_dac_nids,
6048                 .dig_out_nid = ALC882_DIGOUT_NID,
6049                 .dig_in_nid = ALC882_DIGIN_NID,
6050                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6051                 .channel_mode = alc882_ch_modes,
6052                 .need_dac_fix = 1,
6053                 .input_mux = &alc882_capture_source,
6054         },
6055         [ALC882_6ST_DIG] = {
6056                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6057                 .init_verbs = { alc882_init_verbs },
6058                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6059                 .dac_nids = alc882_dac_nids,
6060                 .dig_out_nid = ALC882_DIGOUT_NID,
6061                 .dig_in_nid = ALC882_DIGIN_NID,
6062                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6063                 .channel_mode = alc882_sixstack_modes,
6064                 .input_mux = &alc882_capture_source,
6065         },
6066         [ALC882_ARIMA] = {
6067                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6068                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6069                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6070                 .dac_nids = alc882_dac_nids,
6071                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6072                 .channel_mode = alc882_sixstack_modes,
6073                 .input_mux = &alc882_capture_source,
6074         },
6075         [ALC882_W2JC] = {
6076                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6077                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6078                                 alc880_gpio1_init_verbs },
6079                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6080                 .dac_nids = alc882_dac_nids,
6081                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6082                 .channel_mode = alc880_threestack_modes,
6083                 .need_dac_fix = 1,
6084                 .input_mux = &alc882_capture_source,
6085                 .dig_out_nid = ALC882_DIGOUT_NID,
6086         },
6087         [ALC885_MBP3] = {
6088                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6089                 .init_verbs = { alc885_mbp3_init_verbs,
6090                                 alc880_gpio1_init_verbs },
6091                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6092                 .dac_nids = alc882_dac_nids,
6093                 .channel_mode = alc885_mbp_6ch_modes,
6094                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6095                 .input_mux = &alc882_capture_source,
6096                 .dig_out_nid = ALC882_DIGOUT_NID,
6097                 .dig_in_nid = ALC882_DIGIN_NID,
6098                 .unsol_event = alc885_mbp3_unsol_event,
6099                 .init_hook = alc885_mbp3_automute,
6100         },
6101         [ALC885_MACPRO] = {
6102                 .mixers = { alc882_macpro_mixer },
6103                 .init_verbs = { alc882_macpro_init_verbs },
6104                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6105                 .dac_nids = alc882_dac_nids,
6106                 .dig_out_nid = ALC882_DIGOUT_NID,
6107                 .dig_in_nid = ALC882_DIGIN_NID,
6108                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6109                 .channel_mode = alc882_ch_modes,
6110                 .input_mux = &alc882_capture_source,
6111                 .init_hook = alc885_macpro_init_hook,
6112         },
6113         [ALC885_IMAC24] = {
6114                 .mixers = { alc885_imac24_mixer },
6115                 .init_verbs = { alc885_imac24_init_verbs },
6116                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6117                 .dac_nids = alc882_dac_nids,
6118                 .dig_out_nid = ALC882_DIGOUT_NID,
6119                 .dig_in_nid = ALC882_DIGIN_NID,
6120                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6121                 .channel_mode = alc882_ch_modes,
6122                 .input_mux = &alc882_capture_source,
6123                 .unsol_event = alc885_imac24_unsol_event,
6124                 .init_hook = alc885_imac24_init_hook,
6125         },
6126         [ALC882_TARGA] = {
6127                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6128                             alc882_capture_mixer },
6129                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6130                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6131                 .dac_nids = alc882_dac_nids,
6132                 .dig_out_nid = ALC882_DIGOUT_NID,
6133                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6134                 .adc_nids = alc882_adc_nids,
6135                 .capsrc_nids = alc882_capsrc_nids,
6136                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6137                 .channel_mode = alc882_3ST_6ch_modes,
6138                 .need_dac_fix = 1,
6139                 .input_mux = &alc882_capture_source,
6140                 .unsol_event = alc882_targa_unsol_event,
6141                 .init_hook = alc882_targa_automute,
6142         },
6143         [ALC882_ASUS_A7J] = {
6144                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6145                             alc882_capture_mixer },
6146                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6147                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6148                 .dac_nids = alc882_dac_nids,
6149                 .dig_out_nid = ALC882_DIGOUT_NID,
6150                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6151                 .adc_nids = alc882_adc_nids,
6152                 .capsrc_nids = alc882_capsrc_nids,
6153                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6154                 .channel_mode = alc882_3ST_6ch_modes,
6155                 .need_dac_fix = 1,
6156                 .input_mux = &alc882_capture_source,
6157         },
6158         [ALC882_ASUS_A7M] = {
6159                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6160                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6161                                 alc880_gpio1_init_verbs,
6162                                 alc882_asus_a7m_verbs },
6163                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6164                 .dac_nids = alc882_dac_nids,
6165                 .dig_out_nid = ALC882_DIGOUT_NID,
6166                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6167                 .channel_mode = alc880_threestack_modes,
6168                 .need_dac_fix = 1,
6169                 .input_mux = &alc882_capture_source,
6170         },
6171 };
6172
6173
6174 /*
6175  * Pin config fixes
6176  */
6177 enum {
6178         PINFIX_ABIT_AW9D_MAX
6179 };
6180
6181 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6182         { 0x15, 0x01080104 }, /* side */
6183         { 0x16, 0x01011012 }, /* rear */
6184         { 0x17, 0x01016011 }, /* clfe */
6185         { }
6186 };
6187
6188 static const struct alc_pincfg *alc882_pin_fixes[] = {
6189         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6190 };
6191
6192 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6193         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6194         {}
6195 };
6196
6197 /*
6198  * BIOS auto configuration
6199  */
6200 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6201                                               hda_nid_t nid, int pin_type,
6202                                               int dac_idx)
6203 {
6204         /* set as output */
6205         struct alc_spec *spec = codec->spec;
6206         int idx;
6207
6208         alc_set_pin_output(codec, nid, pin_type);
6209         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6210                 idx = 4;
6211         else
6212                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6213         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6214
6215 }
6216
6217 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6218 {
6219         struct alc_spec *spec = codec->spec;
6220         int i;
6221
6222         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6223         for (i = 0; i <= HDA_SIDE; i++) {
6224                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6225                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6226                 if (nid)
6227                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6228                                                           i);
6229         }
6230 }
6231
6232 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6233 {
6234         struct alc_spec *spec = codec->spec;
6235         hda_nid_t pin;
6236
6237         pin = spec->autocfg.hp_pins[0];
6238         if (pin) /* connect to front */
6239                 /* use dac 0 */
6240                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6241         pin = spec->autocfg.speaker_pins[0];
6242         if (pin)
6243                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6244 }
6245
6246 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
6247 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
6248
6249 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6250 {
6251         struct alc_spec *spec = codec->spec;
6252         int i;
6253
6254         for (i = 0; i < AUTO_PIN_LAST; i++) {
6255                 hda_nid_t nid = spec->autocfg.input_pins[i];
6256                 if (alc882_is_input_pin(nid)) {
6257                         snd_hda_codec_write(codec, nid, 0,
6258                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
6259                                             i <= AUTO_PIN_FRONT_MIC ?
6260                                             PIN_VREF80 : PIN_IN);
6261                         if (nid != ALC882_PIN_CD_NID)
6262                                 snd_hda_codec_write(codec, nid, 0,
6263                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6264                                                     AMP_OUT_MUTE);
6265                 }
6266         }
6267 }
6268
6269 /* add mic boosts if needed */
6270 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6271 {
6272         struct alc_spec *spec = codec->spec;
6273         int err;
6274         hda_nid_t nid;
6275
6276         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6277         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6278                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6279                                   "Mic Boost",
6280                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6281                 if (err < 0)
6282                         return err;
6283         }
6284         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6285         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6286                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6287                                   "Front Mic Boost",
6288                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6289                 if (err < 0)
6290                         return err;
6291         }
6292         return 0;
6293 }
6294
6295 /* almost identical with ALC880 parser... */
6296 static int alc882_parse_auto_config(struct hda_codec *codec)
6297 {
6298         struct alc_spec *spec = codec->spec;
6299         int err = alc880_parse_auto_config(codec);
6300
6301         if (err < 0)
6302                 return err;
6303         else if (!err)
6304                 return 0; /* no config found */
6305
6306         err = alc_auto_add_mic_boost(codec);
6307         if (err < 0)
6308                 return err;
6309
6310         /* hack - override the init verbs */
6311         spec->init_verbs[0] = alc882_auto_init_verbs;
6312
6313         return 1; /* config found */
6314 }
6315
6316 /* additional initialization for auto-configuration model */
6317 static void alc882_auto_init(struct hda_codec *codec)
6318 {
6319         struct alc_spec *spec = codec->spec;
6320         alc882_auto_init_multi_out(codec);
6321         alc882_auto_init_hp_out(codec);
6322         alc882_auto_init_analog_input(codec);
6323         if (spec->unsol_event)
6324                 alc_sku_automute(codec);
6325 }
6326
6327 static int patch_alc882(struct hda_codec *codec)
6328 {
6329         struct alc_spec *spec;
6330         int err, board_config;
6331
6332         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6333         if (spec == NULL)
6334                 return -ENOMEM;
6335
6336         codec->spec = spec;
6337
6338         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6339                                                   alc882_models,
6340                                                   alc882_cfg_tbl);
6341
6342         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6343                 /* Pick up systems that don't supply PCI SSID */
6344                 switch (codec->subsystem_id) {
6345                 case 0x106b0c00: /* Mac Pro */
6346                         board_config = ALC885_MACPRO;
6347                         break;
6348                 case 0x106b1000: /* iMac 24 */
6349                         board_config = ALC885_IMAC24;
6350                         break;
6351                 case 0x106b00a1: /* Macbook */
6352                 case 0x106b2c00: /* Macbook Pro rev3 */
6353                         board_config = ALC885_MBP3;
6354                         break;
6355                 default:
6356                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6357                                          "trying auto-probe from BIOS...\n");
6358                         board_config = ALC882_AUTO;
6359                 }
6360         }
6361
6362         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6363
6364         if (board_config == ALC882_AUTO) {
6365                 /* automatic parse from the BIOS config */
6366                 err = alc882_parse_auto_config(codec);
6367                 if (err < 0) {
6368                         alc_free(codec);
6369                         return err;
6370                 } else if (!err) {
6371                         printk(KERN_INFO
6372                                "hda_codec: Cannot set up configuration "
6373                                "from BIOS.  Using base mode...\n");
6374                         board_config = ALC882_3ST_DIG;
6375                 }
6376         }
6377
6378         if (board_config != ALC882_AUTO)
6379                 setup_preset(spec, &alc882_presets[board_config]);
6380
6381         spec->stream_name_analog = "ALC882 Analog";
6382         spec->stream_analog_playback = &alc882_pcm_analog_playback;
6383         spec->stream_analog_capture = &alc882_pcm_analog_capture;
6384         /* FIXME: setup DAC5 */
6385         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6386         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6387
6388         spec->stream_name_digital = "ALC882 Digital";
6389         spec->stream_digital_playback = &alc882_pcm_digital_playback;
6390         spec->stream_digital_capture = &alc882_pcm_digital_capture;
6391
6392         if (!spec->adc_nids && spec->input_mux) {
6393                 /* check whether NID 0x07 is valid */
6394                 unsigned int wcap = get_wcaps(codec, 0x07);
6395                 /* get type */
6396                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6397                 if (wcap != AC_WID_AUD_IN) {
6398                         spec->adc_nids = alc882_adc_nids_alt;
6399                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6400                         spec->capsrc_nids = alc882_capsrc_nids_alt;
6401                         spec->mixers[spec->num_mixers] =
6402                                 alc882_capture_alt_mixer;
6403                         spec->num_mixers++;
6404                 } else {
6405                         spec->adc_nids = alc882_adc_nids;
6406                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6407                         spec->capsrc_nids = alc882_capsrc_nids;
6408                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6409                         spec->num_mixers++;
6410                 }
6411         }
6412
6413         spec->vmaster_nid = 0x0c;
6414
6415         codec->patch_ops = alc_patch_ops;
6416         if (board_config == ALC882_AUTO)
6417                 spec->init_hook = alc882_auto_init;
6418 #ifdef CONFIG_SND_HDA_POWER_SAVE
6419         if (!spec->loopback.amplist)
6420                 spec->loopback.amplist = alc882_loopbacks;
6421 #endif
6422
6423         return 0;
6424 }
6425
6426 /*
6427  * ALC883 support
6428  *
6429  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6430  * configuration.  Each pin widget can choose any input DACs and a mixer.
6431  * Each ADC is connected from a mixer of all inputs.  This makes possible
6432  * 6-channel independent captures.
6433  *
6434  * In addition, an independent DAC for the multi-playback (not used in this
6435  * driver yet).
6436  */
6437 #define ALC883_DIGOUT_NID       0x06
6438 #define ALC883_DIGIN_NID        0x0a
6439
6440 static hda_nid_t alc883_dac_nids[4] = {
6441         /* front, rear, clfe, rear_surr */
6442         0x02, 0x04, 0x03, 0x05
6443 };
6444
6445 static hda_nid_t alc883_adc_nids[2] = {
6446         /* ADC1-2 */
6447         0x08, 0x09,
6448 };
6449
6450 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6451
6452 /* input MUX */
6453 /* FIXME: should be a matrix-type input source selection */
6454
6455 static struct hda_input_mux alc883_capture_source = {
6456         .num_items = 4,
6457         .items = {
6458                 { "Mic", 0x0 },
6459                 { "Front Mic", 0x1 },
6460                 { "Line", 0x2 },
6461                 { "CD", 0x4 },
6462         },
6463 };
6464
6465 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6466         .num_items = 2,
6467         .items = {
6468                 { "Mic", 0x1 },
6469                 { "Line", 0x2 },
6470         },
6471 };
6472
6473 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6474         .num_items = 4,
6475         .items = {
6476                 { "Mic", 0x0 },
6477                 { "iMic", 0x1 },
6478                 { "Line", 0x2 },
6479                 { "CD", 0x4 },
6480         },
6481 };
6482
6483 #define alc883_mux_enum_info alc_mux_enum_info
6484 #define alc883_mux_enum_get alc_mux_enum_get
6485 /* ALC883 has the ALC882-type input selection */
6486 #define alc883_mux_enum_put alc882_mux_enum_put
6487
6488 /*
6489  * 2ch mode
6490  */
6491 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6492         { 2, NULL }
6493 };
6494
6495 /*
6496  * 2ch mode
6497  */
6498 static struct hda_verb alc883_3ST_ch2_init[] = {
6499         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6500         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6501         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6502         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6503         { } /* end */
6504 };
6505
6506 /*
6507  * 4ch mode
6508  */
6509 static struct hda_verb alc883_3ST_ch4_init[] = {
6510         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6511         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6512         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6513         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6514         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6515         { } /* end */
6516 };
6517
6518 /*
6519  * 6ch mode
6520  */
6521 static struct hda_verb alc883_3ST_ch6_init[] = {
6522         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6523         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6524         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6525         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6526         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6527         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6528         { } /* end */
6529 };
6530
6531 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
6532         { 2, alc883_3ST_ch2_init },
6533         { 4, alc883_3ST_ch4_init },
6534         { 6, alc883_3ST_ch6_init },
6535 };
6536
6537 /*
6538  * 6ch mode
6539  */
6540 static struct hda_verb alc883_sixstack_ch6_init[] = {
6541         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6542         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6543         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6544         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6545         { } /* end */
6546 };
6547
6548 /*
6549  * 8ch mode
6550  */
6551 static struct hda_verb alc883_sixstack_ch8_init[] = {
6552         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6553         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6554         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6555         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6556         { } /* end */
6557 };
6558
6559 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6560         { 6, alc883_sixstack_ch6_init },
6561         { 8, alc883_sixstack_ch8_init },
6562 };
6563
6564 static struct hda_verb alc883_medion_eapd_verbs[] = {
6565         /* eanable EAPD on medion laptop */
6566         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6567         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
6568         { }
6569 };
6570
6571 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6572  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6573  */
6574
6575 static struct snd_kcontrol_new alc883_base_mixer[] = {
6576         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6577         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6578         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6579         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6580         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6581         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6582         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6583         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6584         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6585         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6586         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6587         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6588         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6589         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6590         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6591         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6592         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6593         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6594         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6595         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6596         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6597         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6598         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6599         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6600         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6601         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6602         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6603         {
6604                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6605                 /* .name = "Capture Source", */
6606                 .name = "Input Source",
6607                 .count = 2,
6608                 .info = alc883_mux_enum_info,
6609                 .get = alc883_mux_enum_get,
6610                 .put = alc883_mux_enum_put,
6611         },
6612         { } /* end */
6613 };
6614
6615 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
6616         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6617         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6618         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6619         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6620         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6621         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6622         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6623         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6624         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6625         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6626         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6627         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6628         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6629         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6630         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6631         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6632         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6633         {
6634                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6635                 /* .name = "Capture Source", */
6636                 .name = "Input Source",
6637                 .count = 2,
6638                 .info = alc883_mux_enum_info,
6639                 .get = alc883_mux_enum_get,
6640                 .put = alc883_mux_enum_put,
6641         },
6642         { } /* end */
6643 };
6644
6645 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
6646         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6647         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6648         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6649         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6650         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6651         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6652         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6653         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6654         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6655         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6656         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6657         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6658         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6659         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6660         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6661         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6662         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6663         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6664         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6665         {
6666                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6667                 /* .name = "Capture Source", */
6668                 .name = "Input Source",
6669                 .count = 2,
6670                 .info = alc883_mux_enum_info,
6671                 .get = alc883_mux_enum_get,
6672                 .put = alc883_mux_enum_put,
6673         },
6674         { } /* end */
6675 };
6676
6677 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
6678         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6679         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6680         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6681         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6682         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6683         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6684         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6685         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6686         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6687         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6688         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6689         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6690         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6691         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6692         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6693         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6694         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6695         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6696         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6697         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6698         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6699         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6700         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6701         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6702         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6703         {
6704                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6705                 /* .name = "Capture Source", */
6706                 .name = "Input Source",
6707                 .count = 2,
6708                 .info = alc883_mux_enum_info,
6709                 .get = alc883_mux_enum_get,
6710                 .put = alc883_mux_enum_put,
6711         },
6712         { } /* end */
6713 };
6714
6715 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
6716         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6717         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6718         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6719         HDA_CODEC_MUTE("Surround Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6720         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6721         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6722         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x16, 1, 0x0, HDA_OUTPUT),
6723         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
6724         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6725         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6726         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6727         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6728         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6729         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6730         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6731         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6732         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6733         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6734         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6735         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6736         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6737         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6738         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6739
6740         {
6741                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6742                 /* .name = "Capture Source", */
6743                 .name = "Input Source",
6744                 .count = 1,
6745                 .info = alc883_mux_enum_info,
6746                 .get = alc883_mux_enum_get,
6747                 .put = alc883_mux_enum_put,
6748         },
6749         { } /* end */
6750 };
6751
6752 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
6753         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6754         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6755         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6756         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6757         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6758         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6759         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6760         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6761         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6762         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6763         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6764         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6765         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6766         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6767         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6768         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6769         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6770         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6771         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6772         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6773         {
6774                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6775                 /* .name = "Capture Source", */
6776                 .name = "Input Source",
6777                 .count = 2,
6778                 .info = alc883_mux_enum_info,
6779                 .get = alc883_mux_enum_get,
6780                 .put = alc883_mux_enum_put,
6781         },
6782         { } /* end */
6783 };
6784
6785 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
6786         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6787         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6788         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6789         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6790         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6791         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6792         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6794         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6795         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6796         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6797         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6798         {
6799                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6800                 /* .name = "Capture Source", */
6801                 .name = "Input Source",
6802                 .count = 2,
6803                 .info = alc883_mux_enum_info,
6804                 .get = alc883_mux_enum_get,
6805                 .put = alc883_mux_enum_put,
6806         },
6807         { } /* end */
6808 };
6809
6810 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
6811         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6812         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6813         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6814         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
6815         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6816         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6817         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6818         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6819         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6820         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6821         {
6822                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6823                 /* .name = "Capture Source", */
6824                 .name = "Input Source",
6825                 .count = 1,
6826                 .info = alc883_mux_enum_info,
6827                 .get = alc883_mux_enum_get,
6828                 .put = alc883_mux_enum_put,
6829         },
6830         { } /* end */
6831 };
6832
6833 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
6834         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6835         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
6836         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6837         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6838         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6839         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6840         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6841         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6842         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6843         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6844         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6845         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6846         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6847         {
6848                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6849                 /* .name = "Capture Source", */
6850                 .name = "Input Source",
6851                 .count = 2,
6852                 .info = alc883_mux_enum_info,
6853                 .get = alc883_mux_enum_get,
6854                 .put = alc883_mux_enum_put,
6855         },
6856         { } /* end */
6857 };
6858
6859 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
6860         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6861         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6862         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6863         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6864         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6865         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6866         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6867         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6868         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6869         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6870         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6871         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6872         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6873         {
6874                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6875                 /* .name = "Capture Source", */
6876                 .name = "Input Source",
6877                 .count = 2,
6878                 .info = alc883_mux_enum_info,
6879                 .get = alc883_mux_enum_get,
6880                 .put = alc883_mux_enum_put,
6881         },
6882         { } /* end */
6883 };
6884
6885 static struct snd_kcontrol_new alc888_6st_hp_mixer[] = {
6886         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6887         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6888         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
6889         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
6890         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
6891         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
6892         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
6893         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
6894         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6895         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6896         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6897         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6898         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6899         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6900         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6901         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6902         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6903         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6904         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6905         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6906         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6907         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6908         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6909         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6910         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6911         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6912         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6913         {
6914                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6915                 /* .name = "Capture Source", */
6916                 .name = "Input Source",
6917                 .count = 2,
6918                 .info = alc883_mux_enum_info,
6919                 .get = alc883_mux_enum_get,
6920                 .put = alc883_mux_enum_put,
6921         },
6922         { } /* end */
6923 };
6924
6925 static struct snd_kcontrol_new alc888_3st_hp_mixer[] = {
6926         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6927         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6928         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
6929         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
6930         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
6931         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
6932         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
6933         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
6934         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6935         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6936         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6937         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6938         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6939         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6940         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6941         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6942         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6943         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6944         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6945         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6946         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6947         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6948         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6949         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6950         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6951         {
6952                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6953                 /* .name = "Capture Source", */
6954                 .name = "Input Source",
6955                 .count = 2,
6956                 .info = alc883_mux_enum_info,
6957                 .get = alc883_mux_enum_get,
6958                 .put = alc883_mux_enum_put,
6959         },
6960         { } /* end */
6961 };
6962
6963 static struct snd_kcontrol_new alc888_6st_dell_mixer[] = {
6964         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6965         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6966         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
6967         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
6968         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
6969         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
6970         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
6971         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
6972         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6973         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6974         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6975         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6976         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6977         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6978         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6979         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6980         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6981         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6982         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6983         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6984         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6985         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
6986         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
6987         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6988         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6989         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6990         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6991         {
6992                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6993                 /* .name = "Capture Source", */
6994                 .name = "Input Source",
6995                 .count = 2,
6996                 .info = alc883_mux_enum_info,
6997                 .get = alc883_mux_enum_get,
6998                 .put = alc883_mux_enum_put,
6999         },
7000         { } /* end */
7001 };
7002
7003 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7004         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7005         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7006         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7007         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7008         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7009         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7010         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7011         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7012         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7013         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7014         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7015         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7016         {
7017                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7018                 /* .name = "Capture Source", */
7019                 .name = "Input Source",
7020                 .count = 2,
7021                 .info = alc883_mux_enum_info,
7022                 .get = alc883_mux_enum_get,
7023                 .put = alc883_mux_enum_put,
7024         },
7025         { } /* end */
7026 };
7027
7028 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7029         {
7030                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7031                 .name = "Channel Mode",
7032                 .info = alc_ch_mode_info,
7033                 .get = alc_ch_mode_get,
7034                 .put = alc_ch_mode_put,
7035         },
7036         { } /* end */
7037 };
7038
7039 static struct hda_verb alc883_init_verbs[] = {
7040         /* ADC1: mute amp left and right */
7041         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7042         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7043         /* ADC2: mute amp left and right */
7044         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7045         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7046         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7047         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7048         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7049         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7050         /* Rear mixer */
7051         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7052         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7053         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7054         /* CLFE mixer */
7055         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7056         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7057         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7058         /* Side mixer */
7059         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7060         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7061         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7062
7063         /* mute analog input loopbacks */
7064         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7065         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7066         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7067         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7068         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7069
7070         /* Front Pin: output 0 (0x0c) */
7071         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7072         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7073         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7074         /* Rear Pin: output 1 (0x0d) */
7075         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7076         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7077         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7078         /* CLFE Pin: output 2 (0x0e) */
7079         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7080         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7081         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7082         /* Side Pin: output 3 (0x0f) */
7083         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7084         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7085         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7086         /* Mic (rear) pin: input vref at 80% */
7087         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7088         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7089         /* Front Mic pin: input vref at 80% */
7090         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7091         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7092         /* Line In pin: input */
7093         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7094         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7095         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7096         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7097         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7098         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7099         /* CD pin widget for input */
7100         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7101
7102         /* FIXME: use matrix-type input source selection */
7103         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7104         /* Input mixer2 */
7105         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7106         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7107         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7108         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7109         /* Input mixer3 */
7110         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7111         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7112         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7113         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7114         { }
7115 };
7116
7117 /* toggle speaker-output according to the hp-jack state */
7118 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7119 {
7120         unsigned int present;
7121
7122         present = snd_hda_codec_read(codec, 0x15, 0,
7123                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7124         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7125                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7126         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7127                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7128 }
7129
7130 /* auto-toggle front mic */
7131 /*
7132 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7133 {
7134         unsigned int present;
7135         unsigned char bits;
7136
7137         present = snd_hda_codec_read(codec, 0x18, 0,
7138                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7139         bits = present ? HDA_AMP_MUTE : 0;
7140         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7141 }
7142 */
7143
7144 static void alc883_mitac_automute(struct hda_codec *codec)
7145 {
7146         alc883_mitac_hp_automute(codec);
7147         /* alc883_mitac_mic_automute(codec); */
7148 }
7149
7150 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7151                                            unsigned int res)
7152 {
7153         switch (res >> 26) {
7154         case ALC880_HP_EVENT:
7155                 alc883_mitac_hp_automute(codec);
7156                 break;
7157         case ALC880_MIC_EVENT:
7158                 /* alc883_mitac_mic_automute(codec); */
7159                 break;
7160         }
7161 }
7162
7163 static struct hda_verb alc883_mitac_verbs[] = {
7164         /* HP */
7165         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7166         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7167         /* Subwoofer */
7168         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7169         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7170
7171         /* enable unsolicited event */
7172         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7173         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7174
7175         { } /* end */
7176 };
7177
7178 static struct hda_verb alc883_tagra_verbs[] = {
7179         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7180         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7181
7182         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7183         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7184
7185         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7186         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7187         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7188
7189         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7190         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7191         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7192         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7193
7194         { } /* end */
7195 };
7196
7197 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7198         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7199         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7200         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7201         { } /* end */
7202 };
7203
7204 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7205         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7206         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7207         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7208         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7209         { } /* end */
7210 };
7211
7212 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7213         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7214         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7215         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7216         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7217         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7218         { } /* end */
7219 };
7220
7221 static struct hda_verb alc883_haier_w66_verbs[] = {
7222         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7223         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7224
7225         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7226
7227         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7228         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7229         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7230         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7231         { } /* end */
7232 };
7233
7234 static struct hda_verb alc888_6st_hp_verbs[] = {
7235         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7236         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},  /* Rear : output 2 (0x0e) */
7237         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* CLFE : output 1 (0x0d) */
7238         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},  /* Side : output 3 (0x0f) */
7239         { }
7240 };
7241
7242 static struct hda_verb alc888_3st_hp_verbs[] = {
7243         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7244         {0x18, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7245         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7246         { }
7247 };
7248
7249 static struct hda_verb alc888_6st_dell_verbs[] = {
7250         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7251         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},  /* Rear : output 1 (0x0e) */
7252         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* CLFE : output 2 (0x0d) */
7253         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},  /* Side : output 3 (0x0f) */
7254         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7255         { }
7256 };
7257
7258 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7259         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7260         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7261         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7262         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7263         { }
7264 };
7265
7266 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7267         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7268         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7269         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7270         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7271         { }
7272 };
7273
7274 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7275         { 2, alc888_3st_hp_2ch_init },
7276         { 6, alc888_3st_hp_6ch_init },
7277 };
7278
7279 /* toggle front-jack and RCA according to the hp-jack state */
7280 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7281 {
7282         unsigned int present;
7283
7284         present = snd_hda_codec_read(codec, 0x1b, 0,
7285                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7286         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7287                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7288         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7289                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7290 }
7291
7292 /* toggle RCA according to the front-jack state */
7293 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7294 {
7295         unsigned int present;
7296
7297         present = snd_hda_codec_read(codec, 0x14, 0,
7298                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7299         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7300                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7301 }
7302
7303 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7304                                              unsigned int res)
7305 {
7306         if ((res >> 26) == ALC880_HP_EVENT)
7307                 alc888_lenovo_ms7195_front_automute(codec);
7308         if ((res >> 26) == ALC880_FRONT_EVENT)
7309                 alc888_lenovo_ms7195_rca_automute(codec);
7310 }
7311
7312 static struct hda_verb alc883_medion_md2_verbs[] = {
7313         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7314         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7315
7316         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7317
7318         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7319         { } /* end */
7320 };
7321
7322 /* toggle speaker-output according to the hp-jack state */
7323 static void alc883_medion_md2_automute(struct hda_codec *codec)
7324 {
7325         unsigned int present;
7326
7327         present = snd_hda_codec_read(codec, 0x14, 0,
7328                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7329         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7330                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7331 }
7332
7333 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7334                                           unsigned int res)
7335 {
7336         if ((res >> 26) == ALC880_HP_EVENT)
7337                 alc883_medion_md2_automute(codec);
7338 }
7339
7340 /* toggle speaker-output according to the hp-jack state */
7341 static void alc883_tagra_automute(struct hda_codec *codec)
7342 {
7343         unsigned int present;
7344         unsigned char bits;
7345
7346         present = snd_hda_codec_read(codec, 0x14, 0,
7347                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7348         bits = present ? HDA_AMP_MUTE : 0;
7349         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7350                                  HDA_AMP_MUTE, bits);
7351         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7352                                   present ? 1 : 3);
7353 }
7354
7355 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7356 {
7357         if ((res >> 26) == ALC880_HP_EVENT)
7358                 alc883_tagra_automute(codec);
7359 }
7360
7361 static void alc883_haier_w66_automute(struct hda_codec *codec)
7362 {
7363         unsigned int present;
7364         unsigned char bits;
7365
7366         present = snd_hda_codec_read(codec, 0x1b, 0,
7367                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7368         bits = present ? 0x80 : 0;
7369         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7370                                  0x80, bits);
7371 }
7372
7373 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
7374                                          unsigned int res)
7375 {
7376         if ((res >> 26) == ALC880_HP_EVENT)
7377                 alc883_haier_w66_automute(codec);
7378 }
7379
7380 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
7381 {
7382         unsigned int present;
7383         unsigned char bits;
7384
7385         present = snd_hda_codec_read(codec, 0x14, 0,
7386                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7387         bits = present ? HDA_AMP_MUTE : 0;
7388         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7389                                  HDA_AMP_MUTE, bits);
7390 }
7391
7392 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
7393 {
7394         unsigned int present;
7395         unsigned char bits;
7396
7397         present = snd_hda_codec_read(codec, 0x1b, 0,
7398                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7399         bits = present ? HDA_AMP_MUTE : 0;
7400         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7401                                  HDA_AMP_MUTE, bits);
7402         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7403                                  HDA_AMP_MUTE, bits);
7404 }
7405
7406 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
7407                                            unsigned int res)
7408 {
7409         if ((res >> 26) == ALC880_HP_EVENT)
7410                 alc883_lenovo_101e_all_automute(codec);
7411         if ((res >> 26) == ALC880_FRONT_EVENT)
7412                 alc883_lenovo_101e_ispeaker_automute(codec);
7413 }
7414
7415 /* toggle speaker-output according to the hp-jack state */
7416 static void alc883_acer_aspire_automute(struct hda_codec *codec)
7417 {
7418         unsigned int present;
7419
7420         present = snd_hda_codec_read(codec, 0x14, 0,
7421                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7422         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7423                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7424         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7425                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7426 }
7427
7428 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
7429                                            unsigned int res)
7430 {
7431         if ((res >> 26) == ALC880_HP_EVENT)
7432                 alc883_acer_aspire_automute(codec);
7433 }
7434
7435 static struct hda_verb alc883_acer_eapd_verbs[] = {
7436         /* HP Pin: output 0 (0x0c) */
7437         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7438         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7439         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7440         /* Front Pin: output 0 (0x0c) */
7441         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7442         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7443         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7444         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
7445         /* eanable EAPD on medion laptop */
7446         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7447         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
7448         /* enable unsolicited event */
7449         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7450         { }
7451 };
7452
7453 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
7454 {
7455         unsigned int present;
7456
7457         present = snd_hda_codec_read(codec, 0x1b, 0,
7458                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7459         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7460                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7461         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7462                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7463         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
7464                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7465         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7466                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7467 }
7468
7469 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
7470                                              unsigned int res)
7471 {
7472         switch (res >> 26) {
7473         case ALC880_HP_EVENT:
7474                 printk("hp_event\n");
7475                 alc888_6st_dell_front_automute(codec);
7476                 break;
7477         }
7478 }
7479
7480 /*
7481  * generic initialization of ADC, input mixers and output mixers
7482  */
7483 static struct hda_verb alc883_auto_init_verbs[] = {
7484         /*
7485          * Unmute ADC0-2 and set the default input to mic-in
7486          */
7487         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7488         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7489         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7490         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7491
7492         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7493          * mixer widget
7494          * Note: PASD motherboards uses the Line In 2 as the input for
7495          * front panel mic (mic 2)
7496          */
7497         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7498         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7499         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7500         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7501         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7502         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7503
7504         /*
7505          * Set up output mixers (0x0c - 0x0f)
7506          */
7507         /* set vol=0 to output mixers */
7508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7509         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7510         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7511         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7512         /* set up input amps for analog loopback */
7513         /* Amp Indices: DAC = 0, mixer = 1 */
7514         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7515         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7516         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7517         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7518         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7519         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7520         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7521         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7522         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7523         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7524
7525         /* FIXME: use matrix-type input source selection */
7526         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7527         /* Input mixer1 */
7528         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7529         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7530         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7531         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7532         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7533         /* Input mixer2 */
7534         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7535         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7536         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7537         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
7538         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
7539
7540         { }
7541 };
7542
7543 /* capture mixer elements */
7544 static struct snd_kcontrol_new alc883_capture_mixer[] = {
7545         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7546         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7547         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7548         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7549         {
7550                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7551                 /* The multiple "Capture Source" controls confuse alsamixer
7552                  * So call somewhat different..
7553                  */
7554                 /* .name = "Capture Source", */
7555                 .name = "Input Source",
7556                 .count = 2,
7557                 .info = alc882_mux_enum_info,
7558                 .get = alc882_mux_enum_get,
7559                 .put = alc882_mux_enum_put,
7560         },
7561         { } /* end */
7562 };
7563
7564 #ifdef CONFIG_SND_HDA_POWER_SAVE
7565 #define alc883_loopbacks        alc880_loopbacks
7566 #endif
7567
7568 /* pcm configuration: identiacal with ALC880 */
7569 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
7570 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
7571 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
7572 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
7573 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
7574
7575 /*
7576  * configuration and preset
7577  */
7578 static const char *alc883_models[ALC883_MODEL_LAST] = {
7579         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
7580         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
7581         [ALC883_3ST_6ch]        = "3stack-6ch",
7582         [ALC883_6ST_DIG]        = "6stack-dig",
7583         [ALC883_TARGA_DIG]      = "targa-dig",
7584         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
7585         [ALC883_ACER]           = "acer",
7586         [ALC883_ACER_ASPIRE]    = "acer-aspire",
7587         [ALC883_MEDION]         = "medion",
7588         [ALC883_MEDION_MD2]     = "medion-md2",
7589         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
7590         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
7591         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
7592         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
7593         [ALC883_HAIER_W66]      = "haier-w66",
7594         [ALC888_6ST_HP]         = "6stack-hp",
7595         [ALC888_3ST_HP]         = "3stack-hp",
7596         [ALC888_6ST_DELL]       = "6stack-dell",
7597         [ALC883_MITAC]          = "mitac",
7598         [ALC883_AUTO]           = "auto",
7599 };
7600
7601 static struct snd_pci_quirk alc883_cfg_tbl[] = {
7602         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
7603         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
7604         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
7605         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
7606         SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
7607         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
7608         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
7609         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
7610         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
7611         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC888_6ST_HP),
7612         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
7613         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
7614         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
7615         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
7616         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
7617         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
7618         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
7619         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
7620         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
7621         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
7622         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
7623         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
7624         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
7625         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
7626         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
7627         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
7628         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
7629         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
7630         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
7631         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
7632         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
7633         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
7634         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
7635         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
7636         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
7637         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
7638         SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
7639         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
7640         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
7641         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
7642         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7643         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7644         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
7645         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
7646         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
7647         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
7648         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
7649         {}
7650 };
7651
7652 static struct alc_config_preset alc883_presets[] = {
7653         [ALC883_3ST_2ch_DIG] = {
7654                 .mixers = { alc883_3ST_2ch_mixer },
7655                 .init_verbs = { alc883_init_verbs },
7656                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7657                 .dac_nids = alc883_dac_nids,
7658                 .dig_out_nid = ALC883_DIGOUT_NID,
7659                 .dig_in_nid = ALC883_DIGIN_NID,
7660                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7661                 .channel_mode = alc883_3ST_2ch_modes,
7662                 .input_mux = &alc883_capture_source,
7663         },
7664         [ALC883_3ST_6ch_DIG] = {
7665                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7666                 .init_verbs = { alc883_init_verbs },
7667                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7668                 .dac_nids = alc883_dac_nids,
7669                 .dig_out_nid = ALC883_DIGOUT_NID,
7670                 .dig_in_nid = ALC883_DIGIN_NID,
7671                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7672                 .channel_mode = alc883_3ST_6ch_modes,
7673                 .need_dac_fix = 1,
7674                 .input_mux = &alc883_capture_source,
7675         },
7676         [ALC883_3ST_6ch] = {
7677                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7678                 .init_verbs = { alc883_init_verbs },
7679                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7680                 .dac_nids = alc883_dac_nids,
7681                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7682                 .channel_mode = alc883_3ST_6ch_modes,
7683                 .need_dac_fix = 1,
7684                 .input_mux = &alc883_capture_source,
7685         },
7686         [ALC883_6ST_DIG] = {
7687                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
7688                 .init_verbs = { alc883_init_verbs },
7689                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7690                 .dac_nids = alc883_dac_nids,
7691                 .dig_out_nid = ALC883_DIGOUT_NID,
7692                 .dig_in_nid = ALC883_DIGIN_NID,
7693                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
7694                 .channel_mode = alc883_sixstack_modes,
7695                 .input_mux = &alc883_capture_source,
7696         },
7697         [ALC883_TARGA_DIG] = {
7698                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
7699                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
7700                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7701                 .dac_nids = alc883_dac_nids,
7702                 .dig_out_nid = ALC883_DIGOUT_NID,
7703                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7704                 .channel_mode = alc883_3ST_6ch_modes,
7705                 .need_dac_fix = 1,
7706                 .input_mux = &alc883_capture_source,
7707                 .unsol_event = alc883_tagra_unsol_event,
7708                 .init_hook = alc883_tagra_automute,
7709         },
7710         [ALC883_TARGA_2ch_DIG] = {
7711                 .mixers = { alc883_tagra_2ch_mixer},
7712                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
7713                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7714                 .dac_nids = alc883_dac_nids,
7715                 .dig_out_nid = ALC883_DIGOUT_NID,
7716                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7717                 .channel_mode = alc883_3ST_2ch_modes,
7718                 .input_mux = &alc883_capture_source,
7719                 .unsol_event = alc883_tagra_unsol_event,
7720                 .init_hook = alc883_tagra_automute,
7721         },
7722         [ALC883_ACER] = {
7723                 .mixers = { alc883_base_mixer },
7724                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
7725                  * and the headphone jack.  Turn this on and rely on the
7726                  * standard mute methods whenever the user wants to turn
7727                  * these outputs off.
7728                  */
7729                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
7730                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7731                 .dac_nids = alc883_dac_nids,
7732                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7733                 .channel_mode = alc883_3ST_2ch_modes,
7734                 .input_mux = &alc883_capture_source,
7735         },
7736         [ALC883_ACER_ASPIRE] = {
7737                 .mixers = { alc883_acer_aspire_mixer },
7738                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
7739                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7740                 .dac_nids = alc883_dac_nids,
7741                 .dig_out_nid = ALC883_DIGOUT_NID,
7742                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7743                 .channel_mode = alc883_3ST_2ch_modes,
7744                 .input_mux = &alc883_capture_source,
7745                 .unsol_event = alc883_acer_aspire_unsol_event,
7746                 .init_hook = alc883_acer_aspire_automute,
7747         },
7748         [ALC883_MEDION] = {
7749                 .mixers = { alc883_fivestack_mixer,
7750                             alc883_chmode_mixer },
7751                 .init_verbs = { alc883_init_verbs,
7752                                 alc883_medion_eapd_verbs },
7753                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7754                 .dac_nids = alc883_dac_nids,
7755                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
7756                 .channel_mode = alc883_sixstack_modes,
7757                 .input_mux = &alc883_capture_source,
7758         },
7759         [ALC883_MEDION_MD2] = {
7760                 .mixers = { alc883_medion_md2_mixer},
7761                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
7762                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7763                 .dac_nids = alc883_dac_nids,
7764                 .dig_out_nid = ALC883_DIGOUT_NID,
7765                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7766                 .channel_mode = alc883_3ST_2ch_modes,
7767                 .input_mux = &alc883_capture_source,
7768                 .unsol_event = alc883_medion_md2_unsol_event,
7769                 .init_hook = alc883_medion_md2_automute,
7770         },
7771         [ALC883_LAPTOP_EAPD] = {
7772                 .mixers = { alc883_base_mixer },
7773                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
7774                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7775                 .dac_nids = alc883_dac_nids,
7776                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7777                 .channel_mode = alc883_3ST_2ch_modes,
7778                 .input_mux = &alc883_capture_source,
7779         },
7780         [ALC883_LENOVO_101E_2ch] = {
7781                 .mixers = { alc883_lenovo_101e_2ch_mixer},
7782                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
7783                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7784                 .dac_nids = alc883_dac_nids,
7785                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7786                 .channel_mode = alc883_3ST_2ch_modes,
7787                 .input_mux = &alc883_lenovo_101e_capture_source,
7788                 .unsol_event = alc883_lenovo_101e_unsol_event,
7789                 .init_hook = alc883_lenovo_101e_all_automute,
7790         },
7791         [ALC883_LENOVO_NB0763] = {
7792                 .mixers = { alc883_lenovo_nb0763_mixer },
7793                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
7794                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7795                 .dac_nids = alc883_dac_nids,
7796                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7797                 .channel_mode = alc883_3ST_2ch_modes,
7798                 .need_dac_fix = 1,
7799                 .input_mux = &alc883_lenovo_nb0763_capture_source,
7800                 .unsol_event = alc883_medion_md2_unsol_event,
7801                 .init_hook = alc883_medion_md2_automute,
7802         },
7803         [ALC888_LENOVO_MS7195_DIG] = {
7804                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
7805                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
7806                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7807                 .dac_nids = alc883_dac_nids,
7808                 .dig_out_nid = ALC883_DIGOUT_NID,
7809                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
7810                 .channel_mode = alc883_3ST_6ch_modes,
7811                 .need_dac_fix = 1,
7812                 .input_mux = &alc883_capture_source,
7813                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
7814                 .init_hook = alc888_lenovo_ms7195_front_automute,
7815         },
7816         [ALC883_HAIER_W66] = {
7817                 .mixers = { alc883_tagra_2ch_mixer},
7818                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
7819                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7820                 .dac_nids = alc883_dac_nids,
7821                 .dig_out_nid = ALC883_DIGOUT_NID,
7822                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7823                 .channel_mode = alc883_3ST_2ch_modes,
7824                 .input_mux = &alc883_capture_source,
7825                 .unsol_event = alc883_haier_w66_unsol_event,
7826                 .init_hook = alc883_haier_w66_automute,
7827         },
7828         [ALC888_6ST_HP] = {
7829                 .mixers = { alc888_6st_hp_mixer, alc883_chmode_mixer },
7830                 .init_verbs = { alc883_init_verbs, alc888_6st_hp_verbs },
7831                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7832                 .dac_nids = alc883_dac_nids,
7833                 .dig_out_nid = ALC883_DIGOUT_NID,
7834                 .dig_in_nid = ALC883_DIGIN_NID,
7835                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
7836                 .channel_mode = alc883_sixstack_modes,
7837                 .input_mux = &alc883_capture_source,
7838         },
7839         [ALC888_3ST_HP] = {
7840                 .mixers = { alc888_3st_hp_mixer, alc883_chmode_mixer },
7841                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
7842                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7843                 .dac_nids = alc883_dac_nids,
7844                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
7845                 .channel_mode = alc888_3st_hp_modes,
7846                 .need_dac_fix = 1,
7847                 .input_mux = &alc883_capture_source,
7848         },
7849         [ALC888_6ST_DELL] = {
7850                 .mixers = { alc888_6st_dell_mixer, alc883_chmode_mixer },
7851                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
7852                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7853                 .dac_nids = alc883_dac_nids,
7854                 .dig_out_nid = ALC883_DIGOUT_NID,
7855                 .dig_in_nid = ALC883_DIGIN_NID,
7856                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
7857                 .channel_mode = alc883_sixstack_modes,
7858                 .input_mux = &alc883_capture_source,
7859                 .unsol_event = alc888_6st_dell_unsol_event,
7860                 .init_hook = alc888_6st_dell_front_automute,
7861         },
7862         [ALC883_MITAC] = {
7863                 .mixers = { alc883_mitac_mixer },
7864                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
7865                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
7866                 .dac_nids = alc883_dac_nids,
7867                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
7868                 .channel_mode = alc883_3ST_2ch_modes,
7869                 .input_mux = &alc883_capture_source,
7870                 .unsol_event = alc883_mitac_unsol_event,
7871                 .init_hook = alc883_mitac_automute,
7872         },
7873 };
7874
7875
7876 /*
7877  * BIOS auto configuration
7878  */
7879 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
7880                                               hda_nid_t nid, int pin_type,
7881                                               int dac_idx)
7882 {
7883         /* set as output */
7884         struct alc_spec *spec = codec->spec;
7885         int idx;
7886
7887         alc_set_pin_output(codec, nid, pin_type);
7888         if (spec->multiout.dac_nids[dac_idx] == 0x25)
7889                 idx = 4;
7890         else
7891                 idx = spec->multiout.dac_nids[dac_idx] - 2;
7892         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
7893
7894 }
7895
7896 static void alc883_auto_init_multi_out(struct hda_codec *codec)
7897 {
7898         struct alc_spec *spec = codec->spec;
7899         int i;
7900
7901         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
7902         for (i = 0; i <= HDA_SIDE; i++) {
7903                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
7904                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
7905                 if (nid)
7906                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
7907                                                           i);
7908         }
7909 }
7910
7911 static void alc883_auto_init_hp_out(struct hda_codec *codec)
7912 {
7913         struct alc_spec *spec = codec->spec;
7914         hda_nid_t pin;
7915
7916         pin = spec->autocfg.hp_pins[0];
7917         if (pin) /* connect to front */
7918                 /* use dac 0 */
7919                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7920         pin = spec->autocfg.speaker_pins[0];
7921         if (pin)
7922                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7923 }
7924
7925 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
7926 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
7927
7928 static void alc883_auto_init_analog_input(struct hda_codec *codec)
7929 {
7930         struct alc_spec *spec = codec->spec;
7931         int i;
7932
7933         for (i = 0; i < AUTO_PIN_LAST; i++) {
7934                 hda_nid_t nid = spec->autocfg.input_pins[i];
7935                 if (alc883_is_input_pin(nid)) {
7936                         snd_hda_codec_write(codec, nid, 0,
7937                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
7938                                             (i <= AUTO_PIN_FRONT_MIC ?
7939                                              PIN_VREF80 : PIN_IN));
7940                         if (nid != ALC883_PIN_CD_NID)
7941                                 snd_hda_codec_write(codec, nid, 0,
7942                                                     AC_VERB_SET_AMP_GAIN_MUTE,
7943                                                     AMP_OUT_MUTE);
7944                 }
7945         }
7946 }
7947
7948 /* almost identical with ALC880 parser... */
7949 static int alc883_parse_auto_config(struct hda_codec *codec)
7950 {
7951         struct alc_spec *spec = codec->spec;
7952         int err = alc880_parse_auto_config(codec);
7953
7954         if (err < 0)
7955                 return err;
7956         else if (!err)
7957                 return 0; /* no config found */
7958
7959         err = alc_auto_add_mic_boost(codec);
7960         if (err < 0)
7961                 return err;
7962
7963         /* hack - override the init verbs */
7964         spec->init_verbs[0] = alc883_auto_init_verbs;
7965         spec->mixers[spec->num_mixers] = alc883_capture_mixer;
7966         spec->num_mixers++;
7967
7968         return 1; /* config found */
7969 }
7970
7971 /* additional initialization for auto-configuration model */
7972 static void alc883_auto_init(struct hda_codec *codec)
7973 {
7974         struct alc_spec *spec = codec->spec;
7975         alc883_auto_init_multi_out(codec);
7976         alc883_auto_init_hp_out(codec);
7977         alc883_auto_init_analog_input(codec);
7978         if (spec->unsol_event)
7979                 alc_sku_automute(codec);
7980 }
7981
7982 static int patch_alc883(struct hda_codec *codec)
7983 {
7984         struct alc_spec *spec;
7985         int err, board_config;
7986
7987         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7988         if (spec == NULL)
7989                 return -ENOMEM;
7990
7991         codec->spec = spec;
7992
7993         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
7994                                                   alc883_models,
7995                                                   alc883_cfg_tbl);
7996         if (board_config < 0) {
7997                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
7998                        "trying auto-probe from BIOS...\n");
7999                 board_config = ALC883_AUTO;
8000         }
8001
8002         if (board_config == ALC883_AUTO) {
8003                 /* automatic parse from the BIOS config */
8004                 err = alc883_parse_auto_config(codec);
8005                 if (err < 0) {
8006                         alc_free(codec);
8007                         return err;
8008                 } else if (!err) {
8009                         printk(KERN_INFO
8010                                "hda_codec: Cannot set up configuration "
8011                                "from BIOS.  Using base mode...\n");
8012                         board_config = ALC883_3ST_2ch_DIG;
8013                 }
8014         }
8015
8016         if (board_config != ALC883_AUTO)
8017                 setup_preset(spec, &alc883_presets[board_config]);
8018
8019         spec->stream_name_analog = "ALC883 Analog";
8020         spec->stream_analog_playback = &alc883_pcm_analog_playback;
8021         spec->stream_analog_capture = &alc883_pcm_analog_capture;
8022         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8023
8024         spec->stream_name_digital = "ALC883 Digital";
8025         spec->stream_digital_playback = &alc883_pcm_digital_playback;
8026         spec->stream_digital_capture = &alc883_pcm_digital_capture;
8027
8028         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8029         spec->adc_nids = alc883_adc_nids;
8030         spec->capsrc_nids = alc883_capsrc_nids;
8031
8032         spec->vmaster_nid = 0x0c;
8033
8034         codec->patch_ops = alc_patch_ops;
8035         if (board_config == ALC883_AUTO)
8036                 spec->init_hook = alc883_auto_init;
8037 #ifdef CONFIG_SND_HDA_POWER_SAVE
8038         if (!spec->loopback.amplist)
8039                 spec->loopback.amplist = alc883_loopbacks;
8040 #endif
8041
8042         return 0;
8043 }
8044
8045 /*
8046  * ALC262 support
8047  */
8048
8049 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
8050 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
8051
8052 #define alc262_dac_nids         alc260_dac_nids
8053 #define alc262_adc_nids         alc882_adc_nids
8054 #define alc262_adc_nids_alt     alc882_adc_nids_alt
8055
8056 #define alc262_modes            alc260_modes
8057 #define alc262_capture_source   alc882_capture_source
8058
8059 static struct snd_kcontrol_new alc262_base_mixer[] = {
8060         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8061         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8062         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8063         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8064         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8065         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8066         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8067         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8068         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8069         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8070         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8071         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8072         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8073            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8074         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8075         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8076         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8077         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8078         { } /* end */
8079 };
8080
8081 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8082         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8083         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8084         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8085         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8086         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8087         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8088         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8089         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8090         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8091         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8092         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8093         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8094         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8095            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8096         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8097         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8098         { } /* end */
8099 };
8100
8101 /* update HP, line and mono-out pins according to the master switch */
8102 static void alc262_hp_master_update(struct hda_codec *codec)
8103 {
8104         struct alc_spec *spec = codec->spec;
8105         int val = spec->master_sw;
8106
8107         /* HP & line-out */
8108         snd_hda_codec_write_cache(codec, 0x1b, 0,
8109                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8110                                   val ? PIN_HP : 0);
8111         snd_hda_codec_write_cache(codec, 0x15, 0,
8112                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8113                                   val ? PIN_HP : 0);
8114         /* mono (speaker) depending on the HP jack sense */
8115         val = val && !spec->jack_present;
8116         snd_hda_codec_write_cache(codec, 0x16, 0,
8117                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8118                                   val ? PIN_OUT : 0);
8119 }
8120
8121 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8122 {
8123         struct alc_spec *spec = codec->spec;
8124         unsigned int presence;
8125         presence = snd_hda_codec_read(codec, 0x1b, 0,
8126                                       AC_VERB_GET_PIN_SENSE, 0);
8127         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8128         alc262_hp_master_update(codec);
8129 }
8130
8131 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8132 {
8133         if ((res >> 26) != ALC880_HP_EVENT)
8134                 return;
8135         alc262_hp_bpc_automute(codec);
8136 }
8137
8138 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8139 {
8140         struct alc_spec *spec = codec->spec;
8141         unsigned int presence;
8142         presence = snd_hda_codec_read(codec, 0x15, 0,
8143                                       AC_VERB_GET_PIN_SENSE, 0);
8144         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8145         alc262_hp_master_update(codec);
8146 }
8147
8148 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8149                                            unsigned int res)
8150 {
8151         if ((res >> 26) != ALC880_HP_EVENT)
8152                 return;
8153         alc262_hp_wildwest_automute(codec);
8154 }
8155
8156 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
8157                                    struct snd_ctl_elem_value *ucontrol)
8158 {
8159         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8160         struct alc_spec *spec = codec->spec;
8161         *ucontrol->value.integer.value = spec->master_sw;
8162         return 0;
8163 }
8164
8165 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
8166                                    struct snd_ctl_elem_value *ucontrol)
8167 {
8168         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8169         struct alc_spec *spec = codec->spec;
8170         int val = !!*ucontrol->value.integer.value;
8171
8172         if (val == spec->master_sw)
8173                 return 0;
8174         spec->master_sw = val;
8175         alc262_hp_master_update(codec);
8176         return 1;
8177 }
8178
8179 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
8180         {
8181                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8182                 .name = "Master Playback Switch",
8183                 .info = snd_ctl_boolean_mono_info,
8184                 .get = alc262_hp_master_sw_get,
8185                 .put = alc262_hp_master_sw_put,
8186         },
8187         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8188         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8189         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8190         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8191                               HDA_OUTPUT),
8192         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8193                             HDA_OUTPUT),
8194         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8195         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8196         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8197         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8198         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8199         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8200         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8201         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8202         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8203         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8204         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8205         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8206         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
8207         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
8208         { } /* end */
8209 };
8210
8211 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
8212         {
8213                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8214                 .name = "Master Playback Switch",
8215                 .info = snd_ctl_boolean_mono_info,
8216                 .get = alc262_hp_master_sw_get,
8217                 .put = alc262_hp_master_sw_put,
8218         },
8219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8220         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8221         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8222         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8223         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
8224                               HDA_OUTPUT),
8225         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
8226                             HDA_OUTPUT),
8227         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
8228         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
8229         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
8230         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8231         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8232         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8233         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8234         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8235         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
8236         { } /* end */
8237 };
8238
8239 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
8240         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8241         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8242         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
8243         { } /* end */
8244 };
8245
8246 /* mute/unmute internal speaker according to the hp jack and mute state */
8247 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
8248 {
8249         struct alc_spec *spec = codec->spec;
8250
8251         if (force || !spec->sense_updated) {
8252                 unsigned int present;
8253                 present = snd_hda_codec_read(codec, 0x15, 0,
8254                                              AC_VERB_GET_PIN_SENSE, 0);
8255                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
8256                 spec->sense_updated = 1;
8257         }
8258         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
8259                                  spec->jack_present ? HDA_AMP_MUTE : 0);
8260 }
8261
8262 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
8263                                         unsigned int res)
8264 {
8265         if ((res >> 26) != ALC880_HP_EVENT)
8266                 return;
8267         alc262_hp_t5735_automute(codec, 1);
8268 }
8269
8270 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
8271 {
8272         alc262_hp_t5735_automute(codec, 1);
8273 }
8274
8275 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
8276         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8277         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8278         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8279         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8280         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8281         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8282         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8283         { } /* end */
8284 };
8285
8286 static struct hda_verb alc262_hp_t5735_verbs[] = {
8287         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8288         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8289
8290         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8291         { }
8292 };
8293
8294 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
8295         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8296         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8297         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8298         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8299         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8300         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8301         { } /* end */
8302 };
8303
8304 static struct hda_verb alc262_hp_rp5700_verbs[] = {
8305         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8306         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8307         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8308         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8309         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8310         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8311         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8312         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8313         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8314         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
8315         {}
8316 };
8317
8318 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
8319         .num_items = 1,
8320         .items = {
8321                 { "Line", 0x1 },
8322         },
8323 };
8324
8325 /* bind hp and internal speaker mute (with plug check) */
8326 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
8327                                      struct snd_ctl_elem_value *ucontrol)
8328 {
8329         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8330         long *valp = ucontrol->value.integer.value;
8331         int change;
8332
8333         /* change hp mute */
8334         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
8335                                           HDA_AMP_MUTE,
8336                                           valp[0] ? 0 : HDA_AMP_MUTE);
8337         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
8338                                            HDA_AMP_MUTE,
8339                                            valp[1] ? 0 : HDA_AMP_MUTE);
8340         if (change) {
8341                 /* change speaker according to HP jack state */
8342                 struct alc_spec *spec = codec->spec;
8343                 unsigned int mute;
8344                 if (spec->jack_present)
8345                         mute = HDA_AMP_MUTE;
8346                 else
8347                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
8348                                                       HDA_OUTPUT, 0);
8349                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8350                                          HDA_AMP_MUTE, mute);
8351         }
8352         return change;
8353 }
8354
8355 static struct snd_kcontrol_new alc262_sony_mixer[] = {
8356         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8357         {
8358                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8359                 .name = "Master Playback Switch",
8360                 .info = snd_hda_mixer_amp_switch_info,
8361                 .get = snd_hda_mixer_amp_switch_get,
8362                 .put = alc262_sony_master_sw_put,
8363                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
8364         },
8365         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8366         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8367         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8368         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8369         { } /* end */
8370 };
8371
8372 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
8373         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8374         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8375         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8376         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8377         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8378         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8379         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8380         { } /* end */
8381 };
8382
8383 #define alc262_capture_mixer            alc882_capture_mixer
8384 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
8385
8386 /*
8387  * generic initialization of ADC, input mixers and output mixers
8388  */
8389 static struct hda_verb alc262_init_verbs[] = {
8390         /*
8391          * Unmute ADC0-2 and set the default input to mic-in
8392          */
8393         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8394         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8395         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8396         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8397         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8398         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8399
8400         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8401          * mixer widget
8402          * Note: PASD motherboards uses the Line In 2 as the input for
8403          * front panel mic (mic 2)
8404          */
8405         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8406         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8407         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8408         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8409         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8410         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8411
8412         /*
8413          * Set up output mixers (0x0c - 0x0e)
8414          */
8415         /* set vol=0 to output mixers */
8416         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8417         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8418         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8419         /* set up input amps for analog loopback */
8420         /* Amp Indices: DAC = 0, mixer = 1 */
8421         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8422         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8423         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8424         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8425         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8426         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8427
8428         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8429         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8430         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8431         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8432         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8433         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8434
8435         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8436         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8437         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8438         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8439         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8440
8441         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8442         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8443
8444         /* FIXME: use matrix-type input source selection */
8445         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8446         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8447         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8448         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8449         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8450         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8451         /* Input mixer2 */
8452         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8453         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8454         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8455         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8456         /* Input mixer3 */
8457         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8458         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8459         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8460         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8461
8462         { }
8463 };
8464
8465 static struct hda_verb alc262_hippo_unsol_verbs[] = {
8466         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8467         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8468         {}
8469 };
8470
8471 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
8472         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8473         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8474         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
8475
8476         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8477         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8478         {}
8479 };
8480
8481 static struct hda_verb alc262_sony_unsol_verbs[] = {
8482         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
8483         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8484         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
8485
8486         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8487         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8488 };
8489
8490 /* mute/unmute internal speaker according to the hp jack and mute state */
8491 static void alc262_hippo_automute(struct hda_codec *codec)
8492 {
8493         struct alc_spec *spec = codec->spec;
8494         unsigned int mute;
8495         unsigned int present;
8496
8497         /* need to execute and sync at first */
8498         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
8499         present = snd_hda_codec_read(codec, 0x15, 0,
8500                                      AC_VERB_GET_PIN_SENSE, 0);
8501         spec->jack_present = (present & 0x80000000) != 0;
8502         if (spec->jack_present) {
8503                 /* mute internal speaker */
8504                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8505                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8506         } else {
8507                 /* unmute internal speaker if necessary */
8508                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
8509                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8510                                          HDA_AMP_MUTE, mute);
8511         }
8512 }
8513
8514 /* unsolicited event for HP jack sensing */
8515 static void alc262_hippo_unsol_event(struct hda_codec *codec,
8516                                        unsigned int res)
8517 {
8518         if ((res >> 26) != ALC880_HP_EVENT)
8519                 return;
8520         alc262_hippo_automute(codec);
8521 }
8522
8523 static void alc262_hippo1_automute(struct hda_codec *codec)
8524 {
8525         unsigned int mute;
8526         unsigned int present;
8527
8528         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8529         present = snd_hda_codec_read(codec, 0x1b, 0,
8530                                      AC_VERB_GET_PIN_SENSE, 0);
8531         present = (present & 0x80000000) != 0;
8532         if (present) {
8533                 /* mute internal speaker */
8534                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8535                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8536         } else {
8537                 /* unmute internal speaker if necessary */
8538                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8539                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8540                                          HDA_AMP_MUTE, mute);
8541         }
8542 }
8543
8544 /* unsolicited event for HP jack sensing */
8545 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
8546                                        unsigned int res)
8547 {
8548         if ((res >> 26) != ALC880_HP_EVENT)
8549                 return;
8550         alc262_hippo1_automute(codec);
8551 }
8552
8553 /*
8554  * fujitsu model
8555  *  0x14 = headphone/spdif-out, 0x15 = internal speaker
8556  */
8557
8558 #define ALC_HP_EVENT    0x37
8559
8560 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
8561         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
8562         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8563         {}
8564 };
8565
8566 static struct hda_input_mux alc262_fujitsu_capture_source = {
8567         .num_items = 3,
8568         .items = {
8569                 { "Mic", 0x0 },
8570                 { "Int Mic", 0x1 },
8571                 { "CD", 0x4 },
8572         },
8573 };
8574
8575 static struct hda_input_mux alc262_HP_capture_source = {
8576         .num_items = 5,
8577         .items = {
8578                 { "Mic", 0x0 },
8579                 { "Front Mic", 0x1 },
8580                 { "Line", 0x2 },
8581                 { "CD", 0x4 },
8582                 { "AUX IN", 0x6 },
8583         },
8584 };
8585
8586 static struct hda_input_mux alc262_HP_D7000_capture_source = {
8587         .num_items = 4,
8588         .items = {
8589                 { "Mic", 0x0 },
8590                 { "Front Mic", 0x2 },
8591                 { "Line", 0x1 },
8592                 { "CD", 0x4 },
8593         },
8594 };
8595
8596 /* mute/unmute internal speaker according to the hp jack and mute state */
8597 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
8598 {
8599         struct alc_spec *spec = codec->spec;
8600         unsigned int mute;
8601
8602         if (force || !spec->sense_updated) {
8603                 unsigned int present;
8604                 /* need to execute and sync at first */
8605                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
8606                 present = snd_hda_codec_read(codec, 0x14, 0,
8607                                          AC_VERB_GET_PIN_SENSE, 0);
8608                 spec->jack_present = (present & 0x80000000) != 0;
8609                 spec->sense_updated = 1;
8610         }
8611         if (spec->jack_present) {
8612                 /* mute internal speaker */
8613                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8614                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8615         } else {
8616                 /* unmute internal speaker if necessary */
8617                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
8618                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8619                                          HDA_AMP_MUTE, mute);
8620         }
8621 }
8622
8623 /* unsolicited event for HP jack sensing */
8624 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
8625                                        unsigned int res)
8626 {
8627         if ((res >> 26) != ALC_HP_EVENT)
8628                 return;
8629         alc262_fujitsu_automute(codec, 1);
8630 }
8631
8632 /* bind volumes of both NID 0x0c and 0x0d */
8633 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
8634         .ops = &snd_hda_bind_vol,
8635         .values = {
8636                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
8637                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
8638                 0
8639         },
8640 };
8641
8642 /* bind hp and internal speaker mute (with plug check) */
8643 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
8644                                          struct snd_ctl_elem_value *ucontrol)
8645 {
8646         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
8647         long *valp = ucontrol->value.integer.value;
8648         int change;
8649
8650         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
8651                                           HDA_AMP_MUTE,
8652                                           valp[0] ? 0 : HDA_AMP_MUTE);
8653         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
8654                                            HDA_AMP_MUTE,
8655                                            valp[1] ? 0 : HDA_AMP_MUTE);
8656         if (change)
8657                 alc262_fujitsu_automute(codec, 0);
8658         return change;
8659 }
8660
8661 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
8662         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
8663         {
8664                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8665                 .name = "Master Playback Switch",
8666                 .info = snd_hda_mixer_amp_switch_info,
8667                 .get = snd_hda_mixer_amp_switch_get,
8668                 .put = alc262_fujitsu_master_sw_put,
8669                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
8670         },
8671         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8672         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8673         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8674         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8675         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8676         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8677         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8678         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8679         { } /* end */
8680 };
8681
8682 /* additional init verbs for Benq laptops */
8683 static struct hda_verb alc262_EAPD_verbs[] = {
8684         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8685         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
8686         {}
8687 };
8688
8689 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
8690         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8691         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8692
8693         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8694         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
8695         {}
8696 };
8697
8698 /* Samsung Q1 Ultra Vista model setup */
8699 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
8700         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8701         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8702         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8703         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8704         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8705         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8706         { } /* end */
8707 };
8708
8709 static struct hda_verb alc262_ultra_verbs[] = {
8710         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8711         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8712         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
8713         /* Mic is on Node 0x19 */
8714         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8715         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
8716         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8717         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
8718         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8719         {0x24, AC_VERB_SET_CONNECT_SEL, 0x01},
8720         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
8721         {}
8722 };
8723
8724 static struct hda_input_mux alc262_ultra_capture_source = {
8725         .num_items = 1,
8726         .items = {
8727                 { "Mic", 0x1 },
8728         },
8729 };
8730
8731 /* mute/unmute internal speaker according to the hp jack and mute state */
8732 static void alc262_ultra_automute(struct hda_codec *codec)
8733 {
8734         struct alc_spec *spec = codec->spec;
8735         unsigned int mute;
8736         unsigned int present;
8737
8738         /* need to execute and sync at first */
8739         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
8740         present = snd_hda_codec_read(codec, 0x15, 0,
8741                                      AC_VERB_GET_PIN_SENSE, 0);
8742         spec->jack_present = (present & 0x80000000) != 0;
8743         if (spec->jack_present) {
8744                 /* mute internal speaker */
8745                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8746                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8747         } else {
8748                 /* unmute internal speaker if necessary */
8749                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
8750                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8751                                          HDA_AMP_MUTE, mute);
8752         }
8753 }
8754
8755 /* unsolicited event for HP jack sensing */
8756 static void alc262_ultra_unsol_event(struct hda_codec *codec,
8757                                        unsigned int res)
8758 {
8759         if ((res >> 26) != ALC880_HP_EVENT)
8760                 return;
8761         alc262_ultra_automute(codec);
8762 }
8763
8764 /* add playback controls from the parsed DAC table */
8765 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
8766                                              const struct auto_pin_cfg *cfg)
8767 {
8768         hda_nid_t nid;
8769         int err;
8770
8771         spec->multiout.num_dacs = 1;    /* only use one dac */
8772         spec->multiout.dac_nids = spec->private_dac_nids;
8773         spec->multiout.dac_nids[0] = 2;
8774
8775         nid = cfg->line_out_pins[0];
8776         if (nid) {
8777                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
8778                                   "Front Playback Volume",
8779                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
8780                 if (err < 0)
8781                         return err;
8782                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
8783                                   "Front Playback Switch",
8784                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
8785                 if (err < 0)
8786                         return err;
8787         }
8788
8789         nid = cfg->speaker_pins[0];
8790         if (nid) {
8791                 if (nid == 0x16) {
8792                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
8793                                           "Speaker Playback Volume",
8794                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
8795                                                               HDA_OUTPUT));
8796                         if (err < 0)
8797                                 return err;
8798                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
8799                                           "Speaker Playback Switch",
8800                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
8801                                                               HDA_OUTPUT));
8802                         if (err < 0)
8803                                 return err;
8804                 } else {
8805                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
8806                                           "Speaker Playback Switch",
8807                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
8808                                                               HDA_OUTPUT));
8809                         if (err < 0)
8810                                 return err;
8811                 }
8812         }
8813         nid = cfg->hp_pins[0];
8814         if (nid) {
8815                 /* spec->multiout.hp_nid = 2; */
8816                 if (nid == 0x16) {
8817                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
8818                                           "Headphone Playback Volume",
8819                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
8820                                                               HDA_OUTPUT));
8821                         if (err < 0)
8822                                 return err;
8823                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
8824                                           "Headphone Playback Switch",
8825                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
8826                                                               HDA_OUTPUT));
8827                         if (err < 0)
8828                                 return err;
8829                 } else {
8830                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
8831                                           "Headphone Playback Switch",
8832                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
8833                                                               HDA_OUTPUT));
8834                         if (err < 0)
8835                                 return err;
8836                 }
8837         }
8838         return 0;
8839 }
8840
8841 /* identical with ALC880 */
8842 #define alc262_auto_create_analog_input_ctls \
8843         alc880_auto_create_analog_input_ctls
8844
8845 /*
8846  * generic initialization of ADC, input mixers and output mixers
8847  */
8848 static struct hda_verb alc262_volume_init_verbs[] = {
8849         /*
8850          * Unmute ADC0-2 and set the default input to mic-in
8851          */
8852         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8853         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8854         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8855         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8856         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8857         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8858
8859         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8860          * mixer widget
8861          * Note: PASD motherboards uses the Line In 2 as the input for
8862          * front panel mic (mic 2)
8863          */
8864         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8865         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8866         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8867         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8868         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8869         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8870
8871         /*
8872          * Set up output mixers (0x0c - 0x0f)
8873          */
8874         /* set vol=0 to output mixers */
8875         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8876         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8877         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8878
8879         /* set up input amps for analog loopback */
8880         /* Amp Indices: DAC = 0, mixer = 1 */
8881         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8882         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8883         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8884         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8885         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8886         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8887
8888         /* FIXME: use matrix-type input source selection */
8889         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8890         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8891         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8892         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8893         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8894         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8895         /* Input mixer2 */
8896         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8897         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8898         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8899         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8900         /* Input mixer3 */
8901         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8902         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
8903         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
8904         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
8905
8906         { }
8907 };
8908
8909 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
8910         /*
8911          * Unmute ADC0-2 and set the default input to mic-in
8912          */
8913         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8914         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8915         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8916         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8917         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8918         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8919
8920         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8921          * mixer widget
8922          * Note: PASD motherboards uses the Line In 2 as the input for
8923          * front panel mic (mic 2)
8924          */
8925         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8926         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8927         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8928         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8929         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8930         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8931         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
8932         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
8933
8934         /*
8935          * Set up output mixers (0x0c - 0x0e)
8936          */
8937         /* set vol=0 to output mixers */
8938         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8939         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8940         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8941
8942         /* set up input amps for analog loopback */
8943         /* Amp Indices: DAC = 0, mixer = 1 */
8944         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8945         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8946         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8947         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8948         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8949         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8950
8951         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8952         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8953         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8954
8955         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8956         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8957
8958         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8959         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8960
8961         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8962         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8963         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8964         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8965         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
8966
8967         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
8968         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
8969         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
8970         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
8971         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
8972         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
8973
8974
8975         /* FIXME: use matrix-type input source selection */
8976         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8977         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8978         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8979         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
8980         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
8981         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
8982         /* Input mixer2 */
8983         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8984         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
8985         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
8986         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
8987         /* Input mixer3 */
8988         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
8989         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
8990         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
8991         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
8992
8993         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8994
8995         { }
8996 };
8997
8998 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
8999         /*
9000          * Unmute ADC0-2 and set the default input to mic-in
9001          */
9002         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9003         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9004         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9005         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9006         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9007         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9008
9009         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9010          * mixer widget
9011          * Note: PASD motherboards uses the Line In 2 as the input for front
9012          * panel mic (mic 2)
9013          */
9014         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9015         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9016         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9017         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9018         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9019         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9020         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9021         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9022         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9023         /*
9024          * Set up output mixers (0x0c - 0x0e)
9025          */
9026         /* set vol=0 to output mixers */
9027         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9028         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9029         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9030
9031         /* set up input amps for analog loopback */
9032         /* Amp Indices: DAC = 0, mixer = 1 */
9033         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9034         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9035         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9036         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9037         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9038         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9039
9040
9041         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
9042         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
9043         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
9044         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
9045         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
9046         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
9047         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
9048
9049         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9050         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9051
9052         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9053         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9054
9055         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
9056         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9057         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9058         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
9059         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9060         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
9061
9062         /* FIXME: use matrix-type input source selection */
9063         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9064         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9065         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
9066         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
9067         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
9068         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
9069         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
9070         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
9071         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
9072         /* Input mixer2 */
9073         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9074         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9075         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9076         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9077         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9078         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9079         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9080         /* Input mixer3 */
9081         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9082         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9083         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
9084         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
9085         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
9086         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
9087         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
9088
9089         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9090
9091         { }
9092 };
9093
9094 #ifdef CONFIG_SND_HDA_POWER_SAVE
9095 #define alc262_loopbacks        alc880_loopbacks
9096 #endif
9097
9098 /* pcm configuration: identiacal with ALC880 */
9099 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
9100 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
9101 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
9102 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
9103
9104 /*
9105  * BIOS auto configuration
9106  */
9107 static int alc262_parse_auto_config(struct hda_codec *codec)
9108 {
9109         struct alc_spec *spec = codec->spec;
9110         int err;
9111         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
9112
9113         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9114                                            alc262_ignore);
9115         if (err < 0)
9116                 return err;
9117         if (!spec->autocfg.line_outs)
9118                 return 0; /* can't find valid BIOS pin config */
9119         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
9120         if (err < 0)
9121                 return err;
9122         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
9123         if (err < 0)
9124                 return err;
9125
9126         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9127
9128         if (spec->autocfg.dig_out_pin)
9129                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
9130         if (spec->autocfg.dig_in_pin)
9131                 spec->dig_in_nid = ALC262_DIGIN_NID;
9132
9133         if (spec->kctl_alloc)
9134                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
9135
9136         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
9137         spec->num_mux_defs = 1;
9138         spec->input_mux = &spec->private_imux;
9139
9140         err = alc_auto_add_mic_boost(codec);
9141         if (err < 0)
9142                 return err;
9143
9144         return 1;
9145 }
9146
9147 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
9148 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
9149 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
9150
9151
9152 /* init callback for auto-configuration model -- overriding the default init */
9153 static void alc262_auto_init(struct hda_codec *codec)
9154 {
9155         struct alc_spec *spec = codec->spec;
9156         alc262_auto_init_multi_out(codec);
9157         alc262_auto_init_hp_out(codec);
9158         alc262_auto_init_analog_input(codec);
9159         if (spec->unsol_event)
9160                 alc_sku_automute(codec);
9161 }
9162
9163 /*
9164  * configuration and preset
9165  */
9166 static const char *alc262_models[ALC262_MODEL_LAST] = {
9167         [ALC262_BASIC]          = "basic",
9168         [ALC262_HIPPO]          = "hippo",
9169         [ALC262_HIPPO_1]        = "hippo_1",
9170         [ALC262_FUJITSU]        = "fujitsu",
9171         [ALC262_HP_BPC]         = "hp-bpc",
9172         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
9173         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
9174         [ALC262_HP_RP5700]      = "hp-rp5700",
9175         [ALC262_BENQ_ED8]       = "benq",
9176         [ALC262_BENQ_T31]       = "benq-t31",
9177         [ALC262_SONY_ASSAMD]    = "sony-assamd",
9178         [ALC262_ULTRA]          = "ultra",
9179         [ALC262_AUTO]           = "auto",
9180 };
9181
9182 static struct snd_pci_quirk alc262_cfg_tbl[] = {
9183         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
9184         SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
9185         SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
9186         SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
9187         SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
9188         SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
9189         SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
9190         SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
9191         SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
9192         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
9193         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
9194         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
9195         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
9196         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
9197         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
9198         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
9199         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
9200         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
9201         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
9202         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
9203         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
9204                       ALC262_HP_TC_T5735),
9205         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
9206         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9207         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
9208         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9209         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
9210         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
9211         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
9212         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
9213         SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
9214         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
9215         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
9216         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
9217         {}
9218 };
9219
9220 static struct alc_config_preset alc262_presets[] = {
9221         [ALC262_BASIC] = {
9222                 .mixers = { alc262_base_mixer },
9223                 .init_verbs = { alc262_init_verbs },
9224                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9225                 .dac_nids = alc262_dac_nids,
9226                 .hp_nid = 0x03,
9227                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9228                 .channel_mode = alc262_modes,
9229                 .input_mux = &alc262_capture_source,
9230         },
9231         [ALC262_HIPPO] = {
9232                 .mixers = { alc262_base_mixer },
9233                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
9234                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9235                 .dac_nids = alc262_dac_nids,
9236                 .hp_nid = 0x03,
9237                 .dig_out_nid = ALC262_DIGOUT_NID,
9238                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9239                 .channel_mode = alc262_modes,
9240                 .input_mux = &alc262_capture_source,
9241                 .unsol_event = alc262_hippo_unsol_event,
9242                 .init_hook = alc262_hippo_automute,
9243         },
9244         [ALC262_HIPPO_1] = {
9245                 .mixers = { alc262_hippo1_mixer },
9246                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
9247                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9248                 .dac_nids = alc262_dac_nids,
9249                 .hp_nid = 0x02,
9250                 .dig_out_nid = ALC262_DIGOUT_NID,
9251                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9252                 .channel_mode = alc262_modes,
9253                 .input_mux = &alc262_capture_source,
9254                 .unsol_event = alc262_hippo1_unsol_event,
9255                 .init_hook = alc262_hippo1_automute,
9256         },
9257         [ALC262_FUJITSU] = {
9258                 .mixers = { alc262_fujitsu_mixer },
9259                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
9260                                 alc262_fujitsu_unsol_verbs },
9261                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9262                 .dac_nids = alc262_dac_nids,
9263                 .hp_nid = 0x03,
9264                 .dig_out_nid = ALC262_DIGOUT_NID,
9265                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9266                 .channel_mode = alc262_modes,
9267                 .input_mux = &alc262_fujitsu_capture_source,
9268                 .unsol_event = alc262_fujitsu_unsol_event,
9269         },
9270         [ALC262_HP_BPC] = {
9271                 .mixers = { alc262_HP_BPC_mixer },
9272                 .init_verbs = { alc262_HP_BPC_init_verbs },
9273                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9274                 .dac_nids = alc262_dac_nids,
9275                 .hp_nid = 0x03,
9276                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9277                 .channel_mode = alc262_modes,
9278                 .input_mux = &alc262_HP_capture_source,
9279                 .unsol_event = alc262_hp_bpc_unsol_event,
9280                 .init_hook = alc262_hp_bpc_automute,
9281         },
9282         [ALC262_HP_BPC_D7000_WF] = {
9283                 .mixers = { alc262_HP_BPC_WildWest_mixer },
9284                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9285                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9286                 .dac_nids = alc262_dac_nids,
9287                 .hp_nid = 0x03,
9288                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9289                 .channel_mode = alc262_modes,
9290                 .input_mux = &alc262_HP_D7000_capture_source,
9291                 .unsol_event = alc262_hp_wildwest_unsol_event,
9292                 .init_hook = alc262_hp_wildwest_automute,
9293         },
9294         [ALC262_HP_BPC_D7000_WL] = {
9295                 .mixers = { alc262_HP_BPC_WildWest_mixer,
9296                             alc262_HP_BPC_WildWest_option_mixer },
9297                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
9298                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9299                 .dac_nids = alc262_dac_nids,
9300                 .hp_nid = 0x03,
9301                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9302                 .channel_mode = alc262_modes,
9303                 .input_mux = &alc262_HP_D7000_capture_source,
9304                 .unsol_event = alc262_hp_wildwest_unsol_event,
9305                 .init_hook = alc262_hp_wildwest_automute,
9306         },
9307         [ALC262_HP_TC_T5735] = {
9308                 .mixers = { alc262_hp_t5735_mixer },
9309                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
9310                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9311                 .dac_nids = alc262_dac_nids,
9312                 .hp_nid = 0x03,
9313                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9314                 .channel_mode = alc262_modes,
9315                 .input_mux = &alc262_capture_source,
9316                 .unsol_event = alc262_hp_t5735_unsol_event,
9317                 .init_hook = alc262_hp_t5735_init_hook,
9318         },
9319         [ALC262_HP_RP5700] = {
9320                 .mixers = { alc262_hp_rp5700_mixer },
9321                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
9322                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9323                 .dac_nids = alc262_dac_nids,
9324                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9325                 .channel_mode = alc262_modes,
9326                 .input_mux = &alc262_hp_rp5700_capture_source,
9327         },
9328         [ALC262_BENQ_ED8] = {
9329                 .mixers = { alc262_base_mixer },
9330                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
9331                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9332                 .dac_nids = alc262_dac_nids,
9333                 .hp_nid = 0x03,
9334                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9335                 .channel_mode = alc262_modes,
9336                 .input_mux = &alc262_capture_source,
9337         },
9338         [ALC262_SONY_ASSAMD] = {
9339                 .mixers = { alc262_sony_mixer },
9340                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
9341                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9342                 .dac_nids = alc262_dac_nids,
9343                 .hp_nid = 0x02,
9344                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9345                 .channel_mode = alc262_modes,
9346                 .input_mux = &alc262_capture_source,
9347                 .unsol_event = alc262_hippo_unsol_event,
9348                 .init_hook = alc262_hippo_automute,
9349         },
9350         [ALC262_BENQ_T31] = {
9351                 .mixers = { alc262_benq_t31_mixer },
9352                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
9353                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9354                 .dac_nids = alc262_dac_nids,
9355                 .hp_nid = 0x03,
9356                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9357                 .channel_mode = alc262_modes,
9358                 .input_mux = &alc262_capture_source,
9359                 .unsol_event = alc262_hippo_unsol_event,
9360                 .init_hook = alc262_hippo_automute,
9361         },
9362         [ALC262_ULTRA] = {
9363                 .mixers = { alc262_ultra_mixer },
9364                 .init_verbs = { alc262_init_verbs, alc262_ultra_verbs },
9365                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
9366                 .dac_nids = alc262_dac_nids,
9367                 .hp_nid = 0x03,
9368                 .dig_out_nid = ALC262_DIGOUT_NID,
9369                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
9370                 .channel_mode = alc262_modes,
9371                 .input_mux = &alc262_ultra_capture_source,
9372                 .unsol_event = alc262_ultra_unsol_event,
9373                 .init_hook = alc262_ultra_automute,
9374         },
9375 };
9376
9377 static int patch_alc262(struct hda_codec *codec)
9378 {
9379         struct alc_spec *spec;
9380         int board_config;
9381         int err;
9382
9383         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9384         if (spec == NULL)
9385                 return -ENOMEM;
9386
9387         codec->spec = spec;
9388 #if 0
9389         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
9390          * under-run
9391          */
9392         {
9393         int tmp;
9394         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9395         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
9396         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
9397         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
9398         }
9399 #endif
9400
9401         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
9402                                                   alc262_models,
9403                                                   alc262_cfg_tbl);
9404
9405         if (board_config < 0) {
9406                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
9407                        "trying auto-probe from BIOS...\n");
9408                 board_config = ALC262_AUTO;
9409         }
9410
9411         if (board_config == ALC262_AUTO) {
9412                 /* automatic parse from the BIOS config */
9413                 err = alc262_parse_auto_config(codec);
9414                 if (err < 0) {
9415                         alc_free(codec);
9416                         return err;
9417                 } else if (!err) {
9418                         printk(KERN_INFO
9419                                "hda_codec: Cannot set up configuration "
9420                                "from BIOS.  Using base mode...\n");
9421                         board_config = ALC262_BASIC;
9422                 }
9423         }
9424
9425         if (board_config != ALC262_AUTO)
9426                 setup_preset(spec, &alc262_presets[board_config]);
9427
9428         spec->stream_name_analog = "ALC262 Analog";
9429         spec->stream_analog_playback = &alc262_pcm_analog_playback;
9430         spec->stream_analog_capture = &alc262_pcm_analog_capture;
9431
9432         spec->stream_name_digital = "ALC262 Digital";
9433         spec->stream_digital_playback = &alc262_pcm_digital_playback;
9434         spec->stream_digital_capture = &alc262_pcm_digital_capture;
9435
9436         if (!spec->adc_nids && spec->input_mux) {
9437                 /* check whether NID 0x07 is valid */
9438                 unsigned int wcap = get_wcaps(codec, 0x07);
9439
9440                 /* get type */
9441                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9442                 if (wcap != AC_WID_AUD_IN) {
9443                         spec->adc_nids = alc262_adc_nids_alt;
9444                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
9445                         spec->mixers[spec->num_mixers] =
9446                                 alc262_capture_alt_mixer;
9447                         spec->num_mixers++;
9448                 } else {
9449                         spec->adc_nids = alc262_adc_nids;
9450                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
9451                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
9452                         spec->num_mixers++;
9453                 }
9454         }
9455
9456         spec->vmaster_nid = 0x0c;
9457
9458         codec->patch_ops = alc_patch_ops;
9459         if (board_config == ALC262_AUTO)
9460                 spec->init_hook = alc262_auto_init;
9461 #ifdef CONFIG_SND_HDA_POWER_SAVE
9462         if (!spec->loopback.amplist)
9463                 spec->loopback.amplist = alc262_loopbacks;
9464 #endif
9465
9466         return 0;
9467 }
9468
9469 /*
9470  *  ALC268 channel source setting (2 channel)
9471  */
9472 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
9473 #define alc268_modes            alc260_modes
9474
9475 static hda_nid_t alc268_dac_nids[2] = {
9476         /* front, hp */
9477         0x02, 0x03
9478 };
9479
9480 static hda_nid_t alc268_adc_nids[2] = {
9481         /* ADC0-1 */
9482         0x08, 0x07
9483 };
9484
9485 static hda_nid_t alc268_adc_nids_alt[1] = {
9486         /* ADC0 */
9487         0x08
9488 };
9489
9490 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
9491
9492 static struct snd_kcontrol_new alc268_base_mixer[] = {
9493         /* output mixer control */
9494         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
9495         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9496         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
9497         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9498         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9499         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9500         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
9501         { }
9502 };
9503
9504 static struct hda_verb alc268_eapd_verbs[] = {
9505         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9506         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9507         { }
9508 };
9509
9510 /* Toshiba specific */
9511 #define alc268_toshiba_automute alc262_hippo_automute
9512
9513 static struct hda_verb alc268_toshiba_verbs[] = {
9514         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9515         { } /* end */
9516 };
9517
9518 /* Acer specific */
9519 /* bind volumes of both NID 0x02 and 0x03 */
9520 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
9521         .ops = &snd_hda_bind_vol,
9522         .values = {
9523                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
9524                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
9525                 0
9526         },
9527 };
9528
9529 /* mute/unmute internal speaker according to the hp jack and mute state */
9530 static void alc268_acer_automute(struct hda_codec *codec, int force)
9531 {
9532         struct alc_spec *spec = codec->spec;
9533         unsigned int mute;
9534
9535         if (force || !spec->sense_updated) {
9536                 unsigned int present;
9537                 present = snd_hda_codec_read(codec, 0x14, 0,
9538                                          AC_VERB_GET_PIN_SENSE, 0);
9539                 spec->jack_present = (present & 0x80000000) != 0;
9540                 spec->sense_updated = 1;
9541         }
9542         if (spec->jack_present)
9543                 mute = HDA_AMP_MUTE; /* mute internal speaker */
9544         else /* unmute internal speaker if necessary */
9545                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9546         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9547                                  HDA_AMP_MUTE, mute);
9548 }
9549
9550
9551 /* bind hp and internal speaker mute (with plug check) */
9552 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
9553                                      struct snd_ctl_elem_value *ucontrol)
9554 {
9555         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9556         long *valp = ucontrol->value.integer.value;
9557         int change;
9558
9559         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
9560                                           HDA_AMP_MUTE,
9561                                           valp[0] ? 0 : HDA_AMP_MUTE);
9562         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
9563                                            HDA_AMP_MUTE,
9564                                            valp[1] ? 0 : HDA_AMP_MUTE);
9565         if (change)
9566                 alc268_acer_automute(codec, 0);
9567         return change;
9568 }
9569
9570 static struct snd_kcontrol_new alc268_acer_mixer[] = {
9571         /* output mixer control */
9572         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
9573         {
9574                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9575                 .name = "Master Playback Switch",
9576                 .info = snd_hda_mixer_amp_switch_info,
9577                 .get = snd_hda_mixer_amp_switch_get,
9578                 .put = alc268_acer_master_sw_put,
9579                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9580         },
9581         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9582         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
9583         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
9584         { }
9585 };
9586
9587 static struct hda_verb alc268_acer_verbs[] = {
9588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9590
9591         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9592         { }
9593 };
9594
9595 /* unsolicited event for HP jack sensing */
9596 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
9597                                        unsigned int res)
9598 {
9599         if ((res >> 26) != ALC880_HP_EVENT)
9600                 return;
9601         alc268_toshiba_automute(codec);
9602 }
9603
9604 static void alc268_acer_unsol_event(struct hda_codec *codec,
9605                                        unsigned int res)
9606 {
9607         if ((res >> 26) != ALC880_HP_EVENT)
9608                 return;
9609         alc268_acer_automute(codec, 1);
9610 }
9611
9612 static void alc268_acer_init_hook(struct hda_codec *codec)
9613 {
9614         alc268_acer_automute(codec, 1);
9615 }
9616
9617 static struct snd_kcontrol_new alc268_dell_mixer[] = {
9618         /* output mixer control */
9619         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
9620         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9621         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
9622         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9623         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9624         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
9625         { }
9626 };
9627
9628 static struct hda_verb alc268_dell_verbs[] = {
9629         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9630         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9631         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9632         { }
9633 };
9634
9635 /* mute/unmute internal speaker according to the hp jack and mute state */
9636 static void alc268_dell_automute(struct hda_codec *codec)
9637 {
9638         unsigned int present;
9639         unsigned int mute;
9640
9641         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
9642         if (present & 0x80000000)
9643                 mute = HDA_AMP_MUTE;
9644         else
9645                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9646         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9647                                  HDA_AMP_MUTE, mute);
9648 }
9649
9650 static void alc268_dell_unsol_event(struct hda_codec *codec,
9651                                     unsigned int res)
9652 {
9653         if ((res >> 26) != ALC880_HP_EVENT)
9654                 return;
9655         alc268_dell_automute(codec);
9656 }
9657
9658 #define alc268_dell_init_hook   alc268_dell_automute
9659
9660 /*
9661  * generic initialization of ADC, input mixers and output mixers
9662  */
9663 static struct hda_verb alc268_base_init_verbs[] = {
9664         /* Unmute DAC0-1 and set vol = 0 */
9665         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9666         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9667         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9668         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9669         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9670         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9671
9672         /*
9673          * Set up output mixers (0x0c - 0x0e)
9674          */
9675         /* set vol=0 to output mixers */
9676         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9677         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9678         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9679         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
9680
9681         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9682         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9683
9684         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9685         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9686         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9687         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9688         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9689         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9690         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9691         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9692
9693         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9694         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9695         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9696         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9697         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9698         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9699         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9700         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9701
9702         /* Unmute Selector 23h,24h and set the default input to mic-in */
9703
9704         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
9705         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9706         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
9707         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9708
9709         { }
9710 };
9711
9712 /*
9713  * generic initialization of ADC, input mixers and output mixers
9714  */
9715 static struct hda_verb alc268_volume_init_verbs[] = {
9716         /* set output DAC */
9717         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9718         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9719         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9720         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9721
9722         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9723         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9724         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9725         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9726         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9727
9728         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9729         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9730         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9731         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9732         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9733
9734         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9735         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9736         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9737         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9738
9739         /* set PCBEEP vol = 0 */
9740         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, (0xb000 | (0x00 << 8))},
9741
9742         { }
9743 };
9744
9745 #define alc268_mux_enum_info alc_mux_enum_info
9746 #define alc268_mux_enum_get alc_mux_enum_get
9747 #define alc268_mux_enum_put alc_mux_enum_put
9748
9749 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
9750         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
9751         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
9752         {
9753                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9754                 /* The multiple "Capture Source" controls confuse alsamixer
9755                  * So call somewhat different..
9756                  */
9757                 /* .name = "Capture Source", */
9758                 .name = "Input Source",
9759                 .count = 1,
9760                 .info = alc268_mux_enum_info,
9761                 .get = alc268_mux_enum_get,
9762                 .put = alc268_mux_enum_put,
9763         },
9764         { } /* end */
9765 };
9766
9767 static struct snd_kcontrol_new alc268_capture_mixer[] = {
9768         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
9769         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
9770         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
9771         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
9772         {
9773                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9774                 /* The multiple "Capture Source" controls confuse alsamixer
9775                  * So call somewhat different..
9776                  */
9777                 /* .name = "Capture Source", */
9778                 .name = "Input Source",
9779                 .count = 2,
9780                 .info = alc268_mux_enum_info,
9781                 .get = alc268_mux_enum_get,
9782                 .put = alc268_mux_enum_put,
9783         },
9784         { } /* end */
9785 };
9786
9787 static struct hda_input_mux alc268_capture_source = {
9788         .num_items = 4,
9789         .items = {
9790                 { "Mic", 0x0 },
9791                 { "Front Mic", 0x1 },
9792                 { "Line", 0x2 },
9793                 { "CD", 0x3 },
9794         },
9795 };
9796
9797 #ifdef CONFIG_SND_DEBUG
9798 static struct snd_kcontrol_new alc268_test_mixer[] = {
9799         /* Volume widgets */
9800         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
9801         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
9802         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9803         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
9804         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
9805         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
9806         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
9807         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
9808         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
9809         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
9810         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
9811         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
9812         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
9813         /* The below appears problematic on some hardwares */
9814         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
9815         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
9816         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
9817         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
9818         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
9819
9820         /* Modes for retasking pin widgets */
9821         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
9822         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
9823         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
9824         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
9825
9826         /* Controls for GPIO pins, assuming they are configured as outputs */
9827         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
9828         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
9829         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
9830         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
9831
9832         /* Switches to allow the digital SPDIF output pin to be enabled.
9833          * The ALC268 does not have an SPDIF input.
9834          */
9835         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
9836
9837         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
9838          * this output to turn on an external amplifier.
9839          */
9840         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
9841         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
9842
9843         { } /* end */
9844 };
9845 #endif
9846
9847 /* create input playback/capture controls for the given pin */
9848 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
9849                                     const char *ctlname, int idx)
9850 {
9851         char name[32];
9852         int err;
9853
9854         sprintf(name, "%s Playback Volume", ctlname);
9855         if (nid == 0x14) {
9856                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
9857                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
9858                                                       HDA_OUTPUT));
9859                 if (err < 0)
9860                         return err;
9861         } else if (nid == 0x15) {
9862                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
9863                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
9864                                                       HDA_OUTPUT));
9865                 if (err < 0)
9866                         return err;
9867         } else
9868                 return -1;
9869         sprintf(name, "%s Playback Switch", ctlname);
9870         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
9871                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
9872         if (err < 0)
9873                 return err;
9874         return 0;
9875 }
9876
9877 /* add playback controls from the parsed DAC table */
9878 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
9879                                              const struct auto_pin_cfg *cfg)
9880 {
9881         hda_nid_t nid;
9882         int err;
9883
9884         spec->multiout.num_dacs = 2;    /* only use one dac */
9885         spec->multiout.dac_nids = spec->private_dac_nids;
9886         spec->multiout.dac_nids[0] = 2;
9887         spec->multiout.dac_nids[1] = 3;
9888
9889         nid = cfg->line_out_pins[0];
9890         if (nid)
9891                 alc268_new_analog_output(spec, nid, "Front", 0);
9892
9893         nid = cfg->speaker_pins[0];
9894         if (nid == 0x1d) {
9895                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9896                                   "Speaker Playback Volume",
9897                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9898                 if (err < 0)
9899                         return err;
9900         }
9901         nid = cfg->hp_pins[0];
9902         if (nid)
9903                 alc268_new_analog_output(spec, nid, "Headphone", 0);
9904
9905         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
9906         if (nid == 0x16) {
9907                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9908                                   "Mono Playback Switch",
9909                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
9910                 if (err < 0)
9911                         return err;
9912         }
9913         return 0;
9914 }
9915
9916 /* create playback/capture controls for input pins */
9917 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
9918                                                 const struct auto_pin_cfg *cfg)
9919 {
9920         struct hda_input_mux *imux = &spec->private_imux;
9921         int i, idx1;
9922
9923         for (i = 0; i < AUTO_PIN_LAST; i++) {
9924                 switch(cfg->input_pins[i]) {
9925                 case 0x18:
9926                         idx1 = 0;       /* Mic 1 */
9927                         break;
9928                 case 0x19:
9929                         idx1 = 1;       /* Mic 2 */
9930                         break;
9931                 case 0x1a:
9932                         idx1 = 2;       /* Line In */
9933                         break;
9934                 case 0x1c:
9935                         idx1 = 3;       /* CD */
9936                         break;
9937                 default:
9938                         continue;
9939                 }
9940                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
9941                 imux->items[imux->num_items].index = idx1;
9942                 imux->num_items++;
9943         }
9944         return 0;
9945 }
9946
9947 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
9948 {
9949         struct alc_spec *spec = codec->spec;
9950         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
9951         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9952         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
9953         unsigned int    dac_vol1, dac_vol2;
9954
9955         if (speaker_nid) {
9956                 snd_hda_codec_write(codec, speaker_nid, 0,
9957                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
9958                 snd_hda_codec_write(codec, 0x0f, 0,
9959                                     AC_VERB_SET_AMP_GAIN_MUTE,
9960                                     AMP_IN_UNMUTE(1));
9961                 snd_hda_codec_write(codec, 0x10, 0,
9962                                     AC_VERB_SET_AMP_GAIN_MUTE,
9963                                     AMP_IN_UNMUTE(1));
9964         } else {
9965                 snd_hda_codec_write(codec, 0x0f, 0,
9966                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
9967                 snd_hda_codec_write(codec, 0x10, 0,
9968                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
9969         }
9970
9971         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
9972         if (line_nid == 0x14)
9973                 dac_vol2 = AMP_OUT_ZERO;
9974         else if (line_nid == 0x15)
9975                 dac_vol1 = AMP_OUT_ZERO;
9976         if (hp_nid == 0x14)
9977                 dac_vol2 = AMP_OUT_ZERO;
9978         else if (hp_nid == 0x15)
9979                 dac_vol1 = AMP_OUT_ZERO;
9980         if (line_nid != 0x16 || hp_nid != 0x16 ||
9981             spec->autocfg.line_out_pins[1] != 0x16 ||
9982             spec->autocfg.line_out_pins[2] != 0x16)
9983                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
9984
9985         snd_hda_codec_write(codec, 0x02, 0,
9986                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
9987         snd_hda_codec_write(codec, 0x03, 0,
9988                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
9989 }
9990
9991 /* pcm configuration: identiacal with ALC880 */
9992 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
9993 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
9994 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
9995 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
9996
9997 /*
9998  * BIOS auto configuration
9999  */
10000 static int alc268_parse_auto_config(struct hda_codec *codec)
10001 {
10002         struct alc_spec *spec = codec->spec;
10003         int err;
10004         static hda_nid_t alc268_ignore[] = { 0 };
10005
10006         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10007                                            alc268_ignore);
10008         if (err < 0)
10009                 return err;
10010         if (!spec->autocfg.line_outs)
10011                 return 0; /* can't find valid BIOS pin config */
10012
10013         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
10014         if (err < 0)
10015                 return err;
10016         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
10017         if (err < 0)
10018                 return err;
10019
10020         spec->multiout.max_channels = 2;
10021
10022         /* digital only support output */
10023         if (spec->autocfg.dig_out_pin)
10024                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
10025
10026         if (spec->kctl_alloc)
10027                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10028
10029         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
10030         spec->num_mux_defs = 1;
10031         spec->input_mux = &spec->private_imux;
10032
10033         err = alc_auto_add_mic_boost(codec);
10034         if (err < 0)
10035                 return err;
10036
10037         return 1;
10038 }
10039
10040 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
10041 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
10042 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
10043
10044 /* init callback for auto-configuration model -- overriding the default init */
10045 static void alc268_auto_init(struct hda_codec *codec)
10046 {
10047         struct alc_spec *spec = codec->spec;
10048         alc268_auto_init_multi_out(codec);
10049         alc268_auto_init_hp_out(codec);
10050         alc268_auto_init_mono_speaker_out(codec);
10051         alc268_auto_init_analog_input(codec);
10052         if (spec->unsol_event)
10053                 alc_sku_automute(codec);
10054 }
10055
10056 /*
10057  * configuration and preset
10058  */
10059 static const char *alc268_models[ALC268_MODEL_LAST] = {
10060         [ALC268_3ST]            = "3stack",
10061         [ALC268_TOSHIBA]        = "toshiba",
10062         [ALC268_ACER]           = "acer",
10063         [ALC268_DELL]           = "dell",
10064         [ALC268_ZEPTO]          = "zepto",
10065 #ifdef CONFIG_SND_DEBUG
10066         [ALC268_TEST]           = "test",
10067 #endif
10068         [ALC268_AUTO]           = "auto",
10069 };
10070
10071 static struct snd_pci_quirk alc268_cfg_tbl[] = {
10072         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
10073         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
10074         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
10075         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
10076         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
10077         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
10078         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
10079         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
10080         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
10081         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
10082         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
10083         {}
10084 };
10085
10086 static struct alc_config_preset alc268_presets[] = {
10087         [ALC268_3ST] = {
10088                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer },
10089                 .init_verbs = { alc268_base_init_verbs },
10090                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10091                 .dac_nids = alc268_dac_nids,
10092                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10093                 .adc_nids = alc268_adc_nids_alt,
10094                 .capsrc_nids = alc268_capsrc_nids,
10095                 .hp_nid = 0x03,
10096                 .dig_out_nid = ALC268_DIGOUT_NID,
10097                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10098                 .channel_mode = alc268_modes,
10099                 .input_mux = &alc268_capture_source,
10100         },
10101         [ALC268_TOSHIBA] = {
10102                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer },
10103                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10104                                 alc268_toshiba_verbs },
10105                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10106                 .dac_nids = alc268_dac_nids,
10107                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10108                 .adc_nids = alc268_adc_nids_alt,
10109                 .capsrc_nids = alc268_capsrc_nids,
10110                 .hp_nid = 0x03,
10111                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10112                 .channel_mode = alc268_modes,
10113                 .input_mux = &alc268_capture_source,
10114                 .unsol_event = alc268_toshiba_unsol_event,
10115                 .init_hook = alc268_toshiba_automute,
10116         },
10117         [ALC268_ACER] = {
10118                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer },
10119                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10120                                 alc268_acer_verbs },
10121                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10122                 .dac_nids = alc268_dac_nids,
10123                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10124                 .adc_nids = alc268_adc_nids_alt,
10125                 .capsrc_nids = alc268_capsrc_nids,
10126                 .hp_nid = 0x02,
10127                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10128                 .channel_mode = alc268_modes,
10129                 .input_mux = &alc268_capture_source,
10130                 .unsol_event = alc268_acer_unsol_event,
10131                 .init_hook = alc268_acer_init_hook,
10132         },
10133         [ALC268_DELL] = {
10134                 .mixers = { alc268_dell_mixer },
10135                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10136                                 alc268_dell_verbs },
10137                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10138                 .dac_nids = alc268_dac_nids,
10139                 .hp_nid = 0x02,
10140                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10141                 .channel_mode = alc268_modes,
10142                 .unsol_event = alc268_dell_unsol_event,
10143                 .init_hook = alc268_dell_init_hook,
10144                 .input_mux = &alc268_capture_source,
10145         },
10146         [ALC268_ZEPTO] = {
10147                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer },
10148                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10149                                 alc268_toshiba_verbs },
10150                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10151                 .dac_nids = alc268_dac_nids,
10152                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10153                 .adc_nids = alc268_adc_nids_alt,
10154                 .capsrc_nids = alc268_capsrc_nids,
10155                 .hp_nid = 0x03,
10156                 .dig_out_nid = ALC268_DIGOUT_NID,
10157                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10158                 .channel_mode = alc268_modes,
10159                 .input_mux = &alc268_capture_source,
10160                 .unsol_event = alc268_toshiba_unsol_event,
10161                 .init_hook = alc268_toshiba_automute
10162         },
10163 #ifdef CONFIG_SND_DEBUG
10164         [ALC268_TEST] = {
10165                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
10166                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
10167                                 alc268_volume_init_verbs },
10168                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
10169                 .dac_nids = alc268_dac_nids,
10170                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
10171                 .adc_nids = alc268_adc_nids_alt,
10172                 .capsrc_nids = alc268_capsrc_nids,
10173                 .hp_nid = 0x03,
10174                 .dig_out_nid = ALC268_DIGOUT_NID,
10175                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
10176                 .channel_mode = alc268_modes,
10177                 .input_mux = &alc268_capture_source,
10178         },
10179 #endif
10180 };
10181
10182 static int patch_alc268(struct hda_codec *codec)
10183 {
10184         struct alc_spec *spec;
10185         int board_config;
10186         int err;
10187
10188         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
10189         if (spec == NULL)
10190                 return -ENOMEM;
10191
10192         codec->spec = spec;
10193
10194         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
10195                                                   alc268_models,
10196                                                   alc268_cfg_tbl);
10197
10198         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
10199                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
10200                        "trying auto-probe from BIOS...\n");
10201                 board_config = ALC268_AUTO;
10202         }
10203
10204         if (board_config == ALC268_AUTO) {
10205                 /* automatic parse from the BIOS config */
10206                 err = alc268_parse_auto_config(codec);
10207                 if (err < 0) {
10208                         alc_free(codec);
10209                         return err;
10210                 } else if (!err) {
10211                         printk(KERN_INFO
10212                                "hda_codec: Cannot set up configuration "
10213                                "from BIOS.  Using base mode...\n");
10214                         board_config = ALC268_3ST;
10215                 }
10216         }
10217
10218         if (board_config != ALC268_AUTO)
10219                 setup_preset(spec, &alc268_presets[board_config]);
10220
10221         spec->stream_name_analog = "ALC268 Analog";
10222         spec->stream_analog_playback = &alc268_pcm_analog_playback;
10223         spec->stream_analog_capture = &alc268_pcm_analog_capture;
10224         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
10225
10226         spec->stream_name_digital = "ALC268 Digital";
10227         spec->stream_digital_playback = &alc268_pcm_digital_playback;
10228
10229         if (!spec->adc_nids && spec->input_mux) {
10230                 /* check whether NID 0x07 is valid */
10231                 unsigned int wcap = get_wcaps(codec, 0x07);
10232
10233                 /* get type */
10234                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10235                 if (wcap != AC_WID_AUD_IN) {
10236                         spec->adc_nids = alc268_adc_nids_alt;
10237                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
10238                         spec->mixers[spec->num_mixers] =
10239                                         alc268_capture_alt_mixer;
10240                         spec->num_mixers++;
10241                 } else {
10242                         spec->adc_nids = alc268_adc_nids;
10243                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
10244                         spec->mixers[spec->num_mixers] =
10245                                 alc268_capture_mixer;
10246                         spec->num_mixers++;
10247                 }
10248                 spec->capsrc_nids = alc268_capsrc_nids;
10249         }
10250
10251         spec->vmaster_nid = 0x02;
10252
10253         codec->patch_ops = alc_patch_ops;
10254         if (board_config == ALC268_AUTO)
10255                 spec->init_hook = alc268_auto_init;
10256
10257         return 0;
10258 }
10259
10260 /*
10261  *  ALC269 channel source setting (2 channel)
10262  */
10263 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
10264
10265 #define alc269_dac_nids         alc260_dac_nids
10266
10267 static hda_nid_t alc269_adc_nids[1] = {
10268         /* ADC1 */
10269         0x07,
10270 };
10271
10272 #define alc269_modes            alc260_modes
10273 #define alc269_capture_source   alc880_lg_lw_capture_source
10274
10275 static struct snd_kcontrol_new alc269_base_mixer[] = {
10276         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10277         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10278         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10279         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10280         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10281         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10282         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10283         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10284         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10285         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10286         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10287         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10288         { } /* end */
10289 };
10290
10291 /* capture mixer elements */
10292 static struct snd_kcontrol_new alc269_capture_mixer[] = {
10293         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10294         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10295         {
10296                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10297                 /* The multiple "Capture Source" controls confuse alsamixer
10298                  * So call somewhat different..
10299                  */
10300                 /* .name = "Capture Source", */
10301                 .name = "Input Source",
10302                 .count = 1,
10303                 .info = alc_mux_enum_info,
10304                 .get = alc_mux_enum_get,
10305                 .put = alc_mux_enum_put,
10306         },
10307         { } /* end */
10308 };
10309
10310 /*
10311  * generic initialization of ADC, input mixers and output mixers
10312  */
10313 static struct hda_verb alc269_init_verbs[] = {
10314         /*
10315          * Unmute ADC0 and set the default input to mic-in
10316          */
10317         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10318
10319         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
10320          * analog-loopback mixer widget
10321          * Note: PASD motherboards uses the Line In 2 as the input for
10322          * front panel mic (mic 2)
10323          */
10324         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10325         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10326         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10327         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10328         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10329         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10330
10331         /*
10332          * Set up output mixers (0x0c - 0x0e)
10333          */
10334         /* set vol=0 to output mixers */
10335         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10336         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10337
10338         /* set up input amps for analog loopback */
10339         /* Amp Indices: DAC = 0, mixer = 1 */
10340         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10341         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10342         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10343         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10344         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10345         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10346
10347         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10348         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10349         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10350         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10351         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10352         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10353         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10354
10355         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10356         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10357         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10358         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10359         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10360         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10361         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10362
10363         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10364         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10365
10366         /* FIXME: use matrix-type input source selection */
10367         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
10368         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10369         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10371         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10372         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10373
10374         /* set EAPD */
10375         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10376         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10377         { }
10378 };
10379
10380 /* add playback controls from the parsed DAC table */
10381 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
10382                                              const struct auto_pin_cfg *cfg)
10383 {
10384         hda_nid_t nid;
10385         int err;
10386
10387         spec->multiout.num_dacs = 1;    /* only use one dac */
10388         spec->multiout.dac_nids = spec->private_dac_nids;
10389         spec->multiout.dac_nids[0] = 2;
10390
10391         nid = cfg->line_out_pins[0];
10392         if (nid) {
10393                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10394                                   "Front Playback Volume",
10395                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
10396                 if (err < 0)
10397                         return err;
10398                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10399                                   "Front Playback Switch",
10400                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10401                 if (err < 0)
10402                         return err;
10403         }
10404
10405         nid = cfg->speaker_pins[0];
10406         if (nid) {
10407                 if (!cfg->line_out_pins[0]) {
10408                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10409                                           "Speaker Playback Volume",
10410                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
10411                                                               HDA_OUTPUT));
10412                         if (err < 0)
10413                                 return err;
10414                 }
10415                 if (nid == 0x16) {
10416                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10417                                           "Speaker Playback Switch",
10418                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10419                                                               HDA_OUTPUT));
10420                         if (err < 0)
10421                                 return err;
10422                 } else {
10423                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10424                                           "Speaker Playback Switch",
10425                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10426                                                               HDA_OUTPUT));
10427                         if (err < 0)
10428                                 return err;
10429                 }
10430         }
10431         nid = cfg->hp_pins[0];
10432         if (nid) {
10433                 /* spec->multiout.hp_nid = 2; */
10434                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
10435                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10436                                           "Headphone Playback Volume",
10437                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
10438                                                               HDA_OUTPUT));
10439                         if (err < 0)
10440                                 return err;
10441                 }
10442                 if (nid == 0x16) {
10443                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10444                                           "Headphone Playback Switch",
10445                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10446                                                               HDA_OUTPUT));
10447                         if (err < 0)
10448                                 return err;
10449                 } else {
10450                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10451                                           "Headphone Playback Switch",
10452                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10453                                                               HDA_OUTPUT));
10454                         if (err < 0)
10455                                 return err;
10456                 }
10457         }
10458         return 0;
10459 }
10460
10461 #define alc269_auto_create_analog_input_ctls \
10462         alc880_auto_create_analog_input_ctls
10463
10464 #ifdef CONFIG_SND_HDA_POWER_SAVE
10465 #define alc269_loopbacks        alc880_loopbacks
10466 #endif
10467
10468 /* pcm configuration: identiacal with ALC880 */
10469 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
10470 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
10471 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
10472 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
10473
10474 /*
10475  * BIOS auto configuration
10476  */
10477 static int alc269_parse_auto_config(struct hda_codec *codec)
10478 {
10479         struct alc_spec *spec = codec->spec;
10480         int err;
10481         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
10482
10483         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10484                                            alc269_ignore);
10485         if (err < 0)
10486                 return err;
10487
10488         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
10489         if (err < 0)
10490                 return err;
10491         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
10492         if (err < 0)
10493                 return err;
10494
10495         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10496
10497         if (spec->autocfg.dig_out_pin)
10498                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
10499
10500         if (spec->kctl_alloc)
10501                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10502
10503         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
10504         spec->num_mux_defs = 1;
10505         spec->input_mux = &spec->private_imux;
10506
10507         err = alc_auto_add_mic_boost(codec);
10508         if (err < 0)
10509                 return err;
10510
10511         return 1;
10512 }
10513
10514 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
10515 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
10516 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
10517
10518
10519 /* init callback for auto-configuration model -- overriding the default init */
10520 static void alc269_auto_init(struct hda_codec *codec)
10521 {
10522         struct alc_spec *spec = codec->spec;
10523         alc269_auto_init_multi_out(codec);
10524         alc269_auto_init_hp_out(codec);
10525         alc269_auto_init_analog_input(codec);
10526         if (spec->unsol_event)
10527                 alc_sku_automute(codec);
10528 }
10529
10530 /*
10531  * configuration and preset
10532  */
10533 static const char *alc269_models[ALC269_MODEL_LAST] = {
10534         [ALC269_BASIC]          = "basic",
10535 };
10536
10537 static struct snd_pci_quirk alc269_cfg_tbl[] = {
10538         {}
10539 };
10540
10541 static struct alc_config_preset alc269_presets[] = {
10542         [ALC269_BASIC] = {
10543                 .mixers = { alc269_base_mixer },
10544                 .init_verbs = { alc269_init_verbs },
10545                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
10546                 .dac_nids = alc269_dac_nids,
10547                 .hp_nid = 0x03,
10548                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
10549                 .channel_mode = alc269_modes,
10550                 .input_mux = &alc269_capture_source,
10551         },
10552 };
10553
10554 static int patch_alc269(struct hda_codec *codec)
10555 {
10556         struct alc_spec *spec;
10557         int board_config;
10558         int err;
10559
10560         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10561         if (spec == NULL)
10562                 return -ENOMEM;
10563
10564         codec->spec = spec;
10565
10566         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
10567                                                   alc269_models,
10568                                                   alc269_cfg_tbl);
10569
10570         if (board_config < 0) {
10571                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
10572                        "trying auto-probe from BIOS...\n");
10573                 board_config = ALC269_AUTO;
10574         }
10575
10576         if (board_config == ALC269_AUTO) {
10577                 /* automatic parse from the BIOS config */
10578                 err = alc269_parse_auto_config(codec);
10579                 if (err < 0) {
10580                         alc_free(codec);
10581                         return err;
10582                 } else if (!err) {
10583                         printk(KERN_INFO
10584                                "hda_codec: Cannot set up configuration "
10585                                "from BIOS.  Using base mode...\n");
10586                         board_config = ALC269_BASIC;
10587                 }
10588         }
10589
10590         if (board_config != ALC269_AUTO)
10591                 setup_preset(spec, &alc269_presets[board_config]);
10592
10593         spec->stream_name_analog = "ALC269 Analog";
10594         spec->stream_analog_playback = &alc269_pcm_analog_playback;
10595         spec->stream_analog_capture = &alc269_pcm_analog_capture;
10596
10597         spec->stream_name_digital = "ALC269 Digital";
10598         spec->stream_digital_playback = &alc269_pcm_digital_playback;
10599         spec->stream_digital_capture = &alc269_pcm_digital_capture;
10600
10601         spec->adc_nids = alc269_adc_nids;
10602         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
10603         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
10604         spec->num_mixers++;
10605
10606         codec->patch_ops = alc_patch_ops;
10607         if (board_config == ALC269_AUTO)
10608                 spec->init_hook = alc269_auto_init;
10609 #ifdef CONFIG_SND_HDA_POWER_SAVE
10610         if (!spec->loopback.amplist)
10611                 spec->loopback.amplist = alc269_loopbacks;
10612 #endif
10613
10614         return 0;
10615 }
10616
10617 /*
10618  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
10619  */
10620
10621 /*
10622  * set the path ways for 2 channel output
10623  * need to set the codec line out and mic 1 pin widgets to inputs
10624  */
10625 static struct hda_verb alc861_threestack_ch2_init[] = {
10626         /* set pin widget 1Ah (line in) for input */
10627         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
10628         /* set pin widget 18h (mic1/2) for input, for mic also enable
10629          * the vref
10630          */
10631         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
10632
10633         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
10634 #if 0
10635         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
10636         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
10637 #endif
10638         { } /* end */
10639 };
10640 /*
10641  * 6ch mode
10642  * need to set the codec line out and mic 1 pin widgets to outputs
10643  */
10644 static struct hda_verb alc861_threestack_ch6_init[] = {
10645         /* set pin widget 1Ah (line in) for output (Back Surround)*/
10646         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10647         /* set pin widget 18h (mic1) for output (CLFE)*/
10648         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10649
10650         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
10651         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
10652
10653         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
10654 #if 0
10655         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
10656         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
10657 #endif
10658         { } /* end */
10659 };
10660
10661 static struct hda_channel_mode alc861_threestack_modes[2] = {
10662         { 2, alc861_threestack_ch2_init },
10663         { 6, alc861_threestack_ch6_init },
10664 };
10665 /* Set mic1 as input and unmute the mixer */
10666 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
10667         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
10668         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
10669         { } /* end */
10670 };
10671 /* Set mic1 as output and mute mixer */
10672 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
10673         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10674         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
10675         { } /* end */
10676 };
10677
10678 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
10679         { 2, alc861_uniwill_m31_ch2_init },
10680         { 4, alc861_uniwill_m31_ch4_init },
10681 };
10682
10683 /* Set mic1 and line-in as input and unmute the mixer */
10684 static struct hda_verb alc861_asus_ch2_init[] = {
10685         /* set pin widget 1Ah (line in) for input */
10686         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
10687         /* set pin widget 18h (mic1/2) for input, for mic also enable
10688          * the vref
10689          */
10690         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
10691
10692         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
10693 #if 0
10694         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
10695         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
10696 #endif
10697         { } /* end */
10698 };
10699 /* Set mic1 nad line-in as output and mute mixer */
10700 static struct hda_verb alc861_asus_ch6_init[] = {
10701         /* set pin widget 1Ah (line in) for output (Back Surround)*/
10702         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10703         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
10704         /* set pin widget 18h (mic1) for output (CLFE)*/
10705         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10706         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
10707         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
10708         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
10709
10710         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
10711 #if 0
10712         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
10713         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
10714 #endif
10715         { } /* end */
10716 };
10717
10718 static struct hda_channel_mode alc861_asus_modes[2] = {
10719         { 2, alc861_asus_ch2_init },
10720         { 6, alc861_asus_ch6_init },
10721 };
10722
10723 /* patch-ALC861 */
10724
10725 static struct snd_kcontrol_new alc861_base_mixer[] = {
10726         /* output mixer control */
10727         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
10728         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
10729         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
10730         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
10731         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
10732
10733         /*Input mixer control */
10734         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
10735            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
10736         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
10737         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
10738         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
10739         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
10740         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
10741         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
10742         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
10743         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
10744
10745         /* Capture mixer control */
10746         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
10747         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
10748         {
10749                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10750                 .name = "Capture Source",
10751                 .count = 1,
10752                 .info = alc_mux_enum_info,
10753                 .get = alc_mux_enum_get,
10754                 .put = alc_mux_enum_put,
10755         },
10756         { } /* end */
10757 };
10758
10759 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
10760         /* output mixer control */
10761         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
10762         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
10763         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
10764         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
10765         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
10766
10767         /* Input mixer control */
10768         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
10769            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
10770         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
10771         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
10772         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
10773         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
10774         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
10775         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
10776         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
10777         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
10778
10779         /* Capture mixer control */
10780         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
10781         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
10782         {
10783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10784                 .name = "Capture Source",
10785                 .count = 1,
10786                 .info = alc_mux_enum_info,
10787                 .get = alc_mux_enum_get,
10788                 .put = alc_mux_enum_put,
10789         },
10790         {
10791                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10792                 .name = "Channel Mode",
10793                 .info = alc_ch_mode_info,
10794                 .get = alc_ch_mode_get,
10795                 .put = alc_ch_mode_put,
10796                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
10797         },
10798         { } /* end */
10799 };
10800
10801 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
10802         /* output mixer control */
10803         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
10804         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
10805         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
10806
10807         /*Capture mixer control */
10808         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
10809         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
10810         {
10811                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10812                 .name = "Capture Source",
10813                 .count = 1,
10814                 .info = alc_mux_enum_info,
10815                 .get = alc_mux_enum_get,
10816                 .put = alc_mux_enum_put,
10817         },
10818
10819         { } /* end */
10820 };
10821
10822 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
10823         /* output mixer control */
10824         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
10825         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
10826         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
10827         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
10828         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
10829
10830         /* Input mixer control */
10831         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
10832            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
10833         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
10834         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
10835         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
10836         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
10837         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
10838         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
10839         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
10840         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
10841
10842         /* Capture mixer control */
10843         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
10844         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
10845         {
10846                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10847                 .name = "Capture Source",
10848                 .count = 1,
10849                 .info = alc_mux_enum_info,
10850                 .get = alc_mux_enum_get,
10851                 .put = alc_mux_enum_put,
10852         },
10853         {
10854                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10855                 .name = "Channel Mode",
10856                 .info = alc_ch_mode_info,
10857                 .get = alc_ch_mode_get,
10858                 .put = alc_ch_mode_put,
10859                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
10860         },
10861         { } /* end */
10862 };
10863
10864 static struct snd_kcontrol_new alc861_asus_mixer[] = {
10865         /* output mixer control */
10866         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
10867         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
10868         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
10869         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
10870         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
10871
10872         /* Input mixer control */
10873         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
10874         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10875         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
10876         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
10877         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
10878         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
10879         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
10880         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
10881         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
10882         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
10883
10884         /* Capture mixer control */
10885         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
10886         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
10887         {
10888                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10889                 .name = "Capture Source",
10890                 .count = 1,
10891                 .info = alc_mux_enum_info,
10892                 .get = alc_mux_enum_get,
10893                 .put = alc_mux_enum_put,
10894         },
10895         {
10896                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10897                 .name = "Channel Mode",
10898                 .info = alc_ch_mode_info,
10899                 .get = alc_ch_mode_get,
10900                 .put = alc_ch_mode_put,
10901                 .private_value = ARRAY_SIZE(alc861_asus_modes),
10902         },
10903         { }
10904 };
10905
10906 /* additional mixer */
10907 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
10908         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
10909         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
10910         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
10911         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
10912         { }
10913 };
10914
10915 /*
10916  * generic initialization of ADC, input mixers and output mixers
10917  */
10918 static struct hda_verb alc861_base_init_verbs[] = {
10919         /*
10920          * Unmute ADC0 and set the default input to mic-in
10921          */
10922         /* port-A for surround (rear panel) */
10923         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10924         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
10925         /* port-B for mic-in (rear panel) with vref */
10926         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
10927         /* port-C for line-in (rear panel) */
10928         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
10929         /* port-D for Front */
10930         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10931         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
10932         /* port-E for HP out (front panel) */
10933         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
10934         /* route front PCM to HP */
10935         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
10936         /* port-F for mic-in (front panel) with vref */
10937         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
10938         /* port-G for CLFE (rear panel) */
10939         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10940         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
10941         /* port-H for side (rear panel) */
10942         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10943         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
10944         /* CD-in */
10945         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
10946         /* route front mic to ADC1*/
10947         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10948         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10949
10950         /* Unmute DAC0~3 & spdif out*/
10951         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10952         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10953         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10954         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10955         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10956
10957         /* Unmute Mixer 14 (mic) 1c (Line in)*/
10958         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10959         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10960         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10961         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10962
10963         /* Unmute Stereo Mixer 15 */
10964         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10965         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10966         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
10967         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
10968
10969         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10970         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10971         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10972         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10973         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10974         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10975         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10976         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10977         /* hp used DAC 3 (Front) */
10978         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
10979         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
10980
10981         { }
10982 };
10983
10984 static struct hda_verb alc861_threestack_init_verbs[] = {
10985         /*
10986          * Unmute ADC0 and set the default input to mic-in
10987          */
10988         /* port-A for surround (rear panel) */
10989         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
10990         /* port-B for mic-in (rear panel) with vref */
10991         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
10992         /* port-C for line-in (rear panel) */
10993         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
10994         /* port-D for Front */
10995         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
10996         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
10997         /* port-E for HP out (front panel) */
10998         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
10999         /* route front PCM to HP */
11000         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11001         /* port-F for mic-in (front panel) with vref */
11002         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11003         /* port-G for CLFE (rear panel) */
11004         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11005         /* port-H for side (rear panel) */
11006         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11007         /* CD-in */
11008         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11009         /* route front mic to ADC1*/
11010         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11011         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11012         /* Unmute DAC0~3 & spdif out*/
11013         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11014         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11015         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11016         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11017         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11018
11019         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11020         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11021         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11022         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11023         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11024
11025         /* Unmute Stereo Mixer 15 */
11026         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11027         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11028         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11029         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11030
11031         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11032         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11033         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11034         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11035         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11036         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11037         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11038         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11039         /* hp used DAC 3 (Front) */
11040         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11041         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11042         { }
11043 };
11044
11045 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
11046         /*
11047          * Unmute ADC0 and set the default input to mic-in
11048          */
11049         /* port-A for surround (rear panel) */
11050         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11051         /* port-B for mic-in (rear panel) with vref */
11052         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11053         /* port-C for line-in (rear panel) */
11054         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11055         /* port-D for Front */
11056         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11057         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11058         /* port-E for HP out (front panel) */
11059         /* this has to be set to VREF80 */
11060         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11061         /* route front PCM to HP */
11062         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11063         /* port-F for mic-in (front panel) with vref */
11064         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11065         /* port-G for CLFE (rear panel) */
11066         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11067         /* port-H for side (rear panel) */
11068         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11069         /* CD-in */
11070         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11071         /* route front mic to ADC1*/
11072         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11073         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11074         /* Unmute DAC0~3 & spdif out*/
11075         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11076         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11077         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11078         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11079         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11080
11081         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11082         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11083         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11084         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11085         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11086
11087         /* Unmute Stereo Mixer 15 */
11088         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11089         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11090         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11091         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11092
11093         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11094         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11095         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11096         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11097         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11098         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11099         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11100         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11101         /* hp used DAC 3 (Front) */
11102         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11103         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11104         { }
11105 };
11106
11107 static struct hda_verb alc861_asus_init_verbs[] = {
11108         /*
11109          * Unmute ADC0 and set the default input to mic-in
11110          */
11111         /* port-A for surround (rear panel)
11112          * according to codec#0 this is the HP jack
11113          */
11114         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
11115         /* route front PCM to HP */
11116         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
11117         /* port-B for mic-in (rear panel) with vref */
11118         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11119         /* port-C for line-in (rear panel) */
11120         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11121         /* port-D for Front */
11122         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11123         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
11124         /* port-E for HP out (front panel) */
11125         /* this has to be set to VREF80 */
11126         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11127         /* route front PCM to HP */
11128         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
11129         /* port-F for mic-in (front panel) with vref */
11130         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
11131         /* port-G for CLFE (rear panel) */
11132         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11133         /* port-H for side (rear panel) */
11134         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
11135         /* CD-in */
11136         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
11137         /* route front mic to ADC1*/
11138         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11139         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11140         /* Unmute DAC0~3 & spdif out*/
11141         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11142         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11143         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11144         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11145         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11146         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11147         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11148         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11149         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11150         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11151
11152         /* Unmute Stereo Mixer 15 */
11153         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11154         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11155         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11156         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
11157
11158         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11159         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11160         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11161         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11162         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11163         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11164         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11165         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11166         /* hp used DAC 3 (Front) */
11167         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11168         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11169         { }
11170 };
11171
11172 /* additional init verbs for ASUS laptops */
11173 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
11174         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
11175         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
11176         { }
11177 };
11178
11179 /*
11180  * generic initialization of ADC, input mixers and output mixers
11181  */
11182 static struct hda_verb alc861_auto_init_verbs[] = {
11183         /*
11184          * Unmute ADC0 and set the default input to mic-in
11185          */
11186         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
11187         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11188
11189         /* Unmute DAC0~3 & spdif out*/
11190         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11191         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11192         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11193         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11194         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11195
11196         /* Unmute Mixer 14 (mic) 1c (Line in)*/
11197         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11198         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11199         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11200         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11201
11202         /* Unmute Stereo Mixer 15 */
11203         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11204         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11205         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11206         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
11207
11208         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11209         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11210         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11211         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11212         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11213         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11214         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11215         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11216
11217         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11218         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11219         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11220         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11221         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11222         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11223         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
11224         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
11225
11226         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
11227
11228         { }
11229 };
11230
11231 static struct hda_verb alc861_toshiba_init_verbs[] = {
11232         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11233
11234         { }
11235 };
11236
11237 /* toggle speaker-output according to the hp-jack state */
11238 static void alc861_toshiba_automute(struct hda_codec *codec)
11239 {
11240         unsigned int present;
11241
11242         present = snd_hda_codec_read(codec, 0x0f, 0,
11243                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11244         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
11245                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
11246         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
11247                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
11248 }
11249
11250 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
11251                                        unsigned int res)
11252 {
11253         if ((res >> 26) == ALC880_HP_EVENT)
11254                 alc861_toshiba_automute(codec);
11255 }
11256
11257 /* pcm configuration: identiacal with ALC880 */
11258 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
11259 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
11260 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
11261 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
11262
11263
11264 #define ALC861_DIGOUT_NID       0x07
11265
11266 static struct hda_channel_mode alc861_8ch_modes[1] = {
11267         { 8, NULL }
11268 };
11269
11270 static hda_nid_t alc861_dac_nids[4] = {
11271         /* front, surround, clfe, side */
11272         0x03, 0x06, 0x05, 0x04
11273 };
11274
11275 static hda_nid_t alc660_dac_nids[3] = {
11276         /* front, clfe, surround */
11277         0x03, 0x05, 0x06
11278 };
11279
11280 static hda_nid_t alc861_adc_nids[1] = {
11281         /* ADC0-2 */
11282         0x08,
11283 };
11284
11285 static struct hda_input_mux alc861_capture_source = {
11286         .num_items = 5,
11287         .items = {
11288                 { "Mic", 0x0 },
11289                 { "Front Mic", 0x3 },
11290                 { "Line", 0x1 },
11291                 { "CD", 0x4 },
11292                 { "Mixer", 0x5 },
11293         },
11294 };
11295
11296 /* fill in the dac_nids table from the parsed pin configuration */
11297 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
11298                                      const struct auto_pin_cfg *cfg)
11299 {
11300         int i;
11301         hda_nid_t nid;
11302
11303         spec->multiout.dac_nids = spec->private_dac_nids;
11304         for (i = 0; i < cfg->line_outs; i++) {
11305                 nid = cfg->line_out_pins[i];
11306                 if (nid) {
11307                         if (i >= ARRAY_SIZE(alc861_dac_nids))
11308                                 continue;
11309                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
11310                 }
11311         }
11312         spec->multiout.num_dacs = cfg->line_outs;
11313         return 0;
11314 }
11315
11316 /* add playback controls from the parsed DAC table */
11317 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
11318                                              const struct auto_pin_cfg *cfg)
11319 {
11320         char name[32];
11321         static const char *chname[4] = {
11322                 "Front", "Surround", NULL /*CLFE*/, "Side"
11323         };
11324         hda_nid_t nid;
11325         int i, idx, err;
11326
11327         for (i = 0; i < cfg->line_outs; i++) {
11328                 nid = spec->multiout.dac_nids[i];
11329                 if (!nid)
11330                         continue;
11331                 if (nid == 0x05) {
11332                         /* Center/LFE */
11333                         err = add_control(spec, ALC_CTL_BIND_MUTE,
11334                                           "Center Playback Switch",
11335                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
11336                                                               HDA_OUTPUT));
11337                         if (err < 0)
11338                                 return err;
11339                         err = add_control(spec, ALC_CTL_BIND_MUTE,
11340                                           "LFE Playback Switch",
11341                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
11342                                                               HDA_OUTPUT));
11343                         if (err < 0)
11344                                 return err;
11345                 } else {
11346                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
11347                              idx++)
11348                                 if (nid == alc861_dac_nids[idx])
11349                                         break;
11350                         sprintf(name, "%s Playback Switch", chname[idx]);
11351                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
11352                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
11353                                                               HDA_OUTPUT));
11354                         if (err < 0)
11355                                 return err;
11356                 }
11357         }
11358         return 0;
11359 }
11360
11361 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
11362 {
11363         int err;
11364         hda_nid_t nid;
11365
11366         if (!pin)
11367                 return 0;
11368
11369         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
11370                 nid = 0x03;
11371                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11372                                   "Headphone Playback Switch",
11373                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
11374                 if (err < 0)
11375                         return err;
11376                 spec->multiout.hp_nid = nid;
11377         }
11378         return 0;
11379 }
11380
11381 /* create playback/capture controls for input pins */
11382 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
11383                                                 const struct auto_pin_cfg *cfg)
11384 {
11385         struct hda_input_mux *imux = &spec->private_imux;
11386         int i, err, idx, idx1;
11387
11388         for (i = 0; i < AUTO_PIN_LAST; i++) {
11389                 switch (cfg->input_pins[i]) {
11390                 case 0x0c:
11391                         idx1 = 1;
11392                         idx = 2;        /* Line In */
11393                         break;
11394                 case 0x0f:
11395                         idx1 = 2;
11396                         idx = 2;        /* Line In */
11397                         break;
11398                 case 0x0d:
11399                         idx1 = 0;
11400                         idx = 1;        /* Mic In */
11401                         break;
11402                 case 0x10:
11403                         idx1 = 3;
11404                         idx = 1;        /* Mic In */
11405                         break;
11406                 case 0x11:
11407                         idx1 = 4;
11408                         idx = 0;        /* CD */
11409                         break;
11410                 default:
11411                         continue;
11412                 }
11413
11414                 err = new_analog_input(spec, cfg->input_pins[i],
11415                                        auto_pin_cfg_labels[i], idx, 0x15);
11416                 if (err < 0)
11417                         return err;
11418
11419                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11420                 imux->items[imux->num_items].index = idx1;
11421                 imux->num_items++;
11422         }
11423         return 0;
11424 }
11425
11426 static struct snd_kcontrol_new alc861_capture_mixer[] = {
11427         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11428         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11429
11430         {
11431                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11432                 /* The multiple "Capture Source" controls confuse alsamixer
11433                  * So call somewhat different..
11434                  */
11435                 /* .name = "Capture Source", */
11436                 .name = "Input Source",
11437                 .count = 1,
11438                 .info = alc_mux_enum_info,
11439                 .get = alc_mux_enum_get,
11440                 .put = alc_mux_enum_put,
11441         },
11442         { } /* end */
11443 };
11444
11445 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
11446                                               hda_nid_t nid,
11447                                               int pin_type, int dac_idx)
11448 {
11449         alc_set_pin_output(codec, nid, pin_type);
11450 }
11451
11452 static void alc861_auto_init_multi_out(struct hda_codec *codec)
11453 {
11454         struct alc_spec *spec = codec->spec;
11455         int i;
11456
11457         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
11458         for (i = 0; i < spec->autocfg.line_outs; i++) {
11459                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
11460                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
11461                 if (nid)
11462                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
11463                                                           spec->multiout.dac_nids[i]);
11464         }
11465 }
11466
11467 static void alc861_auto_init_hp_out(struct hda_codec *codec)
11468 {
11469         struct alc_spec *spec = codec->spec;
11470         hda_nid_t pin;
11471
11472         pin = spec->autocfg.hp_pins[0];
11473         if (pin) /* connect to front */
11474                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
11475                                                   spec->multiout.dac_nids[0]);
11476         pin = spec->autocfg.speaker_pins[0];
11477         if (pin)
11478                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
11479 }
11480
11481 static void alc861_auto_init_analog_input(struct hda_codec *codec)
11482 {
11483         struct alc_spec *spec = codec->spec;
11484         int i;
11485
11486         for (i = 0; i < AUTO_PIN_LAST; i++) {
11487                 hda_nid_t nid = spec->autocfg.input_pins[i];
11488                 if (nid >= 0x0c && nid <= 0x11) {
11489                         snd_hda_codec_write(codec, nid, 0,
11490                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
11491                                             i <= AUTO_PIN_FRONT_MIC ?
11492                                             PIN_VREF80 : PIN_IN);
11493                 }
11494         }
11495 }
11496
11497 /* parse the BIOS configuration and set up the alc_spec */
11498 /* return 1 if successful, 0 if the proper config is not found,
11499  * or a negative error code
11500  */
11501 static int alc861_parse_auto_config(struct hda_codec *codec)
11502 {
11503         struct alc_spec *spec = codec->spec;
11504         int err;
11505         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11506
11507         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11508                                            alc861_ignore);
11509         if (err < 0)
11510                 return err;
11511         if (!spec->autocfg.line_outs)
11512                 return 0; /* can't find valid BIOS pin config */
11513
11514         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
11515         if (err < 0)
11516                 return err;
11517         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
11518         if (err < 0)
11519                 return err;
11520         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
11521         if (err < 0)
11522                 return err;
11523         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
11524         if (err < 0)
11525                 return err;
11526
11527         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11528
11529         if (spec->autocfg.dig_out_pin)
11530                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
11531
11532         if (spec->kctl_alloc)
11533                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11534
11535         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
11536
11537         spec->num_mux_defs = 1;
11538         spec->input_mux = &spec->private_imux;
11539
11540         spec->adc_nids = alc861_adc_nids;
11541         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
11542         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
11543         spec->num_mixers++;
11544
11545         return 1;
11546 }
11547
11548 /* additional initialization for auto-configuration model */
11549 static void alc861_auto_init(struct hda_codec *codec)
11550 {
11551         struct alc_spec *spec = codec->spec;
11552         alc861_auto_init_multi_out(codec);
11553         alc861_auto_init_hp_out(codec);
11554         alc861_auto_init_analog_input(codec);
11555         if (spec->unsol_event)
11556                 alc_sku_automute(codec);
11557 }
11558
11559 #ifdef CONFIG_SND_HDA_POWER_SAVE
11560 static struct hda_amp_list alc861_loopbacks[] = {
11561         { 0x15, HDA_INPUT, 0 },
11562         { 0x15, HDA_INPUT, 1 },
11563         { 0x15, HDA_INPUT, 2 },
11564         { 0x15, HDA_INPUT, 3 },
11565         { } /* end */
11566 };
11567 #endif
11568
11569
11570 /*
11571  * configuration and preset
11572  */
11573 static const char *alc861_models[ALC861_MODEL_LAST] = {
11574         [ALC861_3ST]            = "3stack",
11575         [ALC660_3ST]            = "3stack-660",
11576         [ALC861_3ST_DIG]        = "3stack-dig",
11577         [ALC861_6ST_DIG]        = "6stack-dig",
11578         [ALC861_UNIWILL_M31]    = "uniwill-m31",
11579         [ALC861_TOSHIBA]        = "toshiba",
11580         [ALC861_ASUS]           = "asus",
11581         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
11582         [ALC861_AUTO]           = "auto",
11583 };
11584
11585 static struct snd_pci_quirk alc861_cfg_tbl[] = {
11586         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
11587         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
11588         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
11589         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
11590         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
11591         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
11592         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
11593         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
11594          *        Any other models that need this preset?
11595          */
11596         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
11597         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
11598         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
11599         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
11600         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
11601         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
11602         /* FIXME: the below seems conflict */
11603         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
11604         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
11605         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
11606         {}
11607 };
11608
11609 static struct alc_config_preset alc861_presets[] = {
11610         [ALC861_3ST] = {
11611                 .mixers = { alc861_3ST_mixer },
11612                 .init_verbs = { alc861_threestack_init_verbs },
11613                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11614                 .dac_nids = alc861_dac_nids,
11615                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
11616                 .channel_mode = alc861_threestack_modes,
11617                 .need_dac_fix = 1,
11618                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11619                 .adc_nids = alc861_adc_nids,
11620                 .input_mux = &alc861_capture_source,
11621         },
11622         [ALC861_3ST_DIG] = {
11623                 .mixers = { alc861_base_mixer },
11624                 .init_verbs = { alc861_threestack_init_verbs },
11625                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11626                 .dac_nids = alc861_dac_nids,
11627                 .dig_out_nid = ALC861_DIGOUT_NID,
11628                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
11629                 .channel_mode = alc861_threestack_modes,
11630                 .need_dac_fix = 1,
11631                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11632                 .adc_nids = alc861_adc_nids,
11633                 .input_mux = &alc861_capture_source,
11634         },
11635         [ALC861_6ST_DIG] = {
11636                 .mixers = { alc861_base_mixer },
11637                 .init_verbs = { alc861_base_init_verbs },
11638                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11639                 .dac_nids = alc861_dac_nids,
11640                 .dig_out_nid = ALC861_DIGOUT_NID,
11641                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
11642                 .channel_mode = alc861_8ch_modes,
11643                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11644                 .adc_nids = alc861_adc_nids,
11645                 .input_mux = &alc861_capture_source,
11646         },
11647         [ALC660_3ST] = {
11648                 .mixers = { alc861_3ST_mixer },
11649                 .init_verbs = { alc861_threestack_init_verbs },
11650                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
11651                 .dac_nids = alc660_dac_nids,
11652                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
11653                 .channel_mode = alc861_threestack_modes,
11654                 .need_dac_fix = 1,
11655                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11656                 .adc_nids = alc861_adc_nids,
11657                 .input_mux = &alc861_capture_source,
11658         },
11659         [ALC861_UNIWILL_M31] = {
11660                 .mixers = { alc861_uniwill_m31_mixer },
11661                 .init_verbs = { alc861_uniwill_m31_init_verbs },
11662                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11663                 .dac_nids = alc861_dac_nids,
11664                 .dig_out_nid = ALC861_DIGOUT_NID,
11665                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
11666                 .channel_mode = alc861_uniwill_m31_modes,
11667                 .need_dac_fix = 1,
11668                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11669                 .adc_nids = alc861_adc_nids,
11670                 .input_mux = &alc861_capture_source,
11671         },
11672         [ALC861_TOSHIBA] = {
11673                 .mixers = { alc861_toshiba_mixer },
11674                 .init_verbs = { alc861_base_init_verbs,
11675                                 alc861_toshiba_init_verbs },
11676                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11677                 .dac_nids = alc861_dac_nids,
11678                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
11679                 .channel_mode = alc883_3ST_2ch_modes,
11680                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11681                 .adc_nids = alc861_adc_nids,
11682                 .input_mux = &alc861_capture_source,
11683                 .unsol_event = alc861_toshiba_unsol_event,
11684                 .init_hook = alc861_toshiba_automute,
11685         },
11686         [ALC861_ASUS] = {
11687                 .mixers = { alc861_asus_mixer },
11688                 .init_verbs = { alc861_asus_init_verbs },
11689                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11690                 .dac_nids = alc861_dac_nids,
11691                 .dig_out_nid = ALC861_DIGOUT_NID,
11692                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
11693                 .channel_mode = alc861_asus_modes,
11694                 .need_dac_fix = 1,
11695                 .hp_nid = 0x06,
11696                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11697                 .adc_nids = alc861_adc_nids,
11698                 .input_mux = &alc861_capture_source,
11699         },
11700         [ALC861_ASUS_LAPTOP] = {
11701                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
11702                 .init_verbs = { alc861_asus_init_verbs,
11703                                 alc861_asus_laptop_init_verbs },
11704                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
11705                 .dac_nids = alc861_dac_nids,
11706                 .dig_out_nid = ALC861_DIGOUT_NID,
11707                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
11708                 .channel_mode = alc883_3ST_2ch_modes,
11709                 .need_dac_fix = 1,
11710                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
11711                 .adc_nids = alc861_adc_nids,
11712                 .input_mux = &alc861_capture_source,
11713         },
11714 };
11715
11716
11717 static int patch_alc861(struct hda_codec *codec)
11718 {
11719         struct alc_spec *spec;
11720         int board_config;
11721         int err;
11722
11723         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11724         if (spec == NULL)
11725                 return -ENOMEM;
11726
11727         codec->spec = spec;
11728
11729         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
11730                                                   alc861_models,
11731                                                   alc861_cfg_tbl);
11732
11733         if (board_config < 0) {
11734                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
11735                        "trying auto-probe from BIOS...\n");
11736                 board_config = ALC861_AUTO;
11737         }
11738
11739         if (board_config == ALC861_AUTO) {
11740                 /* automatic parse from the BIOS config */
11741                 err = alc861_parse_auto_config(codec);
11742                 if (err < 0) {
11743                         alc_free(codec);
11744                         return err;
11745                 } else if (!err) {
11746                         printk(KERN_INFO
11747                                "hda_codec: Cannot set up configuration "
11748                                "from BIOS.  Using base mode...\n");
11749                    board_config = ALC861_3ST_DIG;
11750                 }
11751         }
11752
11753         if (board_config != ALC861_AUTO)
11754                 setup_preset(spec, &alc861_presets[board_config]);
11755
11756         spec->stream_name_analog = "ALC861 Analog";
11757         spec->stream_analog_playback = &alc861_pcm_analog_playback;
11758         spec->stream_analog_capture = &alc861_pcm_analog_capture;
11759
11760         spec->stream_name_digital = "ALC861 Digital";
11761         spec->stream_digital_playback = &alc861_pcm_digital_playback;
11762         spec->stream_digital_capture = &alc861_pcm_digital_capture;
11763
11764         spec->vmaster_nid = 0x03;
11765
11766         codec->patch_ops = alc_patch_ops;
11767         if (board_config == ALC861_AUTO)
11768                 spec->init_hook = alc861_auto_init;
11769 #ifdef CONFIG_SND_HDA_POWER_SAVE
11770         if (!spec->loopback.amplist)
11771                 spec->loopback.amplist = alc861_loopbacks;
11772 #endif
11773
11774         return 0;
11775 }
11776
11777 /*
11778  * ALC861-VD support
11779  *
11780  * Based on ALC882
11781  *
11782  * In addition, an independent DAC
11783  */
11784 #define ALC861VD_DIGOUT_NID     0x06
11785
11786 static hda_nid_t alc861vd_dac_nids[4] = {
11787         /* front, surr, clfe, side surr */
11788         0x02, 0x03, 0x04, 0x05
11789 };
11790
11791 /* dac_nids for ALC660vd are in a different order - according to
11792  * Realtek's driver.
11793  * This should probably tesult in a different mixer for 6stack models
11794  * of ALC660vd codecs, but for now there is only 3stack mixer
11795  * - and it is the same as in 861vd.
11796  * adc_nids in ALC660vd are (is) the same as in 861vd
11797  */
11798 static hda_nid_t alc660vd_dac_nids[3] = {
11799         /* front, rear, clfe, rear_surr */
11800         0x02, 0x04, 0x03
11801 };
11802
11803 static hda_nid_t alc861vd_adc_nids[1] = {
11804         /* ADC0 */
11805         0x09,
11806 };
11807
11808 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
11809
11810 /* input MUX */
11811 /* FIXME: should be a matrix-type input source selection */
11812 static struct hda_input_mux alc861vd_capture_source = {
11813         .num_items = 4,
11814         .items = {
11815                 { "Mic", 0x0 },
11816                 { "Front Mic", 0x1 },
11817                 { "Line", 0x2 },
11818                 { "CD", 0x4 },
11819         },
11820 };
11821
11822 static struct hda_input_mux alc861vd_dallas_capture_source = {
11823         .num_items = 3,
11824         .items = {
11825                 { "Front Mic", 0x0 },
11826                 { "ATAPI Mic", 0x1 },
11827                 { "Line In", 0x5 },
11828         },
11829 };
11830
11831 static struct hda_input_mux alc861vd_hp_capture_source = {
11832         .num_items = 2,
11833         .items = {
11834                 { "Front Mic", 0x0 },
11835                 { "ATAPI Mic", 0x1 },
11836         },
11837 };
11838
11839 #define alc861vd_mux_enum_info alc_mux_enum_info
11840 #define alc861vd_mux_enum_get alc_mux_enum_get
11841 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
11842 #define alc861vd_mux_enum_put alc882_mux_enum_put
11843
11844 /*
11845  * 2ch mode
11846  */
11847 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
11848         { 2, NULL }
11849 };
11850
11851 /*
11852  * 6ch mode
11853  */
11854 static struct hda_verb alc861vd_6stack_ch6_init[] = {
11855         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
11856         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11857         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11858         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11859         { } /* end */
11860 };
11861
11862 /*
11863  * 8ch mode
11864  */
11865 static struct hda_verb alc861vd_6stack_ch8_init[] = {
11866         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11867         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11868         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11869         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11870         { } /* end */
11871 };
11872
11873 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
11874         { 6, alc861vd_6stack_ch6_init },
11875         { 8, alc861vd_6stack_ch8_init },
11876 };
11877
11878 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
11879         {
11880                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11881                 .name = "Channel Mode",
11882                 .info = alc_ch_mode_info,
11883                 .get = alc_ch_mode_get,
11884                 .put = alc_ch_mode_put,
11885         },
11886         { } /* end */
11887 };
11888
11889 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
11890         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
11891         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
11892
11893         {
11894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11895                 /* The multiple "Capture Source" controls confuse alsamixer
11896                  * So call somewhat different..
11897                  */
11898                 /* .name = "Capture Source", */
11899                 .name = "Input Source",
11900                 .count = 1,
11901                 .info = alc861vd_mux_enum_info,
11902                 .get = alc861vd_mux_enum_get,
11903                 .put = alc861vd_mux_enum_put,
11904         },
11905         { } /* end */
11906 };
11907
11908 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
11909  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
11910  */
11911 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
11912         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11913         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
11914
11915         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11916         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
11917
11918         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
11919                                 HDA_OUTPUT),
11920         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
11921                                 HDA_OUTPUT),
11922         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11923         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
11924
11925         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
11926         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
11927
11928         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11929
11930         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11931         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11932         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11933
11934         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11935         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11936         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11937
11938         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11939         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11940
11941         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11942         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11943
11944         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
11945         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
11946
11947         { } /* end */
11948 };
11949
11950 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
11951         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11952         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
11953
11954         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11955
11956         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11957         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11958         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11959
11960         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11961         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11962         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11963
11964         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11965         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11966
11967         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11968         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11969
11970         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
11971         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
11972
11973         { } /* end */
11974 };
11975
11976 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
11977         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11978         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
11979         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11980
11981         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11982
11983         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11984         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11985         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11986
11987         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11988         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11989         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11990
11991         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11992         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11993
11994         { } /* end */
11995 };
11996
11997 /* Pin assignment: Front=0x14, HP = 0x15,
11998  *                 Front Mic=0x18, ATAPI Mic = 0x19, Line In = 0x1d
11999  */
12000 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
12001         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12002         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12003         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12004         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12005         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12006         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12007         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12008         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12009         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x05, HDA_INPUT),
12010         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x05, HDA_INPUT),
12011         { } /* end */
12012 };
12013
12014 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
12015  *                 Front Mic=0x18, ATAPI Mic = 0x19,
12016  */
12017 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
12018         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12019         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
12020         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12021         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
12022         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12023         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12024         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12025         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12026
12027         { } /* end */
12028 };
12029
12030 /*
12031  * generic initialization of ADC, input mixers and output mixers
12032  */
12033 static struct hda_verb alc861vd_volume_init_verbs[] = {
12034         /*
12035          * Unmute ADC0 and set the default input to mic-in
12036          */
12037         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12038         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12039
12040         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
12041          * the analog-loopback mixer widget
12042          */
12043         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12044         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12045         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12046         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12047         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12049
12050         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
12051         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12052         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12053         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12054         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
12055
12056         /*
12057          * Set up output mixers (0x02 - 0x05)
12058          */
12059         /* set vol=0 to output mixers */
12060         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12061         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12062         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12063         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12064
12065         /* set up input amps for analog loopback */
12066         /* Amp Indices: DAC = 0, mixer = 1 */
12067         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12068         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12069         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12070         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12071         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12072         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12073         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12074         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12075
12076         { }
12077 };
12078
12079 /*
12080  * 3-stack pin configuration:
12081  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
12082  */
12083 static struct hda_verb alc861vd_3stack_init_verbs[] = {
12084         /*
12085          * Set pin mode and muting
12086          */
12087         /* set front pin widgets 0x14 for output */
12088         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12089         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12090         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12091
12092         /* Mic (rear) pin: input vref at 80% */
12093         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12094         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12095         /* Front Mic pin: input vref at 80% */
12096         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12097         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12098         /* Line In pin: input */
12099         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12100         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12101         /* Line-2 In: Headphone output (output 0 - 0x0c) */
12102         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12103         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12104         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12105         /* CD pin widget for input */
12106         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12107
12108         { }
12109 };
12110
12111 /*
12112  * 6-stack pin configuration:
12113  */
12114 static struct hda_verb alc861vd_6stack_init_verbs[] = {
12115         /*
12116          * Set pin mode and muting
12117          */
12118         /* set front pin widgets 0x14 for output */
12119         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12120         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12121         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12122
12123         /* Rear Pin: output 1 (0x0d) */
12124         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12125         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12126         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12127         /* CLFE Pin: output 2 (0x0e) */
12128         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12129         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12130         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
12131         /* Side Pin: output 3 (0x0f) */
12132         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12133         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12134         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
12135
12136         /* Mic (rear) pin: input vref at 80% */
12137         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12138         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12139         /* Front Mic pin: input vref at 80% */
12140         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12141         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12142         /* Line In pin: input */
12143         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12144         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12145         /* Line-2 In: Headphone output (output 0 - 0x0c) */
12146         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12147         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12148         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12149         /* CD pin widget for input */
12150         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12151
12152         { }
12153 };
12154
12155 static struct hda_verb alc861vd_eapd_verbs[] = {
12156         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12157         { }
12158 };
12159
12160 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
12161         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12162         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12163         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12164         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12165         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12166         {}
12167 };
12168
12169 /* toggle speaker-output according to the hp-jack state */
12170 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
12171 {
12172         unsigned int present;
12173         unsigned char bits;
12174
12175         present = snd_hda_codec_read(codec, 0x1b, 0,
12176                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12177         bits = present ? HDA_AMP_MUTE : 0;
12178         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12179                                  HDA_AMP_MUTE, bits);
12180 }
12181
12182 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
12183 {
12184         unsigned int present;
12185         unsigned char bits;
12186
12187         present = snd_hda_codec_read(codec, 0x18, 0,
12188                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12189         bits = present ? HDA_AMP_MUTE : 0;
12190         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
12191                                  HDA_AMP_MUTE, bits);
12192 }
12193
12194 static void alc861vd_lenovo_automute(struct hda_codec *codec)
12195 {
12196         alc861vd_lenovo_hp_automute(codec);
12197         alc861vd_lenovo_mic_automute(codec);
12198 }
12199
12200 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
12201                                         unsigned int res)
12202 {
12203         switch (res >> 26) {
12204         case ALC880_HP_EVENT:
12205                 alc861vd_lenovo_hp_automute(codec);
12206                 break;
12207         case ALC880_MIC_EVENT:
12208                 alc861vd_lenovo_mic_automute(codec);
12209                 break;
12210         }
12211 }
12212
12213 static struct hda_verb alc861vd_dallas_verbs[] = {
12214         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12215         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12216         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12217         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12218
12219         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12220         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12221         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12222         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12223         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12224         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12225         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12226         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12227
12228         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12229         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12230         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12231         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12232         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12233         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12234         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12235         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12236
12237         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
12238         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12239         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
12240         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12241         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12242         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12243         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12244         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12245
12246         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12247         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12248         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12249         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12250
12251         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12252         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12253         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12254
12255         { } /* end */
12256 };
12257
12258 /* toggle speaker-output according to the hp-jack state */
12259 static void alc861vd_dallas_automute(struct hda_codec *codec)
12260 {
12261         unsigned int present;
12262
12263         present = snd_hda_codec_read(codec, 0x15, 0,
12264                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12265         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12266                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
12267 }
12268
12269 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
12270 {
12271         if ((res >> 26) == ALC880_HP_EVENT)
12272                 alc861vd_dallas_automute(codec);
12273 }
12274
12275 #ifdef CONFIG_SND_HDA_POWER_SAVE
12276 #define alc861vd_loopbacks      alc880_loopbacks
12277 #endif
12278
12279 /* pcm configuration: identiacal with ALC880 */
12280 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
12281 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
12282 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
12283 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
12284
12285 /*
12286  * configuration and preset
12287  */
12288 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
12289         [ALC660VD_3ST]          = "3stack-660",
12290         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
12291         [ALC861VD_3ST]          = "3stack",
12292         [ALC861VD_3ST_DIG]      = "3stack-digout",
12293         [ALC861VD_6ST_DIG]      = "6stack-digout",
12294         [ALC861VD_LENOVO]       = "lenovo",
12295         [ALC861VD_DALLAS]       = "dallas",
12296         [ALC861VD_HP]           = "hp",
12297         [ALC861VD_AUTO]         = "auto",
12298 };
12299
12300 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
12301         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
12302         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
12303         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
12304         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
12305         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
12306         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
12307         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
12308         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
12309         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
12310         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
12311         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
12312         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
12313         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
12314         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
12315         {}
12316 };
12317
12318 static struct alc_config_preset alc861vd_presets[] = {
12319         [ALC660VD_3ST] = {
12320                 .mixers = { alc861vd_3st_mixer },
12321                 .init_verbs = { alc861vd_volume_init_verbs,
12322                                  alc861vd_3stack_init_verbs },
12323                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
12324                 .dac_nids = alc660vd_dac_nids,
12325                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12326                 .channel_mode = alc861vd_3stack_2ch_modes,
12327                 .input_mux = &alc861vd_capture_source,
12328         },
12329         [ALC660VD_3ST_DIG] = {
12330                 .mixers = { alc861vd_3st_mixer },
12331                 .init_verbs = { alc861vd_volume_init_verbs,
12332                                  alc861vd_3stack_init_verbs },
12333                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
12334                 .dac_nids = alc660vd_dac_nids,
12335                 .dig_out_nid = ALC861VD_DIGOUT_NID,
12336                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12337                 .channel_mode = alc861vd_3stack_2ch_modes,
12338                 .input_mux = &alc861vd_capture_source,
12339         },
12340         [ALC861VD_3ST] = {
12341                 .mixers = { alc861vd_3st_mixer },
12342                 .init_verbs = { alc861vd_volume_init_verbs,
12343                                  alc861vd_3stack_init_verbs },
12344                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
12345                 .dac_nids = alc861vd_dac_nids,
12346                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12347                 .channel_mode = alc861vd_3stack_2ch_modes,
12348                 .input_mux = &alc861vd_capture_source,
12349         },
12350         [ALC861VD_3ST_DIG] = {
12351                 .mixers = { alc861vd_3st_mixer },
12352                 .init_verbs = { alc861vd_volume_init_verbs,
12353                                  alc861vd_3stack_init_verbs },
12354                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
12355                 .dac_nids = alc861vd_dac_nids,
12356                 .dig_out_nid = ALC861VD_DIGOUT_NID,
12357                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12358                 .channel_mode = alc861vd_3stack_2ch_modes,
12359                 .input_mux = &alc861vd_capture_source,
12360         },
12361         [ALC861VD_6ST_DIG] = {
12362                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
12363                 .init_verbs = { alc861vd_volume_init_verbs,
12364                                 alc861vd_6stack_init_verbs },
12365                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
12366                 .dac_nids = alc861vd_dac_nids,
12367                 .dig_out_nid = ALC861VD_DIGOUT_NID,
12368                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
12369                 .channel_mode = alc861vd_6stack_modes,
12370                 .input_mux = &alc861vd_capture_source,
12371         },
12372         [ALC861VD_LENOVO] = {
12373                 .mixers = { alc861vd_lenovo_mixer },
12374                 .init_verbs = { alc861vd_volume_init_verbs,
12375                                 alc861vd_3stack_init_verbs,
12376                                 alc861vd_eapd_verbs,
12377                                 alc861vd_lenovo_unsol_verbs },
12378                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
12379                 .dac_nids = alc660vd_dac_nids,
12380                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12381                 .channel_mode = alc861vd_3stack_2ch_modes,
12382                 .input_mux = &alc861vd_capture_source,
12383                 .unsol_event = alc861vd_lenovo_unsol_event,
12384                 .init_hook = alc861vd_lenovo_automute,
12385         },
12386         [ALC861VD_DALLAS] = {
12387                 .mixers = { alc861vd_dallas_mixer },
12388                 .init_verbs = { alc861vd_dallas_verbs },
12389                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
12390                 .dac_nids = alc861vd_dac_nids,
12391                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12392                 .channel_mode = alc861vd_3stack_2ch_modes,
12393                 .input_mux = &alc861vd_dallas_capture_source,
12394                 .unsol_event = alc861vd_dallas_unsol_event,
12395                 .init_hook = alc861vd_dallas_automute,
12396         },
12397         [ALC861VD_HP] = {
12398                 .mixers = { alc861vd_hp_mixer },
12399                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
12400                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
12401                 .dac_nids = alc861vd_dac_nids,
12402                 .dig_out_nid = ALC861VD_DIGOUT_NID,
12403                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
12404                 .channel_mode = alc861vd_3stack_2ch_modes,
12405                 .input_mux = &alc861vd_hp_capture_source,
12406                 .unsol_event = alc861vd_dallas_unsol_event,
12407                 .init_hook = alc861vd_dallas_automute,
12408         },
12409 };
12410
12411 /*
12412  * BIOS auto configuration
12413  */
12414 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
12415                                 hda_nid_t nid, int pin_type, int dac_idx)
12416 {
12417         alc_set_pin_output(codec, nid, pin_type);
12418 }
12419
12420 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
12421 {
12422         struct alc_spec *spec = codec->spec;
12423         int i;
12424
12425         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
12426         for (i = 0; i <= HDA_SIDE; i++) {
12427                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
12428                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12429                 if (nid)
12430                         alc861vd_auto_set_output_and_unmute(codec, nid,
12431                                                             pin_type, i);
12432         }
12433 }
12434
12435
12436 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
12437 {
12438         struct alc_spec *spec = codec->spec;
12439         hda_nid_t pin;
12440
12441         pin = spec->autocfg.hp_pins[0];
12442         if (pin) /* connect to front and  use dac 0 */
12443                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
12444         pin = spec->autocfg.speaker_pins[0];
12445         if (pin)
12446                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
12447 }
12448
12449 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
12450 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
12451
12452 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
12453 {
12454         struct alc_spec *spec = codec->spec;
12455         int i;
12456
12457         for (i = 0; i < AUTO_PIN_LAST; i++) {
12458                 hda_nid_t nid = spec->autocfg.input_pins[i];
12459                 if (alc861vd_is_input_pin(nid)) {
12460                         snd_hda_codec_write(codec, nid, 0,
12461                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
12462                                         i <= AUTO_PIN_FRONT_MIC ?
12463                                                         PIN_VREF80 : PIN_IN);
12464                         if (nid != ALC861VD_PIN_CD_NID)
12465                                 snd_hda_codec_write(codec, nid, 0,
12466                                                 AC_VERB_SET_AMP_GAIN_MUTE,
12467                                                 AMP_OUT_MUTE);
12468                 }
12469         }
12470 }
12471
12472 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
12473 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
12474
12475 /* add playback controls from the parsed DAC table */
12476 /* Based on ALC880 version. But ALC861VD has separate,
12477  * different NIDs for mute/unmute switch and volume control */
12478 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
12479                                              const struct auto_pin_cfg *cfg)
12480 {
12481         char name[32];
12482         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
12483         hda_nid_t nid_v, nid_s;
12484         int i, err;
12485
12486         for (i = 0; i < cfg->line_outs; i++) {
12487                 if (!spec->multiout.dac_nids[i])
12488                         continue;
12489                 nid_v = alc861vd_idx_to_mixer_vol(
12490                                 alc880_dac_to_idx(
12491                                         spec->multiout.dac_nids[i]));
12492                 nid_s = alc861vd_idx_to_mixer_switch(
12493                                 alc880_dac_to_idx(
12494                                         spec->multiout.dac_nids[i]));
12495
12496                 if (i == 2) {
12497                         /* Center/LFE */
12498                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12499                                           "Center Playback Volume",
12500                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
12501                                                               HDA_OUTPUT));
12502                         if (err < 0)
12503                                 return err;
12504                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12505                                           "LFE Playback Volume",
12506                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
12507                                                               HDA_OUTPUT));
12508                         if (err < 0)
12509                                 return err;
12510                         err = add_control(spec, ALC_CTL_BIND_MUTE,
12511                                           "Center Playback Switch",
12512                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
12513                                                               HDA_INPUT));
12514                         if (err < 0)
12515                                 return err;
12516                         err = add_control(spec, ALC_CTL_BIND_MUTE,
12517                                           "LFE Playback Switch",
12518                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
12519                                                               HDA_INPUT));
12520                         if (err < 0)
12521                                 return err;
12522                 } else {
12523                         sprintf(name, "%s Playback Volume", chname[i]);
12524                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
12525                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
12526                                                               HDA_OUTPUT));
12527                         if (err < 0)
12528                                 return err;
12529                         sprintf(name, "%s Playback Switch", chname[i]);
12530                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
12531                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
12532                                                               HDA_INPUT));
12533                         if (err < 0)
12534                                 return err;
12535                 }
12536         }
12537         return 0;
12538 }
12539
12540 /* add playback controls for speaker and HP outputs */
12541 /* Based on ALC880 version. But ALC861VD has separate,
12542  * different NIDs for mute/unmute switch and volume control */
12543 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
12544                                         hda_nid_t pin, const char *pfx)
12545 {
12546         hda_nid_t nid_v, nid_s;
12547         int err;
12548         char name[32];
12549
12550         if (!pin)
12551                 return 0;
12552
12553         if (alc880_is_fixed_pin(pin)) {
12554                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
12555                 /* specify the DAC as the extra output */
12556                 if (!spec->multiout.hp_nid)
12557                         spec->multiout.hp_nid = nid_v;
12558                 else
12559                         spec->multiout.extra_out_nid[0] = nid_v;
12560                 /* control HP volume/switch on the output mixer amp */
12561                 nid_v = alc861vd_idx_to_mixer_vol(
12562                                 alc880_fixed_pin_idx(pin));
12563                 nid_s = alc861vd_idx_to_mixer_switch(
12564                                 alc880_fixed_pin_idx(pin));
12565
12566                 sprintf(name, "%s Playback Volume", pfx);
12567                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
12568                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
12569                 if (err < 0)
12570                         return err;
12571                 sprintf(name, "%s Playback Switch", pfx);
12572                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
12573                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
12574                 if (err < 0)
12575                         return err;
12576         } else if (alc880_is_multi_pin(pin)) {
12577                 /* set manual connection */
12578                 /* we have only a switch on HP-out PIN */
12579                 sprintf(name, "%s Playback Switch", pfx);
12580                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12581                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
12582                 if (err < 0)
12583                         return err;
12584         }
12585         return 0;
12586 }
12587
12588 /* parse the BIOS configuration and set up the alc_spec
12589  * return 1 if successful, 0 if the proper config is not found,
12590  * or a negative error code
12591  * Based on ALC880 version - had to change it to override
12592  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
12593 static int alc861vd_parse_auto_config(struct hda_codec *codec)
12594 {
12595         struct alc_spec *spec = codec->spec;
12596         int err;
12597         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
12598
12599         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12600                                            alc861vd_ignore);
12601         if (err < 0)
12602                 return err;
12603         if (!spec->autocfg.line_outs)
12604                 return 0; /* can't find valid BIOS pin config */
12605
12606         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
12607         if (err < 0)
12608                 return err;
12609         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
12610         if (err < 0)
12611                 return err;
12612         err = alc861vd_auto_create_extra_out(spec,
12613                                              spec->autocfg.speaker_pins[0],
12614                                              "Speaker");
12615         if (err < 0)
12616                 return err;
12617         err = alc861vd_auto_create_extra_out(spec,
12618                                              spec->autocfg.hp_pins[0],
12619                                              "Headphone");
12620         if (err < 0)
12621                 return err;
12622         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
12623         if (err < 0)
12624                 return err;
12625
12626         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12627
12628         if (spec->autocfg.dig_out_pin)
12629                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
12630
12631         if (spec->kctl_alloc)
12632                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12633
12634         spec->init_verbs[spec->num_init_verbs++]
12635                 = alc861vd_volume_init_verbs;
12636
12637         spec->num_mux_defs = 1;
12638         spec->input_mux = &spec->private_imux;
12639
12640         err = alc_auto_add_mic_boost(codec);
12641         if (err < 0)
12642                 return err;
12643
12644         return 1;
12645 }
12646
12647 /* additional initialization for auto-configuration model */
12648 static void alc861vd_auto_init(struct hda_codec *codec)
12649 {
12650         struct alc_spec *spec = codec->spec;
12651         alc861vd_auto_init_multi_out(codec);
12652         alc861vd_auto_init_hp_out(codec);
12653         alc861vd_auto_init_analog_input(codec);
12654         if (spec->unsol_event)
12655                 alc_sku_automute(codec);
12656 }
12657
12658 static int patch_alc861vd(struct hda_codec *codec)
12659 {
12660         struct alc_spec *spec;
12661         int err, board_config;
12662
12663         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12664         if (spec == NULL)
12665                 return -ENOMEM;
12666
12667         codec->spec = spec;
12668
12669         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
12670                                                   alc861vd_models,
12671                                                   alc861vd_cfg_tbl);
12672
12673         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
12674                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
12675                         "ALC861VD, trying auto-probe from BIOS...\n");
12676                 board_config = ALC861VD_AUTO;
12677         }
12678
12679         if (board_config == ALC861VD_AUTO) {
12680                 /* automatic parse from the BIOS config */
12681                 err = alc861vd_parse_auto_config(codec);
12682                 if (err < 0) {
12683                         alc_free(codec);
12684                         return err;
12685                 } else if (!err) {
12686                         printk(KERN_INFO
12687                                "hda_codec: Cannot set up configuration "
12688                                "from BIOS.  Using base mode...\n");
12689                         board_config = ALC861VD_3ST;
12690                 }
12691         }
12692
12693         if (board_config != ALC861VD_AUTO)
12694                 setup_preset(spec, &alc861vd_presets[board_config]);
12695
12696         spec->stream_name_analog = "ALC861VD Analog";
12697         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
12698         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
12699
12700         spec->stream_name_digital = "ALC861VD Digital";
12701         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
12702         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
12703
12704         spec->adc_nids = alc861vd_adc_nids;
12705         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
12706         spec->capsrc_nids = alc861vd_capsrc_nids;
12707
12708         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
12709         spec->num_mixers++;
12710
12711         spec->vmaster_nid = 0x02;
12712
12713         codec->patch_ops = alc_patch_ops;
12714
12715         if (board_config == ALC861VD_AUTO)
12716                 spec->init_hook = alc861vd_auto_init;
12717 #ifdef CONFIG_SND_HDA_POWER_SAVE
12718         if (!spec->loopback.amplist)
12719                 spec->loopback.amplist = alc861vd_loopbacks;
12720 #endif
12721
12722         return 0;
12723 }
12724
12725 /*
12726  * ALC662 support
12727  *
12728  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
12729  * configuration.  Each pin widget can choose any input DACs and a mixer.
12730  * Each ADC is connected from a mixer of all inputs.  This makes possible
12731  * 6-channel independent captures.
12732  *
12733  * In addition, an independent DAC for the multi-playback (not used in this
12734  * driver yet).
12735  */
12736 #define ALC662_DIGOUT_NID       0x06
12737 #define ALC662_DIGIN_NID        0x0a
12738
12739 static hda_nid_t alc662_dac_nids[4] = {
12740         /* front, rear, clfe, rear_surr */
12741         0x02, 0x03, 0x04
12742 };
12743
12744 static hda_nid_t alc662_adc_nids[1] = {
12745         /* ADC1-2 */
12746         0x09,
12747 };
12748
12749 static hda_nid_t alc662_capsrc_nids[1] = { 0x23 };
12750
12751 /* input MUX */
12752 /* FIXME: should be a matrix-type input source selection */
12753 static struct hda_input_mux alc662_capture_source = {
12754         .num_items = 4,
12755         .items = {
12756                 { "Mic", 0x0 },
12757                 { "Front Mic", 0x1 },
12758                 { "Line", 0x2 },
12759                 { "CD", 0x4 },
12760         },
12761 };
12762
12763 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
12764         .num_items = 2,
12765         .items = {
12766                 { "Mic", 0x1 },
12767                 { "Line", 0x2 },
12768         },
12769 };
12770
12771 static struct hda_input_mux alc662_eeepc_capture_source = {
12772         .num_items = 2,
12773         .items = {
12774                 { "i-Mic", 0x1 },
12775                 { "e-Mic", 0x0 },
12776         },
12777 };
12778
12779 #define alc662_mux_enum_info alc_mux_enum_info
12780 #define alc662_mux_enum_get alc_mux_enum_get
12781 #define alc662_mux_enum_put alc882_mux_enum_put
12782
12783 /*
12784  * 2ch mode
12785  */
12786 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
12787         { 2, NULL }
12788 };
12789
12790 /*
12791  * 2ch mode
12792  */
12793 static struct hda_verb alc662_3ST_ch2_init[] = {
12794         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
12795         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
12796         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
12797         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
12798         { } /* end */
12799 };
12800
12801 /*
12802  * 6ch mode
12803  */
12804 static struct hda_verb alc662_3ST_ch6_init[] = {
12805         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12806         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12807         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
12808         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12809         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12810         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
12811         { } /* end */
12812 };
12813
12814 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
12815         { 2, alc662_3ST_ch2_init },
12816         { 6, alc662_3ST_ch6_init },
12817 };
12818
12819 /*
12820  * 2ch mode
12821  */
12822 static struct hda_verb alc662_sixstack_ch6_init[] = {
12823         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12824         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12825         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12826         { } /* end */
12827 };
12828
12829 /*
12830  * 6ch mode
12831  */
12832 static struct hda_verb alc662_sixstack_ch8_init[] = {
12833         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12834         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12835         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12836         { } /* end */
12837 };
12838
12839 static struct hda_channel_mode alc662_5stack_modes[2] = {
12840         { 2, alc662_sixstack_ch6_init },
12841         { 6, alc662_sixstack_ch8_init },
12842 };
12843
12844 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
12845  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
12846  */
12847
12848 static struct snd_kcontrol_new alc662_base_mixer[] = {
12849         /* output mixer control */
12850         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12851         HDA_CODEC_MUTE("Front Playback Switch", 0x02, 0x0, HDA_OUTPUT),
12852         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12853         HDA_CODEC_MUTE("Surround Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12854         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
12855         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
12856         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
12857         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
12858         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12859
12860         /*Input mixer control */
12861         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
12862         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
12863         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
12864         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
12865         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
12866         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
12867         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
12868         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
12869         { } /* end */
12870 };
12871
12872 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
12873         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12874         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
12875         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12876         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12877         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12878         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12879         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12880         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12881         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12882         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12883         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12884         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12885         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12886         { } /* end */
12887 };
12888
12889 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
12890         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12891         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
12892         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12893         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
12894         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
12895         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
12896         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
12897         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
12898         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12899         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
12900         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
12901         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12902         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12903         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12904         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12905         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12906         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12907         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
12908         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
12909         { } /* end */
12910 };
12911
12912 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
12913         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12914         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
12915         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12916         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
12917         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12918         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12919         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12920         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12921         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12922         { } /* end */
12923 };
12924
12925 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
12926         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12927
12928         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12929         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12930
12931         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
12932         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12933         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12934
12935         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
12936         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
12937         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
12938         { } /* end */
12939 };
12940
12941 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
12942         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12943         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12944         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12945         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
12946         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
12947         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
12948         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
12949         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
12950         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
12951         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
12952         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12953         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12954         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12955         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12956         { } /* end */
12957 };
12958
12959 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
12960         {
12961                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12962                 .name = "Channel Mode",
12963                 .info = alc_ch_mode_info,
12964                 .get = alc_ch_mode_get,
12965                 .put = alc_ch_mode_put,
12966         },
12967         { } /* end */
12968 };
12969
12970 static struct hda_verb alc662_init_verbs[] = {
12971         /* ADC: mute amp left and right */
12972         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12973         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12974         /* Front mixer: unmute input/output amp left and right (volume = 0) */
12975
12976         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12977         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12978         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12979         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12980         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12981
12982         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12983         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12984         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12985         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12986         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12987         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12988
12989         /* Front Pin: output 0 (0x0c) */
12990         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12991         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12992
12993         /* Rear Pin: output 1 (0x0d) */
12994         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12995         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12996
12997         /* CLFE Pin: output 2 (0x0e) */
12998         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12999         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13000
13001         /* Mic (rear) pin: input vref at 80% */
13002         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13003         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13004         /* Front Mic pin: input vref at 80% */
13005         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13006         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13007         /* Line In pin: input */
13008         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13009         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13010         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13011         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13012         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13013         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13014         /* CD pin widget for input */
13015         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13016
13017         /* FIXME: use matrix-type input source selection */
13018         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
13019         /* Input mixer */
13020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13021         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13022         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13023         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13024
13025         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13026         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13027         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13028         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13029         { }
13030 };
13031
13032 static struct hda_verb alc662_sue_init_verbs[] = {
13033         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
13034         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
13035         {}
13036 };
13037
13038 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
13039         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13040         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13041         {}
13042 };
13043
13044 /* Set Unsolicited Event*/
13045 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
13046         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13047         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13048         {}
13049 };
13050
13051 /*
13052  * generic initialization of ADC, input mixers and output mixers
13053  */
13054 static struct hda_verb alc662_auto_init_verbs[] = {
13055         /*
13056          * Unmute ADC and set the default input to mic-in
13057          */
13058         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13059         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13060
13061         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
13062          * mixer widget
13063          * Note: PASD motherboards uses the Line In 2 as the input for front
13064          * panel mic (mic 2)
13065          */
13066         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13067         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13068         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13069         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13070         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13071         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13072
13073         /*
13074          * Set up output mixers (0x0c - 0x0f)
13075          */
13076         /* set vol=0 to output mixers */
13077         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13078         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13079         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13080
13081         /* set up input amps for analog loopback */
13082         /* Amp Indices: DAC = 0, mixer = 1 */
13083         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13084         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13085         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13086         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13087         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13088         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13089
13090
13091         /* FIXME: use matrix-type input source selection */
13092         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
13093         /* Input mixer */
13094         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13095         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13096         { }
13097 };
13098
13099 /* capture mixer elements */
13100 static struct snd_kcontrol_new alc662_capture_mixer[] = {
13101         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13102         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13103         {
13104                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13105                 /* The multiple "Capture Source" controls confuse alsamixer
13106                  * So call somewhat different..
13107                  */
13108                 /* .name = "Capture Source", */
13109                 .name = "Input Source",
13110                 .count = 1,
13111                 .info = alc662_mux_enum_info,
13112                 .get = alc662_mux_enum_get,
13113                 .put = alc662_mux_enum_put,
13114         },
13115         { } /* end */
13116 };
13117
13118 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
13119 {
13120         unsigned int present;
13121         unsigned char bits;
13122
13123         present = snd_hda_codec_read(codec, 0x14, 0,
13124                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13125         bits = present ? HDA_AMP_MUTE : 0;
13126         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13127                                  HDA_AMP_MUTE, bits);
13128 }
13129
13130 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
13131 {
13132         unsigned int present;
13133         unsigned char bits;
13134
13135         present = snd_hda_codec_read(codec, 0x1b, 0,
13136                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13137         bits = present ? HDA_AMP_MUTE : 0;
13138         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13139                                  HDA_AMP_MUTE, bits);
13140         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13141                                  HDA_AMP_MUTE, bits);
13142 }
13143
13144 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
13145                                            unsigned int res)
13146 {
13147         if ((res >> 26) == ALC880_HP_EVENT)
13148                 alc662_lenovo_101e_all_automute(codec);
13149         if ((res >> 26) == ALC880_FRONT_EVENT)
13150                 alc662_lenovo_101e_ispeaker_automute(codec);
13151 }
13152
13153 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
13154 {
13155         unsigned int present;
13156
13157         present = snd_hda_codec_read(codec, 0x18, 0,
13158                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13159         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13160                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
13161         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13162                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
13163         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13164                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
13165         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13166                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
13167 }
13168
13169 /* unsolicited event for HP jack sensing */
13170 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
13171                                      unsigned int res)
13172 {
13173         if ((res >> 26) == ALC880_HP_EVENT)
13174                 alc262_hippo1_automute( codec );
13175
13176         if ((res >> 26) == ALC880_MIC_EVENT)
13177                 alc662_eeepc_mic_automute(codec);
13178 }
13179
13180 static void alc662_eeepc_inithook(struct hda_codec *codec)
13181 {
13182         alc262_hippo1_automute( codec );
13183         alc662_eeepc_mic_automute(codec);
13184 }
13185
13186 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
13187 {
13188         unsigned int mute;
13189         unsigned int present;
13190
13191         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
13192         present = snd_hda_codec_read(codec, 0x14, 0,
13193                                      AC_VERB_GET_PIN_SENSE, 0);
13194         present = (present & 0x80000000) != 0;
13195         if (present) {
13196                 /* mute internal speaker */
13197                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
13198                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
13199         } else {
13200                 /* unmute internal speaker if necessary */
13201                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13202                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
13203                                          HDA_AMP_MUTE, mute);
13204         }
13205 }
13206
13207 /* unsolicited event for HP jack sensing */
13208 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
13209                                           unsigned int res)
13210 {
13211         if ((res >> 26) == ALC880_HP_EVENT)
13212                 alc662_eeepc_ep20_automute(codec);
13213 }
13214
13215 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
13216 {
13217         alc662_eeepc_ep20_automute(codec);
13218 }
13219
13220 #ifdef CONFIG_SND_HDA_POWER_SAVE
13221 #define alc662_loopbacks        alc880_loopbacks
13222 #endif
13223
13224
13225 /* pcm configuration: identiacal with ALC880 */
13226 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
13227 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
13228 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
13229 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
13230
13231 /*
13232  * configuration and preset
13233  */
13234 static const char *alc662_models[ALC662_MODEL_LAST] = {
13235         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
13236         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
13237         [ALC662_3ST_6ch]        = "3stack-6ch",
13238         [ALC662_5ST_DIG]        = "6stack-dig",
13239         [ALC662_LENOVO_101E]    = "lenovo-101e",
13240         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
13241         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
13242         [ALC662_AUTO]           = "auto",
13243 };
13244
13245 static struct snd_pci_quirk alc662_cfg_tbl[] = {
13246         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
13247         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
13248         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
13249         {}
13250 };
13251
13252 static struct alc_config_preset alc662_presets[] = {
13253         [ALC662_3ST_2ch_DIG] = {
13254                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
13255                 .init_verbs = { alc662_init_verbs },
13256                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13257                 .dac_nids = alc662_dac_nids,
13258                 .dig_out_nid = ALC662_DIGOUT_NID,
13259                 .dig_in_nid = ALC662_DIGIN_NID,
13260                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
13261                 .channel_mode = alc662_3ST_2ch_modes,
13262                 .input_mux = &alc662_capture_source,
13263         },
13264         [ALC662_3ST_6ch_DIG] = {
13265                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
13266                             alc662_capture_mixer },
13267                 .init_verbs = { alc662_init_verbs },
13268                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13269                 .dac_nids = alc662_dac_nids,
13270                 .dig_out_nid = ALC662_DIGOUT_NID,
13271                 .dig_in_nid = ALC662_DIGIN_NID,
13272                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
13273                 .channel_mode = alc662_3ST_6ch_modes,
13274                 .need_dac_fix = 1,
13275                 .input_mux = &alc662_capture_source,
13276         },
13277         [ALC662_3ST_6ch] = {
13278                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
13279                             alc662_capture_mixer },
13280                 .init_verbs = { alc662_init_verbs },
13281                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13282                 .dac_nids = alc662_dac_nids,
13283                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
13284                 .channel_mode = alc662_3ST_6ch_modes,
13285                 .need_dac_fix = 1,
13286                 .input_mux = &alc662_capture_source,
13287         },
13288         [ALC662_5ST_DIG] = {
13289                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
13290                             alc662_capture_mixer },
13291                 .init_verbs = { alc662_init_verbs },
13292                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13293                 .dac_nids = alc662_dac_nids,
13294                 .dig_out_nid = ALC662_DIGOUT_NID,
13295                 .dig_in_nid = ALC662_DIGIN_NID,
13296                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
13297                 .channel_mode = alc662_5stack_modes,
13298                 .input_mux = &alc662_capture_source,
13299         },
13300         [ALC662_LENOVO_101E] = {
13301                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
13302                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
13303                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13304                 .dac_nids = alc662_dac_nids,
13305                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
13306                 .channel_mode = alc662_3ST_2ch_modes,
13307                 .input_mux = &alc662_lenovo_101e_capture_source,
13308                 .unsol_event = alc662_lenovo_101e_unsol_event,
13309                 .init_hook = alc662_lenovo_101e_all_automute,
13310         },
13311         [ALC662_ASUS_EEEPC_P701] = {
13312                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
13313                 .init_verbs = { alc662_init_verbs,
13314                                 alc662_eeepc_sue_init_verbs },
13315                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13316                 .dac_nids = alc662_dac_nids,
13317                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
13318                 .channel_mode = alc662_3ST_2ch_modes,
13319                 .input_mux = &alc662_eeepc_capture_source,
13320                 .unsol_event = alc662_eeepc_unsol_event,
13321                 .init_hook = alc662_eeepc_inithook,
13322         },
13323         [ALC662_ASUS_EEEPC_EP20] = {
13324                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
13325                             alc662_chmode_mixer },
13326                 .init_verbs = { alc662_init_verbs,
13327                                 alc662_eeepc_ep20_sue_init_verbs },
13328                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
13329                 .dac_nids = alc662_dac_nids,
13330                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
13331                 .channel_mode = alc662_3ST_6ch_modes,
13332                 .input_mux = &alc662_lenovo_101e_capture_source,
13333                 .unsol_event = alc662_eeepc_ep20_unsol_event,
13334                 .init_hook = alc662_eeepc_ep20_inithook,
13335         },
13336
13337 };
13338
13339
13340 /*
13341  * BIOS auto configuration
13342  */
13343
13344 /* add playback controls from the parsed DAC table */
13345 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
13346                                              const struct auto_pin_cfg *cfg)
13347 {
13348         char name[32];
13349         static const char *chname[4] = {
13350                 "Front", "Surround", NULL /*CLFE*/, "Side"
13351         };
13352         hda_nid_t nid;
13353         int i, err;
13354
13355         for (i = 0; i < cfg->line_outs; i++) {
13356                 if (!spec->multiout.dac_nids[i])
13357                         continue;
13358                 nid = alc880_idx_to_dac(i);
13359                 if (i == 2) {
13360                         /* Center/LFE */
13361                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13362                                           "Center Playback Volume",
13363                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13364                                                               HDA_OUTPUT));
13365                         if (err < 0)
13366                                 return err;
13367                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13368                                           "LFE Playback Volume",
13369                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13370                                                               HDA_OUTPUT));
13371                         if (err < 0)
13372                                 return err;
13373                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13374                                           "Center Playback Switch",
13375                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
13376                                                               HDA_INPUT));
13377                         if (err < 0)
13378                                 return err;
13379                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13380                                           "LFE Playback Switch",
13381                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
13382                                                               HDA_INPUT));
13383                         if (err < 0)
13384                                 return err;
13385                 } else {
13386                         sprintf(name, "%s Playback Volume", chname[i]);
13387                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13388                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13389                                                               HDA_OUTPUT));
13390                         if (err < 0)
13391                                 return err;
13392                         sprintf(name, "%s Playback Switch", chname[i]);
13393                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13394                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
13395                                                               HDA_INPUT));
13396                         if (err < 0)
13397                                 return err;
13398                 }
13399         }
13400         return 0;
13401 }
13402
13403 /* add playback controls for speaker and HP outputs */
13404 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
13405                                         const char *pfx)
13406 {
13407         hda_nid_t nid;
13408         int err;
13409         char name[32];
13410
13411         if (!pin)
13412                 return 0;
13413
13414         if (alc880_is_fixed_pin(pin)) {
13415                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
13416                 /* printk("DAC nid=%x\n",nid); */
13417                 /* specify the DAC as the extra output */
13418                 if (!spec->multiout.hp_nid)
13419                         spec->multiout.hp_nid = nid;
13420                 else
13421                         spec->multiout.extra_out_nid[0] = nid;
13422                 /* control HP volume/switch on the output mixer amp */
13423                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
13424                 sprintf(name, "%s Playback Volume", pfx);
13425                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
13426                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13427                 if (err < 0)
13428                         return err;
13429                 sprintf(name, "%s Playback Switch", pfx);
13430                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13431                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
13432                 if (err < 0)
13433                         return err;
13434         } else if (alc880_is_multi_pin(pin)) {
13435                 /* set manual connection */
13436                 /* we have only a switch on HP-out PIN */
13437                 sprintf(name, "%s Playback Switch", pfx);
13438                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
13439                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
13440                 if (err < 0)
13441                         return err;
13442         }
13443         return 0;
13444 }
13445
13446 /* create playback/capture controls for input pins */
13447 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
13448                                                 const struct auto_pin_cfg *cfg)
13449 {
13450         struct hda_input_mux *imux = &spec->private_imux;
13451         int i, err, idx;
13452
13453         for (i = 0; i < AUTO_PIN_LAST; i++) {
13454                 if (alc880_is_input_pin(cfg->input_pins[i])) {
13455                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
13456                         err = new_analog_input(spec, cfg->input_pins[i],
13457                                                auto_pin_cfg_labels[i],
13458                                                idx, 0x0b);
13459                         if (err < 0)
13460                                 return err;
13461                         imux->items[imux->num_items].label =
13462                                 auto_pin_cfg_labels[i];
13463                         imux->items[imux->num_items].index =
13464                                 alc880_input_pin_idx(cfg->input_pins[i]);
13465                         imux->num_items++;
13466                 }
13467         }
13468         return 0;
13469 }
13470
13471 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
13472                                               hda_nid_t nid, int pin_type,
13473                                               int dac_idx)
13474 {
13475         alc_set_pin_output(codec, nid, pin_type);
13476         /* need the manual connection? */
13477         if (alc880_is_multi_pin(nid)) {
13478                 struct alc_spec *spec = codec->spec;
13479                 int idx = alc880_multi_pin_idx(nid);
13480                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
13481                                     AC_VERB_SET_CONNECT_SEL,
13482                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
13483         }
13484 }
13485
13486 static void alc662_auto_init_multi_out(struct hda_codec *codec)
13487 {
13488         struct alc_spec *spec = codec->spec;
13489         int i;
13490
13491         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
13492         for (i = 0; i <= HDA_SIDE; i++) {
13493                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13494                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13495                 if (nid)
13496                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
13497                                                           i);
13498         }
13499 }
13500
13501 static void alc662_auto_init_hp_out(struct hda_codec *codec)
13502 {
13503         struct alc_spec *spec = codec->spec;
13504         hda_nid_t pin;
13505
13506         pin = spec->autocfg.hp_pins[0];
13507         if (pin) /* connect to front */
13508                 /* use dac 0 */
13509                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
13510         pin = spec->autocfg.speaker_pins[0];
13511         if (pin)
13512                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13513 }
13514
13515 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
13516 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
13517
13518 static void alc662_auto_init_analog_input(struct hda_codec *codec)
13519 {
13520         struct alc_spec *spec = codec->spec;
13521         int i;
13522
13523         for (i = 0; i < AUTO_PIN_LAST; i++) {
13524                 hda_nid_t nid = spec->autocfg.input_pins[i];
13525                 if (alc662_is_input_pin(nid)) {
13526                         snd_hda_codec_write(codec, nid, 0,
13527                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
13528                                             (i <= AUTO_PIN_FRONT_MIC ?
13529                                              PIN_VREF80 : PIN_IN));
13530                         if (nid != ALC662_PIN_CD_NID)
13531                                 snd_hda_codec_write(codec, nid, 0,
13532                                                     AC_VERB_SET_AMP_GAIN_MUTE,
13533                                                     AMP_OUT_MUTE);
13534                 }
13535         }
13536 }
13537
13538 static int alc662_parse_auto_config(struct hda_codec *codec)
13539 {
13540         struct alc_spec *spec = codec->spec;
13541         int err;
13542         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
13543
13544         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13545                                            alc662_ignore);
13546         if (err < 0)
13547                 return err;
13548         if (!spec->autocfg.line_outs)
13549                 return 0; /* can't find valid BIOS pin config */
13550
13551         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
13552         if (err < 0)
13553                 return err;
13554         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
13555         if (err < 0)
13556                 return err;
13557         err = alc662_auto_create_extra_out(spec,
13558                                            spec->autocfg.speaker_pins[0],
13559                                            "Speaker");
13560         if (err < 0)
13561                 return err;
13562         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
13563                                            "Headphone");
13564         if (err < 0)
13565                 return err;
13566         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
13567         if (err < 0)
13568                 return err;
13569
13570         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13571
13572         if (spec->autocfg.dig_out_pin)
13573                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
13574
13575         if (spec->kctl_alloc)
13576                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13577
13578         spec->num_mux_defs = 1;
13579         spec->input_mux = &spec->private_imux;
13580
13581         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
13582         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
13583         spec->num_mixers++;
13584         return 1;
13585 }
13586
13587 /* additional initialization for auto-configuration model */
13588 static void alc662_auto_init(struct hda_codec *codec)
13589 {
13590         struct alc_spec *spec = codec->spec;
13591         alc662_auto_init_multi_out(codec);
13592         alc662_auto_init_hp_out(codec);
13593         alc662_auto_init_analog_input(codec);
13594         if (spec->unsol_event)
13595                 alc_sku_automute(codec);
13596 }
13597
13598 static int patch_alc662(struct hda_codec *codec)
13599 {
13600         struct alc_spec *spec;
13601         int err, board_config;
13602
13603         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13604         if (!spec)
13605                 return -ENOMEM;
13606
13607         codec->spec = spec;
13608
13609         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
13610                                                   alc662_models,
13611                                                   alc662_cfg_tbl);
13612         if (board_config < 0) {
13613                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
13614                        "trying auto-probe from BIOS...\n");
13615                 board_config = ALC662_AUTO;
13616         }
13617
13618         if (board_config == ALC662_AUTO) {
13619                 /* automatic parse from the BIOS config */
13620                 err = alc662_parse_auto_config(codec);
13621                 if (err < 0) {
13622                         alc_free(codec);
13623                         return err;
13624                 } else if (!err) {
13625                         printk(KERN_INFO
13626                                "hda_codec: Cannot set up configuration "
13627                                "from BIOS.  Using base mode...\n");
13628                         board_config = ALC662_3ST_2ch_DIG;
13629                 }
13630         }
13631
13632         if (board_config != ALC662_AUTO)
13633                 setup_preset(spec, &alc662_presets[board_config]);
13634
13635         spec->stream_name_analog = "ALC662 Analog";
13636         spec->stream_analog_playback = &alc662_pcm_analog_playback;
13637         spec->stream_analog_capture = &alc662_pcm_analog_capture;
13638
13639         spec->stream_name_digital = "ALC662 Digital";
13640         spec->stream_digital_playback = &alc662_pcm_digital_playback;
13641         spec->stream_digital_capture = &alc662_pcm_digital_capture;
13642
13643         spec->adc_nids = alc662_adc_nids;
13644         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
13645         spec->capsrc_nids = alc662_capsrc_nids;
13646
13647         spec->vmaster_nid = 0x02;
13648
13649         codec->patch_ops = alc_patch_ops;
13650         if (board_config == ALC662_AUTO)
13651                 spec->init_hook = alc662_auto_init;
13652 #ifdef CONFIG_SND_HDA_POWER_SAVE
13653         if (!spec->loopback.amplist)
13654                 spec->loopback.amplist = alc662_loopbacks;
13655 #endif
13656
13657         return 0;
13658 }
13659
13660 /*
13661  * patch entries
13662  */
13663 struct hda_codec_preset snd_hda_preset_realtek[] = {
13664         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
13665         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
13666         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
13667         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
13668         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
13669         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
13670           .patch = patch_alc861 },
13671         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
13672         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
13673         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
13674         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
13675           .patch = patch_alc883 },
13676         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
13677           .patch = patch_alc662 },
13678         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
13679         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
13680         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
13681         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
13682         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
13683         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
13684         {} /* terminator */
13685 };