sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_patch.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81 #ifdef CONFIG_SND_DEBUG
  82         ALC260_TEST,
  83 #endif
  84         ALC260_AUTO,
  85         ALC260_MODEL_LAST /* last tag */
  86 };
  87
  88 /* ALC262 models */
  89 enum {
  90         ALC262_BASIC,
  91         ALC262_HIPPO,
  92         ALC262_HIPPO_1,
  93         ALC262_FUJITSU,
  94         ALC262_HP_BPC,
  95         ALC262_HP_BPC_D7000_WL,
  96         ALC262_HP_BPC_D7000_WF,
  97         ALC262_HP_TC_T5735,
  98         ALC262_HP_RP5700,
  99         ALC262_BENQ_ED8,
 100         ALC262_SONY_ASSAMD,
 101         ALC262_BENQ_T31,
 102         ALC262_ULTRA,
 103         ALC262_LENOVO_3000,
 104         ALC262_NEC,
 105         ALC262_TOSHIBA_S06,
 106         ALC262_TOSHIBA_RX1,
 107         ALC262_AUTO,
 108         ALC262_MODEL_LAST /* last tag */
 109 };
 110
 111 /* ALC268 models */
 112 enum {
 113         ALC267_QUANTA_IL1,
 114         ALC268_3ST,
 115         ALC268_TOSHIBA,
 116         ALC268_ACER,
 117         ALC268_ACER_ASPIRE_ONE,
 118         ALC268_DELL,
 119         ALC268_ZEPTO,
 120 #ifdef CONFIG_SND_DEBUG
 121         ALC268_TEST,
 122 #endif
 123         ALC268_AUTO,
 124         ALC268_MODEL_LAST /* last tag */
 125 };
 126
 127 /* ALC269 models */
 128 enum {
 129         ALC269_BASIC,
 130         ALC269_QUANTA_FL1,
 131         ALC269_ASUS_EEEPC_P703,
 132         ALC269_ASUS_EEEPC_P901,
 133         ALC269_AUTO,
 134         ALC269_MODEL_LAST /* last tag */
 135 };
 136
 137 /* ALC861 models */
 138 enum {
 139         ALC861_3ST,
 140         ALC660_3ST,
 141         ALC861_3ST_DIG,
 142         ALC861_6ST_DIG,
 143         ALC861_UNIWILL_M31,
 144         ALC861_TOSHIBA,
 145         ALC861_ASUS,
 146         ALC861_ASUS_LAPTOP,
 147         ALC861_AUTO,
 148         ALC861_MODEL_LAST,
 149 };
 150
 151 /* ALC861-VD models */
 152 enum {
 153         ALC660VD_3ST,
 154         ALC660VD_3ST_DIG,
 155         ALC861VD_3ST,
 156         ALC861VD_3ST_DIG,
 157         ALC861VD_6ST_DIG,
 158         ALC861VD_LENOVO,
 159         ALC861VD_DALLAS,
 160         ALC861VD_HP,
 161         ALC861VD_AUTO,
 162         ALC861VD_MODEL_LAST,
 163 };
 164
 165 /* ALC662 models */
 166 enum {
 167         ALC662_3ST_2ch_DIG,
 168         ALC662_3ST_6ch_DIG,
 169         ALC662_3ST_6ch,
 170         ALC662_5ST_DIG,
 171         ALC662_LENOVO_101E,
 172         ALC662_ASUS_EEEPC_P701,
 173         ALC662_ASUS_EEEPC_EP20,
 174         ALC663_ASUS_M51VA,
 175         ALC663_ASUS_G71V,
 176         ALC663_ASUS_H13,
 177         ALC663_ASUS_G50V,
 178         ALC662_ECS,
 179         ALC663_ASUS_MODE1,
 180         ALC662_ASUS_MODE2,
 181         ALC663_ASUS_MODE3,
 182         ALC663_ASUS_MODE4,
 183         ALC663_ASUS_MODE5,
 184         ALC663_ASUS_MODE6,
 185         ALC662_AUTO,
 186         ALC662_MODEL_LAST,
 187 };
 188
 189 /* ALC882 models */
 190 enum {
 191         ALC882_3ST_DIG,
 192         ALC882_6ST_DIG,
 193         ALC882_ARIMA,
 194         ALC882_W2JC,
 195         ALC882_TARGA,
 196         ALC882_ASUS_A7J,
 197         ALC882_ASUS_A7M,
 198         ALC885_MACPRO,
 199         ALC885_MBP3,
 200         ALC885_IMAC24,
 201         ALC882_AUTO,
 202         ALC882_MODEL_LAST,
 203 };
 204
 205 /* ALC883 models */
 206 enum {
 207         ALC883_3ST_2ch_DIG,
 208         ALC883_3ST_6ch_DIG,
 209         ALC883_3ST_6ch,
 210         ALC883_6ST_DIG,
 211         ALC883_TARGA_DIG,
 212         ALC883_TARGA_2ch_DIG,
 213         ALC883_ACER,
 214         ALC883_ACER_ASPIRE,
 215         ALC883_MEDION,
 216         ALC883_MEDION_MD2,
 217         ALC883_LAPTOP_EAPD,
 218         ALC883_LENOVO_101E_2ch,
 219         ALC883_LENOVO_NB0763,
 220         ALC888_LENOVO_MS7195_DIG,
 221         ALC888_LENOVO_SKY,
 222         ALC883_HAIER_W66,
 223         ALC888_3ST_HP,
 224         ALC888_6ST_DELL,
 225         ALC883_MITAC,
 226         ALC883_CLEVO_M720,
 227         ALC883_FUJITSU_PI2515,
 228         ALC883_3ST_6ch_INTEL,
 229         ALC888_ASUS_M90V,
 230         ALC888_ASUS_EEE1601,
 231         ALC883_AUTO,
 232         ALC883_MODEL_LAST,
 233 };
 234
 235 /* for GPIO Poll */
 236 #define GPIO_MASK       0x03
 237
 238 struct alc_spec {
 239         /* codec parameterization */
 240         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 241         unsigned int num_mixers;
 242
 243         const struct hda_verb *init_verbs[5];   /* initialization verbs
 244                                                  * don't forget NULL
 245                                                  * termination!
 246                                                  */
 247         unsigned int num_init_verbs;
 248
 249         char *stream_name_analog;       /* analog PCM stream */
 250         struct hda_pcm_stream *stream_analog_playback;
 251         struct hda_pcm_stream *stream_analog_capture;
 252         struct hda_pcm_stream *stream_analog_alt_playback;
 253         struct hda_pcm_stream *stream_analog_alt_capture;
 254
 255         char *stream_name_digital;      /* digital PCM stream */
 256         struct hda_pcm_stream *stream_digital_playback;
 257         struct hda_pcm_stream *stream_digital_capture;
 258
 259         /* playback */
 260         struct hda_multi_out multiout;  /* playback set-up
 261                                          * max_channels, dacs must be set
 262                                          * dig_out_nid and hp_nid are optional
 263                                          */
 264         hda_nid_t alt_dac_nid;
 265
 266         /* capture */
 267         unsigned int num_adc_nids;
 268         hda_nid_t *adc_nids;
 269         hda_nid_t *capsrc_nids;
 270         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 271
 272         /* capture source */
 273         unsigned int num_mux_defs;
 274         const struct hda_input_mux *input_mux;
 275         unsigned int cur_mux[3];
 276
 277         /* channel model */
 278         const struct hda_channel_mode *channel_mode;
 279         int num_channel_mode;
 280         int need_dac_fix;
 281
 282         /* PCM information */
 283         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 284
 285         /* dynamic controls, init_verbs and input_mux */
 286         struct auto_pin_cfg autocfg;
 287         unsigned int num_kctl_alloc, num_kctl_used;
 288         struct snd_kcontrol_new *kctl_alloc;
 289         struct hda_input_mux private_imux;
 290         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 291
 292         /* hooks */
 293         void (*init_hook)(struct hda_codec *codec);
 294         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 295
 296         /* for pin sensing */
 297         unsigned int sense_updated: 1;
 298         unsigned int jack_present: 1;
 299         unsigned int master_sw: 1;
 300
 301         /* for virtual master */
 302         hda_nid_t vmaster_nid;
 303 #ifdef CONFIG_SND_HDA_POWER_SAVE
 304         struct hda_loopback_check loopback;
 305 #endif
 306
 307         /* for PLL fix */
 308         hda_nid_t pll_nid;
 309         unsigned int pll_coef_idx, pll_coef_bit;
 310 };
 311
 312 /*
 313  * configuration template - to be copied to the spec instance
 314  */
 315 struct alc_config_preset {
 316         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 317                                              * with spec
 318                                              */
 319         const struct hda_verb *init_verbs[5];
 320         unsigned int num_dacs;
 321         hda_nid_t *dac_nids;
 322         hda_nid_t dig_out_nid;          /* optional */
 323         hda_nid_t hp_nid;               /* optional */
 324         unsigned int num_adc_nids;
 325         hda_nid_t *adc_nids;
 326         hda_nid_t *capsrc_nids;
 327         hda_nid_t dig_in_nid;
 328         unsigned int num_channel_mode;
 329         const struct hda_channel_mode *channel_mode;
 330         int need_dac_fix;
 331         unsigned int num_mux_defs;
 332         const struct hda_input_mux *input_mux;
 333         void (*unsol_event)(struct hda_codec *, unsigned int);
 334         void (*init_hook)(struct hda_codec *);
 335 #ifdef CONFIG_SND_HDA_POWER_SAVE
 336         struct hda_amp_list *loopbacks;
 337 #endif
 338 };
 339
 340
 341 /*
 342  * input MUX handling
 343  */
 344 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 345                              struct snd_ctl_elem_info *uinfo)
 346 {
 347         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 348         struct alc_spec *spec = codec->spec;
 349         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 350         if (mux_idx >= spec->num_mux_defs)
 351                 mux_idx = 0;
 352         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 353 }
 354
 355 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 356                             struct snd_ctl_elem_value *ucontrol)
 357 {
 358         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 359         struct alc_spec *spec = codec->spec;
 360         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 361
 362         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 363         return 0;
 364 }
 365
 366 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 367                             struct snd_ctl_elem_value *ucontrol)
 368 {
 369         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 370         struct alc_spec *spec = codec->spec;
 371         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 372         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 373         hda_nid_t nid = spec->capsrc_nids ?
 374                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 375         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
 376                                      nid, &spec->cur_mux[adc_idx]);
 377 }
 378
 379
 380 /*
 381  * channel mode setting
 382  */
 383 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 384                             struct snd_ctl_elem_info *uinfo)
 385 {
 386         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 387         struct alc_spec *spec = codec->spec;
 388         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 389                                     spec->num_channel_mode);
 390 }
 391
 392 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 393                            struct snd_ctl_elem_value *ucontrol)
 394 {
 395         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 396         struct alc_spec *spec = codec->spec;
 397         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 398                                    spec->num_channel_mode,
 399                                    spec->multiout.max_channels);
 400 }
 401
 402 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 403                            struct snd_ctl_elem_value *ucontrol)
 404 {
 405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 406         struct alc_spec *spec = codec->spec;
 407         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 408                                       spec->num_channel_mode,
 409                                       &spec->multiout.max_channels);
 410         if (err >= 0 && spec->need_dac_fix)
 411                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 412         return err;
 413 }
 414
 415 /*
 416  * Control the mode of pin widget settings via the mixer.  "pc" is used
 417  * instead of "%" to avoid consequences of accidently treating the % as
 418  * being part of a format specifier.  Maximum allowed length of a value is
 419  * 63 characters plus NULL terminator.
 420  *
 421  * Note: some retasking pin complexes seem to ignore requests for input
 422  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 423  * are requested.  Therefore order this list so that this behaviour will not
 424  * cause problems when mixer clients move through the enum sequentially.
 425  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 426  * March 2006.
 427  */
 428 static char *alc_pin_mode_names[] = {
 429         "Mic 50pc bias", "Mic 80pc bias",
 430         "Line in", "Line out", "Headphone out",
 431 };
 432 static unsigned char alc_pin_mode_values[] = {
 433         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 434 };
 435 /* The control can present all 5 options, or it can limit the options based
 436  * in the pin being assumed to be exclusively an input or an output pin.  In
 437  * addition, "input" pins may or may not process the mic bias option
 438  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 439  * accept requests for bias as of chip versions up to March 2006) and/or
 440  * wiring in the computer.
 441  */
 442 #define ALC_PIN_DIR_IN              0x00
 443 #define ALC_PIN_DIR_OUT             0x01
 444 #define ALC_PIN_DIR_INOUT           0x02
 445 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 446 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 447
 448 /* Info about the pin modes supported by the different pin direction modes.
 449  * For each direction the minimum and maximum values are given.
 450  */
 451 static signed char alc_pin_mode_dir_info[5][2] = {
 452         { 0, 2 },    /* ALC_PIN_DIR_IN */
 453         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 454         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 455         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 456         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 457 };
 458 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 459 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 460 #define alc_pin_mode_n_items(_dir) \
 461         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 462
 463 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 464                              struct snd_ctl_elem_info *uinfo)
 465 {
 466         unsigned int item_num = uinfo->value.enumerated.item;
 467         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 468
 469         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 470         uinfo->count = 1;
 471         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 472
 473         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 474                 item_num = alc_pin_mode_min(dir);
 475         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 476         return 0;
 477 }
 478
 479 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 480                             struct snd_ctl_elem_value *ucontrol)
 481 {
 482         unsigned int i;
 483         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 484         hda_nid_t nid = kcontrol->private_value & 0xffff;
 485         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 486         long *valp = ucontrol->value.integer.value;
 487         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 488                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 489                                                  0x00);
 490
 491         /* Find enumerated value for current pinctl setting */
 492         i = alc_pin_mode_min(dir);
 493         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 494                 i++;
 495         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 496         return 0;
 497 }
 498
 499 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 500                             struct snd_ctl_elem_value *ucontrol)
 501 {
 502         signed int change;
 503         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 504         hda_nid_t nid = kcontrol->private_value & 0xffff;
 505         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 506         long val = *ucontrol->value.integer.value;
 507         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 508                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 509                                                  0x00);
 510
 511         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 512                 val = alc_pin_mode_min(dir);
 513
 514         change = pinctl != alc_pin_mode_values[val];
 515         if (change) {
 516                 /* Set pin mode to that requested */
 517                 snd_hda_codec_write_cache(codec, nid, 0,
 518                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 519                                           alc_pin_mode_values[val]);
 520
 521                 /* Also enable the retasking pin's input/output as required
 522                  * for the requested pin mode.  Enum values of 2 or less are
 523                  * input modes.
 524                  *
 525                  * Dynamically switching the input/output buffers probably
 526                  * reduces noise slightly (particularly on input) so we'll
 527                  * do it.  However, having both input and output buffers
 528                  * enabled simultaneously doesn't seem to be problematic if
 529                  * this turns out to be necessary in the future.
 530                  */
 531                 if (val <= 2) {
 532                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 533                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 534                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 535                                                  HDA_AMP_MUTE, 0);
 536                 } else {
 537                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 538                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 539                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 540                                                  HDA_AMP_MUTE, 0);
 541                 }
 542         }
 543         return change;
 544 }
 545
 546 #define ALC_PIN_MODE(xname, nid, dir) \
 547         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 548           .info = alc_pin_mode_info, \
 549           .get = alc_pin_mode_get, \
 550           .put = alc_pin_mode_put, \
 551           .private_value = nid | (dir<<16) }
 552
 553 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 554  * together using a mask with more than one bit set.  This control is
 555  * currently used only by the ALC260 test model.  At this stage they are not
 556  * needed for any "production" models.
 557  */
 558 #ifdef CONFIG_SND_DEBUG
 559 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 560
 561 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 562                              struct snd_ctl_elem_value *ucontrol)
 563 {
 564         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 565         hda_nid_t nid = kcontrol->private_value & 0xffff;
 566         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 567         long *valp = ucontrol->value.integer.value;
 568         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 569                                               AC_VERB_GET_GPIO_DATA, 0x00);
 570
 571         *valp = (val & mask) != 0;
 572         return 0;
 573 }
 574 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 575                              struct snd_ctl_elem_value *ucontrol)
 576 {
 577         signed int change;
 578         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 579         hda_nid_t nid = kcontrol->private_value & 0xffff;
 580         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 581         long val = *ucontrol->value.integer.value;
 582         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 583                                                     AC_VERB_GET_GPIO_DATA,
 584                                                     0x00);
 585
 586         /* Set/unset the masked GPIO bit(s) as needed */
 587         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 588         if (val == 0)
 589                 gpio_data &= ~mask;
 590         else
 591                 gpio_data |= mask;
 592         snd_hda_codec_write_cache(codec, nid, 0,
 593                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 594
 595         return change;
 596 }
 597 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 598         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 599           .info = alc_gpio_data_info, \
 600           .get = alc_gpio_data_get, \
 601           .put = alc_gpio_data_put, \
 602           .private_value = nid | (mask<<16) }
 603 #endif   /* CONFIG_SND_DEBUG */
 604
 605 /* A switch control to allow the enabling of the digital IO pins on the
 606  * ALC260.  This is incredibly simplistic; the intention of this control is
 607  * to provide something in the test model allowing digital outputs to be
 608  * identified if present.  If models are found which can utilise these
 609  * outputs a more complete mixer control can be devised for those models if
 610  * necessary.
 611  */
 612 #ifdef CONFIG_SND_DEBUG
 613 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 614
 615 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 616                               struct snd_ctl_elem_value *ucontrol)
 617 {
 618         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 619         hda_nid_t nid = kcontrol->private_value & 0xffff;
 620         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 621         long *valp = ucontrol->value.integer.value;
 622         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 623                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 624
 625         *valp = (val & mask) != 0;
 626         return 0;
 627 }
 628 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 629                               struct snd_ctl_elem_value *ucontrol)
 630 {
 631         signed int change;
 632         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 633         hda_nid_t nid = kcontrol->private_value & 0xffff;
 634         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 635         long val = *ucontrol->value.integer.value;
 636         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 637                                                     AC_VERB_GET_DIGI_CONVERT_1,
 638                                                     0x00);
 639
 640         /* Set/unset the masked control bit(s) as needed */
 641         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 642         if (val==0)
 643                 ctrl_data &= ~mask;
 644         else
 645                 ctrl_data |= mask;
 646         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 647                                   ctrl_data);
 648
 649         return change;
 650 }
 651 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 652         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 653           .info = alc_spdif_ctrl_info, \
 654           .get = alc_spdif_ctrl_get, \
 655           .put = alc_spdif_ctrl_put, \
 656           .private_value = nid | (mask<<16) }
 657 #endif   /* CONFIG_SND_DEBUG */
 658
 659 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 660  * Again, this is only used in the ALC26x test models to help identify when
 661  * the EAPD line must be asserted for features to work.
 662  */
 663 #ifdef CONFIG_SND_DEBUG
 664 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 665
 666 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 667                               struct snd_ctl_elem_value *ucontrol)
 668 {
 669         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 670         hda_nid_t nid = kcontrol->private_value & 0xffff;
 671         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 672         long *valp = ucontrol->value.integer.value;
 673         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 674                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 675
 676         *valp = (val & mask) != 0;
 677         return 0;
 678 }
 679
 680 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 681                               struct snd_ctl_elem_value *ucontrol)
 682 {
 683         int change;
 684         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 685         hda_nid_t nid = kcontrol->private_value & 0xffff;
 686         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 687         long val = *ucontrol->value.integer.value;
 688         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 689                                                     AC_VERB_GET_EAPD_BTLENABLE,
 690                                                     0x00);
 691
 692         /* Set/unset the masked control bit(s) as needed */
 693         change = (!val ? 0 : mask) != (ctrl_data & mask);
 694         if (!val)
 695                 ctrl_data &= ~mask;
 696         else
 697                 ctrl_data |= mask;
 698         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 699                                   ctrl_data);
 700
 701         return change;
 702 }
 703
 704 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 705         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 706           .info = alc_eapd_ctrl_info, \
 707           .get = alc_eapd_ctrl_get, \
 708           .put = alc_eapd_ctrl_put, \
 709           .private_value = nid | (mask<<16) }
 710 #endif   /* CONFIG_SND_DEBUG */
 711
 712 /*
 713  * set up from the preset table
 714  */
 715 static void setup_preset(struct alc_spec *spec,
 716                          const struct alc_config_preset *preset)
 717 {
 718         int i;
 719
 720         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 721                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
 722         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 723              i++)
 724                 spec->init_verbs[spec->num_init_verbs++] =
 725                         preset->init_verbs[i];
 726
 727         spec->channel_mode = preset->channel_mode;
 728         spec->num_channel_mode = preset->num_channel_mode;
 729         spec->need_dac_fix = preset->need_dac_fix;
 730
 731         spec->multiout.max_channels = spec->channel_mode[0].channels;
 732
 733         spec->multiout.num_dacs = preset->num_dacs;
 734         spec->multiout.dac_nids = preset->dac_nids;
 735         spec->multiout.dig_out_nid = preset->dig_out_nid;
 736         spec->multiout.hp_nid = preset->hp_nid;
 737
 738         spec->num_mux_defs = preset->num_mux_defs;
 739         if (!spec->num_mux_defs)
 740                 spec->num_mux_defs = 1;
 741         spec->input_mux = preset->input_mux;
 742
 743         spec->num_adc_nids = preset->num_adc_nids;
 744         spec->adc_nids = preset->adc_nids;
 745         spec->capsrc_nids = preset->capsrc_nids;
 746         spec->dig_in_nid = preset->dig_in_nid;
 747
 748         spec->unsol_event = preset->unsol_event;
 749         spec->init_hook = preset->init_hook;
 750 #ifdef CONFIG_SND_HDA_POWER_SAVE
 751         spec->loopback.amplist = preset->loopbacks;
 752 #endif
 753 }
 754
 755 /* Enable GPIO mask and set output */
 756 static struct hda_verb alc_gpio1_init_verbs[] = {
 757         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 758         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 759         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 760         { }
 761 };
 762
 763 static struct hda_verb alc_gpio2_init_verbs[] = {
 764         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 765         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 766         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 767         { }
 768 };
 769
 770 static struct hda_verb alc_gpio3_init_verbs[] = {
 771         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 772         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 773         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 774         { }
 775 };
 776
 777 /*
 778  * Fix hardware PLL issue
 779  * On some codecs, the analog PLL gating control must be off while
 780  * the default value is 1.
 781  */
 782 static void alc_fix_pll(struct hda_codec *codec)
 783 {
 784         struct alc_spec *spec = codec->spec;
 785         unsigned int val;
 786
 787         if (!spec->pll_nid)
 788                 return;
 789         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 790                             spec->pll_coef_idx);
 791         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 792                                  AC_VERB_GET_PROC_COEF, 0);
 793         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 794                             spec->pll_coef_idx);
 795         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 796                             val & ~(1 << spec->pll_coef_bit));
 797 }
 798
 799 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 800                              unsigned int coef_idx, unsigned int coef_bit)
 801 {
 802         struct alc_spec *spec = codec->spec;
 803         spec->pll_nid = nid;
 804         spec->pll_coef_idx = coef_idx;
 805         spec->pll_coef_bit = coef_bit;
 806         alc_fix_pll(codec);
 807 }
 808
 809 static void alc_sku_automute(struct hda_codec *codec)
 810 {
 811         struct alc_spec *spec = codec->spec;
 812         unsigned int present;
 813         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 814         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 815
 816         /* need to execute and sync at first */
 817         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 818         present = snd_hda_codec_read(codec, hp_nid, 0,
 819                                      AC_VERB_GET_PIN_SENSE, 0);
 820         spec->jack_present = (present & 0x80000000) != 0;
 821         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 822                             spec->jack_present ? 0 : PIN_OUT);
 823 }
 824
 825 static void alc_mic_automute(struct hda_codec *codec)
 826 {
 827         struct alc_spec *spec = codec->spec;
 828         unsigned int present;
 829         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 830         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 831         unsigned int mix_nid = spec->capsrc_nids[0];
 832         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 833
 834         capsrc_idx_mic = mic_nid - 0x18;
 835         capsrc_idx_fmic = fmic_nid - 0x18;
 836         present = snd_hda_codec_read(codec, mic_nid, 0,
 837                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 838         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 839                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 840         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 841                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 842         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 843                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 844 }
 845
 846 /* unsolicited event for HP jack sensing */
 847 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 848 {
 849         if (codec->vendor_id == 0x10ec0880)
 850                 res >>= 28;
 851         else
 852                 res >>= 26;
 853         if (res == ALC880_HP_EVENT)
 854                 alc_sku_automute(codec);
 855
 856         if (res == ALC880_MIC_EVENT)
 857                 alc_mic_automute(codec);
 858 }
 859
 860 static void alc_inithook(struct hda_codec *codec)
 861 {
 862         alc_sku_automute(codec);
 863         alc_mic_automute(codec);
 864 }
 865
 866 /* additional initialization for ALC888 variants */
 867 static void alc888_coef_init(struct hda_codec *codec)
 868 {
 869         unsigned int tmp;
 870
 871         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 872         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 873         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 874         if ((tmp & 0xf0) == 2)
 875                 /* alc888S-VC */
 876                 snd_hda_codec_read(codec, 0x20, 0,
 877                                    AC_VERB_SET_PROC_COEF, 0x830);
 878          else
 879                  /* alc888-VB */
 880                  snd_hda_codec_read(codec, 0x20, 0,
 881                                     AC_VERB_SET_PROC_COEF, 0x3030);
 882 }
 883
 884 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 885  *      31 ~ 16 :       Manufacture ID
 886  *      15 ~ 8  :       SKU ID
 887  *      7  ~ 0  :       Assembly ID
 888  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 889  */
 890 static void alc_subsystem_id(struct hda_codec *codec,
 891                              unsigned int porta, unsigned int porte,
 892                              unsigned int portd)
 893 {
 894         unsigned int ass, tmp, i;
 895         unsigned nid;
 896         struct alc_spec *spec = codec->spec;
 897
 898         ass = codec->subsystem_id & 0xffff;
 899         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
 900                 goto do_sku;
 901
 902         /*
 903          * 31~30        : port conetcivity
 904          * 29~21        : reserve
 905          * 20           : PCBEEP input
 906          * 19~16        : Check sum (15:1)
 907          * 15~1         : Custom
 908          * 0            : override
 909         */
 910         nid = 0x1d;
 911         if (codec->vendor_id == 0x10ec0260)
 912                 nid = 0x17;
 913         ass = snd_hda_codec_read(codec, nid, 0,
 914                                  AC_VERB_GET_CONFIG_DEFAULT, 0);
 915         if (!(ass & 1) && !(ass & 0x100000))
 916                 return;
 917         if ((ass >> 30) != 1)   /* no physical connection */
 918                 return;
 919
 920         /* check sum */
 921         tmp = 0;
 922         for (i = 1; i < 16; i++) {
 923                 if ((ass >> i) & 1)
 924                         tmp++;
 925         }
 926         if (((ass >> 16) & 0xf) != tmp)
 927                 return;
 928 do_sku:
 929         /*
 930          * 0 : override
 931          * 1 :  Swap Jack
 932          * 2 : 0 --> Desktop, 1 --> Laptop
 933          * 3~5 : External Amplifier control
 934          * 7~6 : Reserved
 935         */
 936         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 937         switch (tmp) {
 938         case 1:
 939                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 940                 break;
 941         case 3:
 942                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 943                 break;
 944         case 7:
 945                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 946                 break;
 947         case 5: /* set EAPD output high */
 948                 switch (codec->vendor_id) {
 949                 case 0x10ec0260:
 950                         snd_hda_codec_write(codec, 0x0f, 0,
 951                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 952                         snd_hda_codec_write(codec, 0x10, 0,
 953                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 954                         break;
 955                 case 0x10ec0262:
 956                 case 0x10ec0267:
 957                 case 0x10ec0268:
 958                 case 0x10ec0269:
 959                 case 0x10ec0660:
 960                 case 0x10ec0662:
 961                 case 0x10ec0663:
 962                 case 0x10ec0862:
 963                 case 0x10ec0889:
 964                         snd_hda_codec_write(codec, 0x14, 0,
 965                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 966                         snd_hda_codec_write(codec, 0x15, 0,
 967                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 968                         break;
 969                 }
 970                 switch (codec->vendor_id) {
 971                 case 0x10ec0260:
 972                         snd_hda_codec_write(codec, 0x1a, 0,
 973                                             AC_VERB_SET_COEF_INDEX, 7);
 974                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 975                                                  AC_VERB_GET_PROC_COEF, 0);
 976                         snd_hda_codec_write(codec, 0x1a, 0,
 977                                             AC_VERB_SET_COEF_INDEX, 7);
 978                         snd_hda_codec_write(codec, 0x1a, 0,
 979                                             AC_VERB_SET_PROC_COEF,
 980                                             tmp | 0x2010);
 981                         break;
 982                 case 0x10ec0262:
 983                 case 0x10ec0880:
 984                 case 0x10ec0882:
 985                 case 0x10ec0883:
 986                 case 0x10ec0885:
 987                 case 0x10ec0889:
 988                         snd_hda_codec_write(codec, 0x20, 0,
 989                                             AC_VERB_SET_COEF_INDEX, 7);
 990                         tmp = snd_hda_codec_read(codec, 0x20, 0,
 991                                                  AC_VERB_GET_PROC_COEF, 0);
 992                         snd_hda_codec_write(codec, 0x20, 0,
 993                                             AC_VERB_SET_COEF_INDEX, 7);
 994                         snd_hda_codec_write(codec, 0x20, 0,
 995                                             AC_VERB_SET_PROC_COEF,
 996                                             tmp | 0x2010);
 997                         break;
 998                 case 0x10ec0888:
 999                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1000                         break;
1001                 case 0x10ec0267:
1002                 case 0x10ec0268:
1003                         snd_hda_codec_write(codec, 0x20, 0,
1004                                             AC_VERB_SET_COEF_INDEX, 7);
1005                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1006                                                  AC_VERB_GET_PROC_COEF, 0);
1007                         snd_hda_codec_write(codec, 0x20, 0,
1008                                             AC_VERB_SET_COEF_INDEX, 7);
1009                         snd_hda_codec_write(codec, 0x20, 0,
1010                                             AC_VERB_SET_PROC_COEF,
1011                                             tmp | 0x3000);
1012                         break;
1013                 }
1014         default:
1015                 break;
1016         }
1017
1018         /* is laptop or Desktop and enable the function "Mute internal speaker
1019          * when the external headphone out jack is plugged"
1020          */
1021         if (!(ass & 0x8000))
1022                 return;
1023         /*
1024          * 10~8 : Jack location
1025          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1026          * 14~13: Resvered
1027          * 15   : 1 --> enable the function "Mute internal speaker
1028          *              when the external headphone out jack is plugged"
1029          */
1030         if (!spec->autocfg.speaker_pins[0]) {
1031                 if (spec->autocfg.line_out_pins[0])
1032                         spec->autocfg.speaker_pins[0] =
1033                                 spec->autocfg.line_out_pins[0];
1034                 else
1035                         return;
1036         }
1037
1038         if (!spec->autocfg.hp_pins[0]) {
1039                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1040                 if (tmp == 0)
1041                         spec->autocfg.hp_pins[0] = porta;
1042                 else if (tmp == 1)
1043                         spec->autocfg.hp_pins[0] = porte;
1044                 else if (tmp == 2)
1045                         spec->autocfg.hp_pins[0] = portd;
1046                 else
1047                         return;
1048         }
1049         if (spec->autocfg.hp_pins[0])
1050                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1051                         AC_VERB_SET_UNSOLICITED_ENABLE,
1052                         AC_USRSP_EN | ALC880_HP_EVENT);
1053
1054         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1055                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1056                 snd_hda_codec_write(codec,
1057                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1058                         AC_VERB_SET_UNSOLICITED_ENABLE,
1059                         AC_USRSP_EN | ALC880_MIC_EVENT);
1060
1061         spec->unsol_event = alc_sku_unsol_event;
1062 }
1063
1064 /*
1065  * Fix-up pin default configurations
1066  */
1067
1068 struct alc_pincfg {
1069         hda_nid_t nid;
1070         u32 val;
1071 };
1072
1073 static void alc_fix_pincfg(struct hda_codec *codec,
1074                            const struct snd_pci_quirk *quirk,
1075                            const struct alc_pincfg **pinfix)
1076 {
1077         const struct alc_pincfg *cfg;
1078
1079         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1080         if (!quirk)
1081                 return;
1082
1083         cfg = pinfix[quirk->value];
1084         for (; cfg->nid; cfg++) {
1085                 int i;
1086                 u32 val = cfg->val;
1087                 for (i = 0; i < 4; i++) {
1088                         snd_hda_codec_write(codec, cfg->nid, 0,
1089                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1090                                     val & 0xff);
1091                         val >>= 8;
1092                 }
1093         }
1094 }
1095
1096 /*
1097  * ALC880 3-stack model
1098  *
1099  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1100  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1101  *                 F-Mic = 0x1b, HP = 0x19
1102  */
1103
1104 static hda_nid_t alc880_dac_nids[4] = {
1105         /* front, rear, clfe, rear_surr */
1106         0x02, 0x05, 0x04, 0x03
1107 };
1108
1109 static hda_nid_t alc880_adc_nids[3] = {
1110         /* ADC0-2 */
1111         0x07, 0x08, 0x09,
1112 };
1113
1114 /* The datasheet says the node 0x07 is connected from inputs,
1115  * but it shows zero connection in the real implementation on some devices.
1116  * Note: this is a 915GAV bug, fixed on 915GLV
1117  */
1118 static hda_nid_t alc880_adc_nids_alt[2] = {
1119         /* ADC1-2 */
1120         0x08, 0x09,
1121 };
1122
1123 #define ALC880_DIGOUT_NID       0x06
1124 #define ALC880_DIGIN_NID        0x0a
1125
1126 static struct hda_input_mux alc880_capture_source = {
1127         .num_items = 4,
1128         .items = {
1129                 { "Mic", 0x0 },
1130                 { "Front Mic", 0x3 },
1131                 { "Line", 0x2 },
1132                 { "CD", 0x4 },
1133         },
1134 };
1135
1136 /* channel source setting (2/6 channel selection for 3-stack) */
1137 /* 2ch mode */
1138 static struct hda_verb alc880_threestack_ch2_init[] = {
1139         /* set line-in to input, mute it */
1140         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1141         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1142         /* set mic-in to input vref 80%, mute it */
1143         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1144         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1145         { } /* end */
1146 };
1147
1148 /* 6ch mode */
1149 static struct hda_verb alc880_threestack_ch6_init[] = {
1150         /* set line-in to output, unmute it */
1151         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1152         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1153         /* set mic-in to output, unmute it */
1154         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1155         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1156         { } /* end */
1157 };
1158
1159 static struct hda_channel_mode alc880_threestack_modes[2] = {
1160         { 2, alc880_threestack_ch2_init },
1161         { 6, alc880_threestack_ch6_init },
1162 };
1163
1164 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1165         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1166         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1167         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1168         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1169         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1170         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1171         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1172         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1173         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1174         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1175         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1176         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1177         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1178         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1179         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1180         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1181         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1182         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1183         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1184         {
1185                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1186                 .name = "Channel Mode",
1187                 .info = alc_ch_mode_info,
1188                 .get = alc_ch_mode_get,
1189                 .put = alc_ch_mode_put,
1190         },
1191         { } /* end */
1192 };
1193
1194 /* capture mixer elements */
1195 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1196         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1197         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1198         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1199         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1200         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1201         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1202         {
1203                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1204                 /* The multiple "Capture Source" controls confuse alsamixer
1205                  * So call somewhat different..
1206                  */
1207                 /* .name = "Capture Source", */
1208                 .name = "Input Source",
1209                 .count = 3,
1210                 .info = alc_mux_enum_info,
1211                 .get = alc_mux_enum_get,
1212                 .put = alc_mux_enum_put,
1213         },
1214         { } /* end */
1215 };
1216
1217 /* capture mixer elements (in case NID 0x07 not available) */
1218 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1219         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1220         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1221         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1222         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1223         {
1224                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1225                 /* The multiple "Capture Source" controls confuse alsamixer
1226                  * So call somewhat different..
1227                  */
1228                 /* .name = "Capture Source", */
1229                 .name = "Input Source",
1230                 .count = 2,
1231                 .info = alc_mux_enum_info,
1232                 .get = alc_mux_enum_get,
1233                 .put = alc_mux_enum_put,
1234         },
1235         { } /* end */
1236 };
1237
1238
1239
1240 /*
1241  * ALC880 5-stack model
1242  *
1243  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1244  *      Side = 0x02 (0xd)
1245  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1246  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1247  */
1248
1249 /* additional mixers to alc880_three_stack_mixer */
1250 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1251         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1252         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1253         { } /* end */
1254 };
1255
1256 /* channel source setting (6/8 channel selection for 5-stack) */
1257 /* 6ch mode */
1258 static struct hda_verb alc880_fivestack_ch6_init[] = {
1259         /* set line-in to input, mute it */
1260         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1261         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1262         { } /* end */
1263 };
1264
1265 /* 8ch mode */
1266 static struct hda_verb alc880_fivestack_ch8_init[] = {
1267         /* set line-in to output, unmute it */
1268         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1269         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1270         { } /* end */
1271 };
1272
1273 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1274         { 6, alc880_fivestack_ch6_init },
1275         { 8, alc880_fivestack_ch8_init },
1276 };
1277
1278
1279 /*
1280  * ALC880 6-stack model
1281  *
1282  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1283  *      Side = 0x05 (0x0f)
1284  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1285  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1286  */
1287
1288 static hda_nid_t alc880_6st_dac_nids[4] = {
1289         /* front, rear, clfe, rear_surr */
1290         0x02, 0x03, 0x04, 0x05
1291 };
1292
1293 static struct hda_input_mux alc880_6stack_capture_source = {
1294         .num_items = 4,
1295         .items = {
1296                 { "Mic", 0x0 },
1297                 { "Front Mic", 0x1 },
1298                 { "Line", 0x2 },
1299                 { "CD", 0x4 },
1300         },
1301 };
1302
1303 /* fixed 8-channels */
1304 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1305         { 8, NULL },
1306 };
1307
1308 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1309         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1310         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1311         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1312         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1313         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1314         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1315         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1316         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1317         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1318         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1319         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1320         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1321         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1322         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1323         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1324         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1325         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1326         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1327         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1328         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1329         {
1330                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1331                 .name = "Channel Mode",
1332                 .info = alc_ch_mode_info,
1333                 .get = alc_ch_mode_get,
1334                 .put = alc_ch_mode_put,
1335         },
1336         { } /* end */
1337 };
1338
1339
1340 /*
1341  * ALC880 W810 model
1342  *
1343  * W810 has rear IO for:
1344  * Front (DAC 02)
1345  * Surround (DAC 03)
1346  * Center/LFE (DAC 04)
1347  * Digital out (06)
1348  *
1349  * The system also has a pair of internal speakers, and a headphone jack.
1350  * These are both connected to Line2 on the codec, hence to DAC 02.
1351  *
1352  * There is a variable resistor to control the speaker or headphone
1353  * volume. This is a hardware-only device without a software API.
1354  *
1355  * Plugging headphones in will disable the internal speakers. This is
1356  * implemented in hardware, not via the driver using jack sense. In
1357  * a similar fashion, plugging into the rear socket marked "front" will
1358  * disable both the speakers and headphones.
1359  *
1360  * For input, there's a microphone jack, and an "audio in" jack.
1361  * These may not do anything useful with this driver yet, because I
1362  * haven't setup any initialization verbs for these yet...
1363  */
1364
1365 static hda_nid_t alc880_w810_dac_nids[3] = {
1366         /* front, rear/surround, clfe */
1367         0x02, 0x03, 0x04
1368 };
1369
1370 /* fixed 6 channels */
1371 static struct hda_channel_mode alc880_w810_modes[1] = {
1372         { 6, NULL }
1373 };
1374
1375 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1376 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1377         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1378         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1379         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1380         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1381         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1382         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1383         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1384         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1385         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1386         { } /* end */
1387 };
1388
1389
1390 /*
1391  * Z710V model
1392  *
1393  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1394  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1395  *                 Line = 0x1a
1396  */
1397
1398 static hda_nid_t alc880_z71v_dac_nids[1] = {
1399         0x02
1400 };
1401 #define ALC880_Z71V_HP_DAC      0x03
1402
1403 /* fixed 2 channels */
1404 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1405         { 2, NULL }
1406 };
1407
1408 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1409         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1410         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1411         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1412         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1413         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1414         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1415         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1416         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1417         { } /* end */
1418 };
1419
1420
1421 /*
1422  * ALC880 F1734 model
1423  *
1424  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1425  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1426  */
1427
1428 static hda_nid_t alc880_f1734_dac_nids[1] = {
1429         0x03
1430 };
1431 #define ALC880_F1734_HP_DAC     0x02
1432
1433 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1434         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1435         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1436         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1437         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1438         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1439         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1440         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1441         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1442         { } /* end */
1443 };
1444
1445 static struct hda_input_mux alc880_f1734_capture_source = {
1446         .num_items = 2,
1447         .items = {
1448                 { "Mic", 0x1 },
1449                 { "CD", 0x4 },
1450         },
1451 };
1452
1453
1454 /*
1455  * ALC880 ASUS model
1456  *
1457  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1458  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1459  *  Mic = 0x18, Line = 0x1a
1460  */
1461
1462 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1463 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1464
1465 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1466         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1467         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1468         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1469         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1470         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1471         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1472         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1473         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1474         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1475         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1476         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1477         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1478         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1479         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1480         {
1481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1482                 .name = "Channel Mode",
1483                 .info = alc_ch_mode_info,
1484                 .get = alc_ch_mode_get,
1485                 .put = alc_ch_mode_put,
1486         },
1487         { } /* end */
1488 };
1489
1490 /*
1491  * ALC880 ASUS W1V model
1492  *
1493  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1494  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1495  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1496  */
1497
1498 /* additional mixers to alc880_asus_mixer */
1499 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1500         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1501         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1502         { } /* end */
1503 };
1504
1505 /* additional mixers to alc880_asus_mixer */
1506 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1507         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1508         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1509         { } /* end */
1510 };
1511
1512 /* TCL S700 */
1513 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1514         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1515         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1516         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1517         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1518         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1519         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1520         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1521         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1522         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1523         {
1524                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1525                 /* The multiple "Capture Source" controls confuse alsamixer
1526                  * So call somewhat different..
1527                  */
1528                 /* .name = "Capture Source", */
1529                 .name = "Input Source",
1530                 .count = 1,
1531                 .info = alc_mux_enum_info,
1532                 .get = alc_mux_enum_get,
1533                 .put = alc_mux_enum_put,
1534         },
1535         { } /* end */
1536 };
1537
1538 /* Uniwill */
1539 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1540         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1541         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1542         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1543         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1544         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1545         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1546         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1547         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1548         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1549         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1550         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1551         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1552         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1553         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1554         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1555         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1556         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1557         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1558         {
1559                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1560                 .name = "Channel Mode",
1561                 .info = alc_ch_mode_info,
1562                 .get = alc_ch_mode_get,
1563                 .put = alc_ch_mode_put,
1564         },
1565         { } /* end */
1566 };
1567
1568 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1569         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1570         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1571         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1572         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1573         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1574         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1575         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1576         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1577         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1578         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1579         { } /* end */
1580 };
1581
1582 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1583         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1584         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1585         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1586         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1587         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1588         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1589         { } /* end */
1590 };
1591
1592 /*
1593  * virtual master controls
1594  */
1595
1596 /*
1597  * slave controls for virtual master
1598  */
1599 static const char *alc_slave_vols[] = {
1600         "Front Playback Volume",
1601         "Surround Playback Volume",
1602         "Center Playback Volume",
1603         "LFE Playback Volume",
1604         "Side Playback Volume",
1605         "Headphone Playback Volume",
1606         "Speaker Playback Volume",
1607         "Mono Playback Volume",
1608         "Line-Out Playback Volume",
1609         NULL,
1610 };
1611
1612 static const char *alc_slave_sws[] = {
1613         "Front Playback Switch",
1614         "Surround Playback Switch",
1615         "Center Playback Switch",
1616         "LFE Playback Switch",
1617         "Side Playback Switch",
1618         "Headphone Playback Switch",
1619         "Speaker Playback Switch",
1620         "Mono Playback Switch",
1621         "IEC958 Playback Switch",
1622         NULL,
1623 };
1624
1625 /*
1626  * build control elements
1627  */
1628 static int alc_build_controls(struct hda_codec *codec)
1629 {
1630         struct alc_spec *spec = codec->spec;
1631         int err;
1632         int i;
1633
1634         for (i = 0; i < spec->num_mixers; i++) {
1635                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1636                 if (err < 0)
1637                         return err;
1638         }
1639
1640         if (spec->multiout.dig_out_nid) {
1641                 err = snd_hda_create_spdif_out_ctls(codec,
1642                                                     spec->multiout.dig_out_nid);
1643                 if (err < 0)
1644                         return err;
1645                 err = snd_hda_create_spdif_share_sw(codec,
1646                                                     &spec->multiout);
1647                 if (err < 0)
1648                         return err;
1649                 spec->multiout.share_spdif = 1;
1650         }
1651         if (spec->dig_in_nid) {
1652                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1653                 if (err < 0)
1654                         return err;
1655         }
1656
1657         /* if we have no master control, let's create it */
1658         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1659                 unsigned int vmaster_tlv[4];
1660                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1661                                         HDA_OUTPUT, vmaster_tlv);
1662                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1663                                           vmaster_tlv, alc_slave_vols);
1664                 if (err < 0)
1665                         return err;
1666         }
1667         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1668                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1669                                           NULL, alc_slave_sws);
1670                 if (err < 0)
1671                         return err;
1672         }
1673
1674         return 0;
1675 }
1676
1677
1678 /*
1679  * initialize the codec volumes, etc
1680  */
1681
1682 /*
1683  * generic initialization of ADC, input mixers and output mixers
1684  */
1685 static struct hda_verb alc880_volume_init_verbs[] = {
1686         /*
1687          * Unmute ADC0-2 and set the default input to mic-in
1688          */
1689         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1690         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1691         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1692         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1693         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1694         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1695
1696         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1697          * mixer widget
1698          * Note: PASD motherboards uses the Line In 2 as the input for front
1699          * panel mic (mic 2)
1700          */
1701         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1702         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1703         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1704         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1705         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1706         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1707         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1708         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1709
1710         /*
1711          * Set up output mixers (0x0c - 0x0f)
1712          */
1713         /* set vol=0 to output mixers */
1714         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1715         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1716         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1717         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1718         /* set up input amps for analog loopback */
1719         /* Amp Indices: DAC = 0, mixer = 1 */
1720         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1721         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1722         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1723         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1724         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1725         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1726         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1727         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1728
1729         { }
1730 };
1731
1732 /*
1733  * 3-stack pin configuration:
1734  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1735  */
1736 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1737         /*
1738          * preset connection lists of input pins
1739          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1740          */
1741         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1742         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1743         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1744
1745         /*
1746          * Set pin mode and muting
1747          */
1748         /* set front pin widgets 0x14 for output */
1749         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1750         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1751         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1752         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1753         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1754         /* Mic2 (as headphone out) for HP output */
1755         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1756         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1757         /* Line In pin widget for input */
1758         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1759         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1760         /* Line2 (as front mic) pin widget for input and vref at 80% */
1761         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1762         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1763         /* CD pin widget for input */
1764         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1765
1766         { }
1767 };
1768
1769 /*
1770  * 5-stack pin configuration:
1771  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1772  * line-in/side = 0x1a, f-mic = 0x1b
1773  */
1774 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1775         /*
1776          * preset connection lists of input pins
1777          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1778          */
1779         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1780         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1781
1782         /*
1783          * Set pin mode and muting
1784          */
1785         /* set pin widgets 0x14-0x17 for output */
1786         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1787         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1788         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1789         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1790         /* unmute pins for output (no gain on this amp) */
1791         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1792         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1793         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1794         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1795
1796         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1797         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1798         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1799         /* Mic2 (as headphone out) for HP output */
1800         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1801         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1802         /* Line In pin widget for input */
1803         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1804         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1805         /* Line2 (as front mic) pin widget for input and vref at 80% */
1806         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1807         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1808         /* CD pin widget for input */
1809         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1810
1811         { }
1812 };
1813
1814 /*
1815  * W810 pin configuration:
1816  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1817  */
1818 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1819         /* hphone/speaker input selector: front DAC */
1820         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1821
1822         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1823         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1824         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1825         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1826         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1827         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1828
1829         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1830         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1831
1832         { }
1833 };
1834
1835 /*
1836  * Z71V pin configuration:
1837  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1838  */
1839 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1840         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1841         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1842         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1843         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1844
1845         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1846         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1847         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1848         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1849
1850         { }
1851 };
1852
1853 /*
1854  * 6-stack pin configuration:
1855  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1856  * f-mic = 0x19, line = 0x1a, HP = 0x1b
1857  */
1858 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1859         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1860
1861         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1862         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1863         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1864         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1865         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1866         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1867         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1868         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1869
1870         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1871         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1872         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1873         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1874         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1875         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1876         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1877         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1878         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1879
1880         { }
1881 };
1882
1883 /*
1884  * Uniwill pin configuration:
1885  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1886  * line = 0x1a
1887  */
1888 static struct hda_verb alc880_uniwill_init_verbs[] = {
1889         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1890
1891         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1892         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1893         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1894         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1895         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1896         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1897         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1898         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1899         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1900         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1901         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1902         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1903         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1904         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1905
1906         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1907         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1908         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1909         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1910         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1911         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1912         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1913         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1914         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1915
1916         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1917         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1918
1919         { }
1920 };
1921
1922 /*
1923 * Uniwill P53
1924 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1925  */
1926 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1927         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1928
1929         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1930         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1931         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1932         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1933         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1934         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1935         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1936         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1937         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1938         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1939         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1940         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1941
1942         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1943         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1944         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1945         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1946         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1947         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1948
1949         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1950         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1951
1952         { }
1953 };
1954
1955 static struct hda_verb alc880_beep_init_verbs[] = {
1956         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1957         { }
1958 };
1959
1960 /* toggle speaker-output according to the hp-jack state */
1961 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1962 {
1963         unsigned int present;
1964         unsigned char bits;
1965
1966         present = snd_hda_codec_read(codec, 0x14, 0,
1967                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1968         bits = present ? HDA_AMP_MUTE : 0;
1969         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1970                                  HDA_AMP_MUTE, bits);
1971         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1972                                  HDA_AMP_MUTE, bits);
1973 }
1974
1975 /* auto-toggle front mic */
1976 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1977 {
1978         unsigned int present;
1979         unsigned char bits;
1980
1981         present = snd_hda_codec_read(codec, 0x18, 0,
1982                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1983         bits = present ? HDA_AMP_MUTE : 0;
1984         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1985 }
1986
1987 static void alc880_uniwill_automute(struct hda_codec *codec)
1988 {
1989         alc880_uniwill_hp_automute(codec);
1990         alc880_uniwill_mic_automute(codec);
1991 }
1992
1993 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
1994                                        unsigned int res)
1995 {
1996         /* Looks like the unsol event is incompatible with the standard
1997          * definition.  4bit tag is placed at 28 bit!
1998          */
1999         switch (res >> 28) {
2000         case ALC880_HP_EVENT:
2001                 alc880_uniwill_hp_automute(codec);
2002                 break;
2003         case ALC880_MIC_EVENT:
2004                 alc880_uniwill_mic_automute(codec);
2005                 break;
2006         }
2007 }
2008
2009 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2010 {
2011         unsigned int present;
2012         unsigned char bits;
2013
2014         present = snd_hda_codec_read(codec, 0x14, 0,
2015                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2016         bits = present ? HDA_AMP_MUTE : 0;
2017         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2018 }
2019
2020 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2021 {
2022         unsigned int present;
2023
2024         present = snd_hda_codec_read(codec, 0x21, 0,
2025                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2026         present &= HDA_AMP_VOLMASK;
2027         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2028                                  HDA_AMP_VOLMASK, present);
2029         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2030                                  HDA_AMP_VOLMASK, present);
2031 }
2032
2033 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2034                                            unsigned int res)
2035 {
2036         /* Looks like the unsol event is incompatible with the standard
2037          * definition.  4bit tag is placed at 28 bit!
2038          */
2039         if ((res >> 28) == ALC880_HP_EVENT)
2040                 alc880_uniwill_p53_hp_automute(codec);
2041         if ((res >> 28) == ALC880_DCVOL_EVENT)
2042                 alc880_uniwill_p53_dcvol_automute(codec);
2043 }
2044
2045 /*
2046  * F1734 pin configuration:
2047  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2048  */
2049 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2050         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2051         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2052         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2053         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2054         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2055
2056         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2057         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2058         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2059         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2060
2061         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2062         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2063         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2064         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2065         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2066         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2067         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2068         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2069         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2070
2071         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2072         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2073
2074         { }
2075 };
2076
2077 /*
2078  * ASUS pin configuration:
2079  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2080  */
2081 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2082         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2083         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2084         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2085         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2086
2087         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2088         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2089         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2090         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2091         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2092         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2093         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2094         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2095
2096         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2097         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2098         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2099         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2100         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2101         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2102         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2103         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2104         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2105
2106         { }
2107 };
2108
2109 /* Enable GPIO mask and set output */
2110 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2111 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2112
2113 /* Clevo m520g init */
2114 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2115         /* headphone output */
2116         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2117         /* line-out */
2118         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2119         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2120         /* Line-in */
2121         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2122         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2123         /* CD */
2124         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2125         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2126         /* Mic1 (rear panel) */
2127         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2128         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2129         /* Mic2 (front panel) */
2130         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2131         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2132         /* headphone */
2133         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2134         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2135         /* change to EAPD mode */
2136         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2137         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2138
2139         { }
2140 };
2141
2142 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2143         /* change to EAPD mode */
2144         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2145         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2146
2147         /* Headphone output */
2148         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2149         /* Front output*/
2150         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2151         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2152
2153         /* Line In pin widget for input */
2154         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2155         /* CD pin widget for input */
2156         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2157         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2158         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2159
2160         /* change to EAPD mode */
2161         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2162         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2163
2164         { }
2165 };
2166
2167 /*
2168  * LG m1 express dual
2169  *
2170  * Pin assignment:
2171  *   Rear Line-In/Out (blue): 0x14
2172  *   Build-in Mic-In: 0x15
2173  *   Speaker-out: 0x17
2174  *   HP-Out (green): 0x1b
2175  *   Mic-In/Out (red): 0x19
2176  *   SPDIF-Out: 0x1e
2177  */
2178
2179 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2180 static hda_nid_t alc880_lg_dac_nids[3] = {
2181         0x05, 0x02, 0x03
2182 };
2183
2184 /* seems analog CD is not working */
2185 static struct hda_input_mux alc880_lg_capture_source = {
2186         .num_items = 3,
2187         .items = {
2188                 { "Mic", 0x1 },
2189                 { "Line", 0x5 },
2190                 { "Internal Mic", 0x6 },
2191         },
2192 };
2193
2194 /* 2,4,6 channel modes */
2195 static struct hda_verb alc880_lg_ch2_init[] = {
2196         /* set line-in and mic-in to input */
2197         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2198         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2199         { }
2200 };
2201
2202 static struct hda_verb alc880_lg_ch4_init[] = {
2203         /* set line-in to out and mic-in to input */
2204         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2205         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2206         { }
2207 };
2208
2209 static struct hda_verb alc880_lg_ch6_init[] = {
2210         /* set line-in and mic-in to output */
2211         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2212         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2213         { }
2214 };
2215
2216 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2217         { 2, alc880_lg_ch2_init },
2218         { 4, alc880_lg_ch4_init },
2219         { 6, alc880_lg_ch6_init },
2220 };
2221
2222 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2223         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2224         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2225         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2226         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2227         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2228         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2229         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2230         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2231         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2232         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2233         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2234         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2235         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2236         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2237         {
2238                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2239                 .name = "Channel Mode",
2240                 .info = alc_ch_mode_info,
2241                 .get = alc_ch_mode_get,
2242                 .put = alc_ch_mode_put,
2243         },
2244         { } /* end */
2245 };
2246
2247 static struct hda_verb alc880_lg_init_verbs[] = {
2248         /* set capture source to mic-in */
2249         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2250         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2251         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2252         /* mute all amp mixer inputs */
2253         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2254         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2255         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2256         /* line-in to input */
2257         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2258         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2259         /* built-in mic */
2260         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2261         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2262         /* speaker-out */
2263         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2264         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2265         /* mic-in to input */
2266         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2267         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2268         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2269         /* HP-out */
2270         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2271         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2272         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2273         /* jack sense */
2274         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2275         { }
2276 };
2277
2278 /* toggle speaker-output according to the hp-jack state */
2279 static void alc880_lg_automute(struct hda_codec *codec)
2280 {
2281         unsigned int present;
2282         unsigned char bits;
2283
2284         present = snd_hda_codec_read(codec, 0x1b, 0,
2285                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2286         bits = present ? HDA_AMP_MUTE : 0;
2287         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2288                                  HDA_AMP_MUTE, bits);
2289 }
2290
2291 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2292 {
2293         /* Looks like the unsol event is incompatible with the standard
2294          * definition.  4bit tag is placed at 28 bit!
2295          */
2296         if ((res >> 28) == 0x01)
2297                 alc880_lg_automute(codec);
2298 }
2299
2300 /*
2301  * LG LW20
2302  *
2303  * Pin assignment:
2304  *   Speaker-out: 0x14
2305  *   Mic-In: 0x18
2306  *   Built-in Mic-In: 0x19
2307  *   Line-In: 0x1b
2308  *   HP-Out: 0x1a
2309  *   SPDIF-Out: 0x1e
2310  */
2311
2312 static struct hda_input_mux alc880_lg_lw_capture_source = {
2313         .num_items = 3,
2314         .items = {
2315                 { "Mic", 0x0 },
2316                 { "Internal Mic", 0x1 },
2317                 { "Line In", 0x2 },
2318         },
2319 };
2320
2321 #define alc880_lg_lw_modes alc880_threestack_modes
2322
2323 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2324         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2325         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2326         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2327         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2328         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2329         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2330         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2331         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2332         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2333         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2334         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2335         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2336         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2337         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2338         {
2339                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2340                 .name = "Channel Mode",
2341                 .info = alc_ch_mode_info,
2342                 .get = alc_ch_mode_get,
2343                 .put = alc_ch_mode_put,
2344         },
2345         { } /* end */
2346 };
2347
2348 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2349         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2350         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2351         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2352
2353         /* set capture source to mic-in */
2354         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2355         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2356         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2357         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2358         /* speaker-out */
2359         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2360         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2361         /* HP-out */
2362         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2363         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2364         /* mic-in to input */
2365         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2366         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2367         /* built-in mic */
2368         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2369         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2370         /* jack sense */
2371         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2372         { }
2373 };
2374
2375 /* toggle speaker-output according to the hp-jack state */
2376 static void alc880_lg_lw_automute(struct hda_codec *codec)
2377 {
2378         unsigned int present;
2379         unsigned char bits;
2380
2381         present = snd_hda_codec_read(codec, 0x1b, 0,
2382                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2383         bits = present ? HDA_AMP_MUTE : 0;
2384         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2385                                  HDA_AMP_MUTE, bits);
2386 }
2387
2388 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2389 {
2390         /* Looks like the unsol event is incompatible with the standard
2391          * definition.  4bit tag is placed at 28 bit!
2392          */
2393         if ((res >> 28) == 0x01)
2394                 alc880_lg_lw_automute(codec);
2395 }
2396
2397 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2398         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2399         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2400         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2401         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2402         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2403         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2404         { } /* end */
2405 };
2406
2407 static struct hda_input_mux alc880_medion_rim_capture_source = {
2408         .num_items = 2,
2409         .items = {
2410                 { "Mic", 0x0 },
2411                 { "Internal Mic", 0x1 },
2412         },
2413 };
2414
2415 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2416         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2417
2418         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2419         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2420
2421         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2422         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2423         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2424         /* Mic2 (as headphone out) for HP output */
2425         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2426         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2427         /* Internal Speaker */
2428         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2429         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2430
2431         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2432         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2433
2434         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2435         { }
2436 };
2437
2438 /* toggle speaker-output according to the hp-jack state */
2439 static void alc880_medion_rim_automute(struct hda_codec *codec)
2440 {
2441         unsigned int present;
2442         unsigned char bits;
2443
2444         present = snd_hda_codec_read(codec, 0x14, 0,
2445                                      AC_VERB_GET_PIN_SENSE, 0)
2446                 & AC_PINSENSE_PRESENCE;
2447         bits = present ? HDA_AMP_MUTE : 0;
2448         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2449                                  HDA_AMP_MUTE, bits);
2450         if (present)
2451                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2452         else
2453                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2454 }
2455
2456 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2457                                           unsigned int res)
2458 {
2459         /* Looks like the unsol event is incompatible with the standard
2460          * definition.  4bit tag is placed at 28 bit!
2461          */
2462         if ((res >> 28) == ALC880_HP_EVENT)
2463                 alc880_medion_rim_automute(codec);
2464 }
2465
2466 #ifdef CONFIG_SND_HDA_POWER_SAVE
2467 static struct hda_amp_list alc880_loopbacks[] = {
2468         { 0x0b, HDA_INPUT, 0 },
2469         { 0x0b, HDA_INPUT, 1 },
2470         { 0x0b, HDA_INPUT, 2 },
2471         { 0x0b, HDA_INPUT, 3 },
2472         { 0x0b, HDA_INPUT, 4 },
2473         { } /* end */
2474 };
2475
2476 static struct hda_amp_list alc880_lg_loopbacks[] = {
2477         { 0x0b, HDA_INPUT, 1 },
2478         { 0x0b, HDA_INPUT, 6 },
2479         { 0x0b, HDA_INPUT, 7 },
2480         { } /* end */
2481 };
2482 #endif
2483
2484 /*
2485  * Common callbacks
2486  */
2487
2488 static int alc_init(struct hda_codec *codec)
2489 {
2490         struct alc_spec *spec = codec->spec;
2491         unsigned int i;
2492
2493         alc_fix_pll(codec);
2494         if (codec->vendor_id == 0x10ec0888)
2495                 alc888_coef_init(codec);
2496
2497         for (i = 0; i < spec->num_init_verbs; i++)
2498                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2499
2500         if (spec->init_hook)
2501                 spec->init_hook(codec);
2502
2503         return 0;
2504 }
2505
2506 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2507 {
2508         struct alc_spec *spec = codec->spec;
2509
2510         if (spec->unsol_event)
2511                 spec->unsol_event(codec, res);
2512 }
2513
2514 #ifdef CONFIG_SND_HDA_POWER_SAVE
2515 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2516 {
2517         struct alc_spec *spec = codec->spec;
2518         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2519 }
2520 #endif
2521
2522 /*
2523  * Analog playback callbacks
2524  */
2525 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2526                                     struct hda_codec *codec,
2527                                     struct snd_pcm_substream *substream)
2528 {
2529         struct alc_spec *spec = codec->spec;
2530         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2531                                              hinfo);
2532 }
2533
2534 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2535                                        struct hda_codec *codec,
2536                                        unsigned int stream_tag,
2537                                        unsigned int format,
2538                                        struct snd_pcm_substream *substream)
2539 {
2540         struct alc_spec *spec = codec->spec;
2541         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2542                                                 stream_tag, format, substream);
2543 }
2544
2545 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2546                                        struct hda_codec *codec,
2547                                        struct snd_pcm_substream *substream)
2548 {
2549         struct alc_spec *spec = codec->spec;
2550         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2551 }
2552
2553 /*
2554  * Digital out
2555  */
2556 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2557                                         struct hda_codec *codec,
2558                                         struct snd_pcm_substream *substream)
2559 {
2560         struct alc_spec *spec = codec->spec;
2561         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2562 }
2563
2564 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2565                                            struct hda_codec *codec,
2566                                            unsigned int stream_tag,
2567                                            unsigned int format,
2568                                            struct snd_pcm_substream *substream)
2569 {
2570         struct alc_spec *spec = codec->spec;
2571         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2572                                              stream_tag, format, substream);
2573 }
2574
2575 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2576                                          struct hda_codec *codec,
2577                                          struct snd_pcm_substream *substream)
2578 {
2579         struct alc_spec *spec = codec->spec;
2580         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2581 }
2582
2583 /*
2584  * Analog capture
2585  */
2586 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2587                                       struct hda_codec *codec,
2588                                       unsigned int stream_tag,
2589                                       unsigned int format,
2590                                       struct snd_pcm_substream *substream)
2591 {
2592         struct alc_spec *spec = codec->spec;
2593
2594         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2595                                    stream_tag, 0, format);
2596         return 0;
2597 }
2598
2599 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2600                                       struct hda_codec *codec,
2601                                       struct snd_pcm_substream *substream)
2602 {
2603         struct alc_spec *spec = codec->spec;
2604
2605         snd_hda_codec_cleanup_stream(codec,
2606                                      spec->adc_nids[substream->number + 1]);
2607         return 0;
2608 }
2609
2610
2611 /*
2612  */
2613 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2614         .substreams = 1,
2615         .channels_min = 2,
2616         .channels_max = 8,
2617         /* NID is set in alc_build_pcms */
2618         .ops = {
2619                 .open = alc880_playback_pcm_open,
2620                 .prepare = alc880_playback_pcm_prepare,
2621                 .cleanup = alc880_playback_pcm_cleanup
2622         },
2623 };
2624
2625 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2626         .substreams = 1,
2627         .channels_min = 2,
2628         .channels_max = 2,
2629         /* NID is set in alc_build_pcms */
2630 };
2631
2632 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2633         .substreams = 1,
2634         .channels_min = 2,
2635         .channels_max = 2,
2636         /* NID is set in alc_build_pcms */
2637 };
2638
2639 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2640         .substreams = 2, /* can be overridden */
2641         .channels_min = 2,
2642         .channels_max = 2,
2643         /* NID is set in alc_build_pcms */
2644         .ops = {
2645                 .prepare = alc880_alt_capture_pcm_prepare,
2646                 .cleanup = alc880_alt_capture_pcm_cleanup
2647         },
2648 };
2649
2650 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2651         .substreams = 1,
2652         .channels_min = 2,
2653         .channels_max = 2,
2654         /* NID is set in alc_build_pcms */
2655         .ops = {
2656                 .open = alc880_dig_playback_pcm_open,
2657                 .close = alc880_dig_playback_pcm_close,
2658                 .prepare = alc880_dig_playback_pcm_prepare
2659         },
2660 };
2661
2662 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2663         .substreams = 1,
2664         .channels_min = 2,
2665         .channels_max = 2,
2666         /* NID is set in alc_build_pcms */
2667 };
2668
2669 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2670 static struct hda_pcm_stream alc_pcm_null_stream = {
2671         .substreams = 0,
2672         .channels_min = 0,
2673         .channels_max = 0,
2674 };
2675
2676 static int alc_build_pcms(struct hda_codec *codec)
2677 {
2678         struct alc_spec *spec = codec->spec;
2679         struct hda_pcm *info = spec->pcm_rec;
2680         int i;
2681
2682         codec->num_pcms = 1;
2683         codec->pcm_info = info;
2684
2685         info->name = spec->stream_name_analog;
2686         if (spec->stream_analog_playback) {
2687                 if (snd_BUG_ON(!spec->multiout.dac_nids))
2688                         return -EINVAL;
2689                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2690                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2691         }
2692         if (spec->stream_analog_capture) {
2693                 if (snd_BUG_ON(!spec->adc_nids))
2694                         return -EINVAL;
2695                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2696                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2697         }
2698
2699         if (spec->channel_mode) {
2700                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2701                 for (i = 0; i < spec->num_channel_mode; i++) {
2702                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2703                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2704                         }
2705                 }
2706         }
2707
2708         /* SPDIF for stream index #1 */
2709         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2710                 codec->num_pcms = 2;
2711                 info = spec->pcm_rec + 1;
2712                 info->name = spec->stream_name_digital;
2713                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2714                 if (spec->multiout.dig_out_nid &&
2715                     spec->stream_digital_playback) {
2716                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2717                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2718                 }
2719                 if (spec->dig_in_nid &&
2720                     spec->stream_digital_capture) {
2721                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2722                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2723                 }
2724                 /* FIXME: do we need this for all Realtek codec models? */
2725                 codec->spdif_status_reset = 1;
2726         }
2727
2728         /* If the use of more than one ADC is requested for the current
2729          * model, configure a second analog capture-only PCM.
2730          */
2731         /* Additional Analaog capture for index #2 */
2732         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2733             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2734                 codec->num_pcms = 3;
2735                 info = spec->pcm_rec + 2;
2736                 info->name = spec->stream_name_analog;
2737                 if (spec->alt_dac_nid) {
2738                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2739                                 *spec->stream_analog_alt_playback;
2740                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2741                                 spec->alt_dac_nid;
2742                 } else {
2743                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2744                                 alc_pcm_null_stream;
2745                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2746                 }
2747                 if (spec->num_adc_nids > 1) {
2748                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2749                                 *spec->stream_analog_alt_capture;
2750                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2751                                 spec->adc_nids[1];
2752                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2753                                 spec->num_adc_nids - 1;
2754                 } else {
2755                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2756                                 alc_pcm_null_stream;
2757                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2758                 }
2759         }
2760
2761         return 0;
2762 }
2763
2764 static void alc_free(struct hda_codec *codec)
2765 {
2766         struct alc_spec *spec = codec->spec;
2767         unsigned int i;
2768
2769         if (!spec)
2770                 return;
2771
2772         if (spec->kctl_alloc) {
2773                 for (i = 0; i < spec->num_kctl_used; i++)
2774                         kfree(spec->kctl_alloc[i].name);
2775                 kfree(spec->kctl_alloc);
2776         }
2777         kfree(spec);
2778         codec->spec = NULL; /* to be sure */
2779 }
2780
2781 /*
2782  */
2783 static struct hda_codec_ops alc_patch_ops = {
2784         .build_controls = alc_build_controls,
2785         .build_pcms = alc_build_pcms,
2786         .init = alc_init,
2787         .free = alc_free,
2788         .unsol_event = alc_unsol_event,
2789 #ifdef CONFIG_SND_HDA_POWER_SAVE
2790         .check_power_status = alc_check_power_status,
2791 #endif
2792 };
2793
2794
2795 /*
2796  * Test configuration for debugging
2797  *
2798  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
2799  * enum controls.
2800  */
2801 #ifdef CONFIG_SND_DEBUG
2802 static hda_nid_t alc880_test_dac_nids[4] = {
2803         0x02, 0x03, 0x04, 0x05
2804 };
2805
2806 static struct hda_input_mux alc880_test_capture_source = {
2807         .num_items = 7,
2808         .items = {
2809                 { "In-1", 0x0 },
2810                 { "In-2", 0x1 },
2811                 { "In-3", 0x2 },
2812                 { "In-4", 0x3 },
2813                 { "CD", 0x4 },
2814                 { "Front", 0x5 },
2815                 { "Surround", 0x6 },
2816         },
2817 };
2818
2819 static struct hda_channel_mode alc880_test_modes[4] = {
2820         { 2, NULL },
2821         { 4, NULL },
2822         { 6, NULL },
2823         { 8, NULL },
2824 };
2825
2826 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2827                                  struct snd_ctl_elem_info *uinfo)
2828 {
2829         static char *texts[] = {
2830                 "N/A", "Line Out", "HP Out",
2831                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2832         };
2833         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2834         uinfo->count = 1;
2835         uinfo->value.enumerated.items = 8;
2836         if (uinfo->value.enumerated.item >= 8)
2837                 uinfo->value.enumerated.item = 7;
2838         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2839         return 0;
2840 }
2841
2842 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
2843                                 struct snd_ctl_elem_value *ucontrol)
2844 {
2845         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2846         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2847         unsigned int pin_ctl, item = 0;
2848
2849         pin_ctl = snd_hda_codec_read(codec, nid, 0,
2850                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2851         if (pin_ctl & AC_PINCTL_OUT_EN) {
2852                 if (pin_ctl & AC_PINCTL_HP_EN)
2853                         item = 2;
2854                 else
2855                         item = 1;
2856         } else if (pin_ctl & AC_PINCTL_IN_EN) {
2857                 switch (pin_ctl & AC_PINCTL_VREFEN) {
2858                 case AC_PINCTL_VREF_HIZ: item = 3; break;
2859                 case AC_PINCTL_VREF_50:  item = 4; break;
2860                 case AC_PINCTL_VREF_GRD: item = 5; break;
2861                 case AC_PINCTL_VREF_80:  item = 6; break;
2862                 case AC_PINCTL_VREF_100: item = 7; break;
2863                 }
2864         }
2865         ucontrol->value.enumerated.item[0] = item;
2866         return 0;
2867 }
2868
2869 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2870                                 struct snd_ctl_elem_value *ucontrol)
2871 {
2872         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2873         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2874         static unsigned int ctls[] = {
2875                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2876                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2877                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2878                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2879                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2880                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2881         };
2882         unsigned int old_ctl, new_ctl;
2883
2884         old_ctl = snd_hda_codec_read(codec, nid, 0,
2885                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2886         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2887         if (old_ctl != new_ctl) {
2888                 int val;
2889                 snd_hda_codec_write_cache(codec, nid, 0,
2890                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
2891                                           new_ctl);
2892                 val = ucontrol->value.enumerated.item[0] >= 3 ?
2893                         HDA_AMP_MUTE : 0;
2894                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2895                                          HDA_AMP_MUTE, val);
2896                 return 1;
2897         }
2898         return 0;
2899 }
2900
2901 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2902                                  struct snd_ctl_elem_info *uinfo)
2903 {
2904         static char *texts[] = {
2905                 "Front", "Surround", "CLFE", "Side"
2906         };
2907         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2908         uinfo->count = 1;
2909         uinfo->value.enumerated.items = 4;
2910         if (uinfo->value.enumerated.item >= 4)
2911                 uinfo->value.enumerated.item = 3;
2912         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2913         return 0;
2914 }
2915
2916 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2917                                 struct snd_ctl_elem_value *ucontrol)
2918 {
2919         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2920         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2921         unsigned int sel;
2922
2923         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2924         ucontrol->value.enumerated.item[0] = sel & 3;
2925         return 0;
2926 }
2927
2928 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
2929                                 struct snd_ctl_elem_value *ucontrol)
2930 {
2931         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2932         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2933         unsigned int sel;
2934
2935         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
2936         if (ucontrol->value.enumerated.item[0] != sel) {
2937                 sel = ucontrol->value.enumerated.item[0] & 3;
2938                 snd_hda_codec_write_cache(codec, nid, 0,
2939                                           AC_VERB_SET_CONNECT_SEL, sel);
2940                 return 1;
2941         }
2942         return 0;
2943 }
2944
2945 #define PIN_CTL_TEST(xname,nid) {                       \
2946                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
2947                         .name = xname,                 \
2948                         .info = alc_test_pin_ctl_info, \
2949                         .get = alc_test_pin_ctl_get,   \
2950                         .put = alc_test_pin_ctl_put,   \
2951                         .private_value = nid           \
2952                         }
2953
2954 #define PIN_SRC_TEST(xname,nid) {                       \
2955                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
2956                         .name = xname,                 \
2957                         .info = alc_test_pin_src_info, \
2958                         .get = alc_test_pin_src_get,   \
2959                         .put = alc_test_pin_src_put,   \
2960                         .private_value = nid           \
2961                         }
2962
2963 static struct snd_kcontrol_new alc880_test_mixer[] = {
2964         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2965         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2966         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
2967         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2968         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2969         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2970         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
2971         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2972         PIN_CTL_TEST("Front Pin Mode", 0x14),
2973         PIN_CTL_TEST("Surround Pin Mode", 0x15),
2974         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
2975         PIN_CTL_TEST("Side Pin Mode", 0x17),
2976         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
2977         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
2978         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
2979         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
2980         PIN_SRC_TEST("In-1 Pin Source", 0x18),
2981         PIN_SRC_TEST("In-2 Pin Source", 0x19),
2982         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
2983         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
2984         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
2985         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
2986         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
2987         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
2988         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
2989         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
2990         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
2991         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
2992         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
2993         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
2994         {
2995                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2996                 .name = "Channel Mode",
2997                 .info = alc_ch_mode_info,
2998                 .get = alc_ch_mode_get,
2999                 .put = alc_ch_mode_put,
3000         },
3001         { } /* end */
3002 };
3003
3004 static struct hda_verb alc880_test_init_verbs[] = {
3005         /* Unmute inputs of 0x0c - 0x0f */
3006         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3007         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3008         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3009         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3010         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3011         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3012         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3013         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3014         /* Vol output for 0x0c-0x0f */
3015         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3016         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3017         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3018         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3019         /* Set output pins 0x14-0x17 */
3020         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3021         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3022         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3023         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3024         /* Unmute output pins 0x14-0x17 */
3025         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3026         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3027         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3028         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3029         /* Set input pins 0x18-0x1c */
3030         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3031         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3032         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3033         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3034         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3035         /* Mute input pins 0x18-0x1b */
3036         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3037         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3038         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3039         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3040         /* ADC set up */
3041         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3042         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3043         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3044         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3045         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3046         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3047         /* Analog input/passthru */
3048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3049         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3050         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3051         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3052         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3053         { }
3054 };
3055 #endif
3056
3057 /*
3058  */
3059
3060 static const char *alc880_models[ALC880_MODEL_LAST] = {
3061         [ALC880_3ST]            = "3stack",
3062         [ALC880_TCL_S700]       = "tcl",
3063         [ALC880_3ST_DIG]        = "3stack-digout",
3064         [ALC880_CLEVO]          = "clevo",
3065         [ALC880_5ST]            = "5stack",
3066         [ALC880_5ST_DIG]        = "5stack-digout",
3067         [ALC880_W810]           = "w810",
3068         [ALC880_Z71V]           = "z71v",
3069         [ALC880_6ST]            = "6stack",
3070         [ALC880_6ST_DIG]        = "6stack-digout",
3071         [ALC880_ASUS]           = "asus",
3072         [ALC880_ASUS_W1V]       = "asus-w1v",
3073         [ALC880_ASUS_DIG]       = "asus-dig",
3074         [ALC880_ASUS_DIG2]      = "asus-dig2",
3075         [ALC880_UNIWILL_DIG]    = "uniwill",
3076         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3077         [ALC880_FUJITSU]        = "fujitsu",
3078         [ALC880_F1734]          = "F1734",
3079         [ALC880_LG]             = "lg",
3080         [ALC880_LG_LW]          = "lg-lw",
3081         [ALC880_MEDION_RIM]     = "medion",
3082 #ifdef CONFIG_SND_DEBUG
3083         [ALC880_TEST]           = "test",
3084 #endif
3085         [ALC880_AUTO]           = "auto",
3086 };
3087
3088 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3089         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3090         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3091         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3092         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3093         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3094         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3095         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3096         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3097         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3098         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3099         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3100         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3101         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3102         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3103         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3104         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3105         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3106         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3107         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3108         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3109         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3110         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3111         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3112         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3113         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3114         SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3115         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3116         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3117         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3118         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3119         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3120         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3121         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3122         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3123         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3124         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3125         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3126         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3127         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3128         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3129         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3130         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3131         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3132         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3133         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3134         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3135         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3136         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3137         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3138         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3139         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3140         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3141         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3142         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3143         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3144         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3145         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3146         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3147         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3148         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3149         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3150         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3151         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3152         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3153         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3154         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3155         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3156         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3157         SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3158         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3159         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3160         {}
3161 };
3162
3163 /*
3164  * ALC880 codec presets
3165  */
3166 static struct alc_config_preset alc880_presets[] = {
3167         [ALC880_3ST] = {
3168                 .mixers = { alc880_three_stack_mixer },
3169                 .init_verbs = { alc880_volume_init_verbs,
3170                                 alc880_pin_3stack_init_verbs },
3171                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3172                 .dac_nids = alc880_dac_nids,
3173                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3174                 .channel_mode = alc880_threestack_modes,
3175                 .need_dac_fix = 1,
3176                 .input_mux = &alc880_capture_source,
3177         },
3178         [ALC880_3ST_DIG] = {
3179                 .mixers = { alc880_three_stack_mixer },
3180                 .init_verbs = { alc880_volume_init_verbs,
3181                                 alc880_pin_3stack_init_verbs },
3182                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3183                 .dac_nids = alc880_dac_nids,
3184                 .dig_out_nid = ALC880_DIGOUT_NID,
3185                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3186                 .channel_mode = alc880_threestack_modes,
3187                 .need_dac_fix = 1,
3188                 .input_mux = &alc880_capture_source,
3189         },
3190         [ALC880_TCL_S700] = {
3191                 .mixers = { alc880_tcl_s700_mixer },
3192                 .init_verbs = { alc880_volume_init_verbs,
3193                                 alc880_pin_tcl_S700_init_verbs,
3194                                 alc880_gpio2_init_verbs },
3195                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3196                 .dac_nids = alc880_dac_nids,
3197                 .hp_nid = 0x03,
3198                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3199                 .channel_mode = alc880_2_jack_modes,
3200                 .input_mux = &alc880_capture_source,
3201         },
3202         [ALC880_5ST] = {
3203                 .mixers = { alc880_three_stack_mixer,
3204                             alc880_five_stack_mixer},
3205                 .init_verbs = { alc880_volume_init_verbs,
3206                                 alc880_pin_5stack_init_verbs },
3207                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3208                 .dac_nids = alc880_dac_nids,
3209                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3210                 .channel_mode = alc880_fivestack_modes,
3211                 .input_mux = &alc880_capture_source,
3212         },
3213         [ALC880_5ST_DIG] = {
3214                 .mixers = { alc880_three_stack_mixer,
3215                             alc880_five_stack_mixer },
3216                 .init_verbs = { alc880_volume_init_verbs,
3217                                 alc880_pin_5stack_init_verbs },
3218                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3219                 .dac_nids = alc880_dac_nids,
3220                 .dig_out_nid = ALC880_DIGOUT_NID,
3221                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3222                 .channel_mode = alc880_fivestack_modes,
3223                 .input_mux = &alc880_capture_source,
3224         },
3225         [ALC880_6ST] = {
3226                 .mixers = { alc880_six_stack_mixer },
3227                 .init_verbs = { alc880_volume_init_verbs,
3228                                 alc880_pin_6stack_init_verbs },
3229                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3230                 .dac_nids = alc880_6st_dac_nids,
3231                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3232                 .channel_mode = alc880_sixstack_modes,
3233                 .input_mux = &alc880_6stack_capture_source,
3234         },
3235         [ALC880_6ST_DIG] = {
3236                 .mixers = { alc880_six_stack_mixer },
3237                 .init_verbs = { alc880_volume_init_verbs,
3238                                 alc880_pin_6stack_init_verbs },
3239                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3240                 .dac_nids = alc880_6st_dac_nids,
3241                 .dig_out_nid = ALC880_DIGOUT_NID,
3242                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3243                 .channel_mode = alc880_sixstack_modes,
3244                 .input_mux = &alc880_6stack_capture_source,
3245         },
3246         [ALC880_W810] = {
3247                 .mixers = { alc880_w810_base_mixer },
3248                 .init_verbs = { alc880_volume_init_verbs,
3249                                 alc880_pin_w810_init_verbs,
3250                                 alc880_gpio2_init_verbs },
3251                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3252                 .dac_nids = alc880_w810_dac_nids,
3253                 .dig_out_nid = ALC880_DIGOUT_NID,
3254                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3255                 .channel_mode = alc880_w810_modes,
3256                 .input_mux = &alc880_capture_source,
3257         },
3258         [ALC880_Z71V] = {
3259                 .mixers = { alc880_z71v_mixer },
3260                 .init_verbs = { alc880_volume_init_verbs,
3261                                 alc880_pin_z71v_init_verbs },
3262                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3263                 .dac_nids = alc880_z71v_dac_nids,
3264                 .dig_out_nid = ALC880_DIGOUT_NID,
3265                 .hp_nid = 0x03,
3266                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3267                 .channel_mode = alc880_2_jack_modes,
3268                 .input_mux = &alc880_capture_source,
3269         },
3270         [ALC880_F1734] = {
3271                 .mixers = { alc880_f1734_mixer },
3272                 .init_verbs = { alc880_volume_init_verbs,
3273                                 alc880_pin_f1734_init_verbs },
3274                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3275                 .dac_nids = alc880_f1734_dac_nids,
3276                 .hp_nid = 0x02,
3277                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3278                 .channel_mode = alc880_2_jack_modes,
3279                 .input_mux = &alc880_f1734_capture_source,
3280                 .unsol_event = alc880_uniwill_p53_unsol_event,
3281                 .init_hook = alc880_uniwill_p53_hp_automute,
3282         },
3283         [ALC880_ASUS] = {
3284                 .mixers = { alc880_asus_mixer },
3285                 .init_verbs = { alc880_volume_init_verbs,
3286                                 alc880_pin_asus_init_verbs,
3287                                 alc880_gpio1_init_verbs },
3288                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3289                 .dac_nids = alc880_asus_dac_nids,
3290                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3291                 .channel_mode = alc880_asus_modes,
3292                 .need_dac_fix = 1,
3293                 .input_mux = &alc880_capture_source,
3294         },
3295         [ALC880_ASUS_DIG] = {
3296                 .mixers = { alc880_asus_mixer },
3297                 .init_verbs = { alc880_volume_init_verbs,
3298                                 alc880_pin_asus_init_verbs,
3299                                 alc880_gpio1_init_verbs },
3300                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3301                 .dac_nids = alc880_asus_dac_nids,
3302                 .dig_out_nid = ALC880_DIGOUT_NID,
3303                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3304                 .channel_mode = alc880_asus_modes,
3305                 .need_dac_fix = 1,
3306                 .input_mux = &alc880_capture_source,
3307         },
3308         [ALC880_ASUS_DIG2] = {
3309                 .mixers = { alc880_asus_mixer },
3310                 .init_verbs = { alc880_volume_init_verbs,
3311                                 alc880_pin_asus_init_verbs,
3312                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3313                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3314                 .dac_nids = alc880_asus_dac_nids,
3315                 .dig_out_nid = ALC880_DIGOUT_NID,
3316                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3317                 .channel_mode = alc880_asus_modes,
3318                 .need_dac_fix = 1,
3319                 .input_mux = &alc880_capture_source,
3320         },
3321         [ALC880_ASUS_W1V] = {
3322                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3323                 .init_verbs = { alc880_volume_init_verbs,
3324                                 alc880_pin_asus_init_verbs,
3325                                 alc880_gpio1_init_verbs },
3326                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3327                 .dac_nids = alc880_asus_dac_nids,
3328                 .dig_out_nid = ALC880_DIGOUT_NID,
3329                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3330                 .channel_mode = alc880_asus_modes,
3331                 .need_dac_fix = 1,
3332                 .input_mux = &alc880_capture_source,
3333         },
3334         [ALC880_UNIWILL_DIG] = {
3335                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3336                 .init_verbs = { alc880_volume_init_verbs,
3337                                 alc880_pin_asus_init_verbs },
3338                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3339                 .dac_nids = alc880_asus_dac_nids,
3340                 .dig_out_nid = ALC880_DIGOUT_NID,
3341                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3342                 .channel_mode = alc880_asus_modes,
3343                 .need_dac_fix = 1,
3344                 .input_mux = &alc880_capture_source,
3345         },
3346         [ALC880_UNIWILL] = {
3347                 .mixers = { alc880_uniwill_mixer },
3348                 .init_verbs = { alc880_volume_init_verbs,
3349                                 alc880_uniwill_init_verbs },
3350                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3351                 .dac_nids = alc880_asus_dac_nids,
3352                 .dig_out_nid = ALC880_DIGOUT_NID,
3353                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3354                 .channel_mode = alc880_threestack_modes,
3355                 .need_dac_fix = 1,
3356                 .input_mux = &alc880_capture_source,
3357                 .unsol_event = alc880_uniwill_unsol_event,
3358                 .init_hook = alc880_uniwill_automute,
3359         },
3360         [ALC880_UNIWILL_P53] = {
3361                 .mixers = { alc880_uniwill_p53_mixer },
3362                 .init_verbs = { alc880_volume_init_verbs,
3363                                 alc880_uniwill_p53_init_verbs },
3364                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3365                 .dac_nids = alc880_asus_dac_nids,
3366                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3367                 .channel_mode = alc880_threestack_modes,
3368                 .input_mux = &alc880_capture_source,
3369                 .unsol_event = alc880_uniwill_p53_unsol_event,
3370                 .init_hook = alc880_uniwill_p53_hp_automute,
3371         },
3372         [ALC880_FUJITSU] = {
3373                 .mixers = { alc880_fujitsu_mixer,
3374                             alc880_pcbeep_mixer, },
3375                 .init_verbs = { alc880_volume_init_verbs,
3376                                 alc880_uniwill_p53_init_verbs,
3377                                 alc880_beep_init_verbs },
3378                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3379                 .dac_nids = alc880_dac_nids,
3380                 .dig_out_nid = ALC880_DIGOUT_NID,
3381                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3382                 .channel_mode = alc880_2_jack_modes,
3383                 .input_mux = &alc880_capture_source,
3384                 .unsol_event = alc880_uniwill_p53_unsol_event,
3385                 .init_hook = alc880_uniwill_p53_hp_automute,
3386         },
3387         [ALC880_CLEVO] = {
3388                 .mixers = { alc880_three_stack_mixer },
3389                 .init_verbs = { alc880_volume_init_verbs,
3390                                 alc880_pin_clevo_init_verbs },
3391                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3392                 .dac_nids = alc880_dac_nids,
3393                 .hp_nid = 0x03,
3394                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3395                 .channel_mode = alc880_threestack_modes,
3396                 .need_dac_fix = 1,
3397                 .input_mux = &alc880_capture_source,
3398         },
3399         [ALC880_LG] = {
3400                 .mixers = { alc880_lg_mixer },
3401                 .init_verbs = { alc880_volume_init_verbs,
3402                                 alc880_lg_init_verbs },
3403                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3404                 .dac_nids = alc880_lg_dac_nids,
3405                 .dig_out_nid = ALC880_DIGOUT_NID,
3406                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3407                 .channel_mode = alc880_lg_ch_modes,
3408                 .need_dac_fix = 1,
3409                 .input_mux = &alc880_lg_capture_source,
3410                 .unsol_event = alc880_lg_unsol_event,
3411                 .init_hook = alc880_lg_automute,
3412 #ifdef CONFIG_SND_HDA_POWER_SAVE
3413                 .loopbacks = alc880_lg_loopbacks,
3414 #endif
3415         },
3416         [ALC880_LG_LW] = {
3417                 .mixers = { alc880_lg_lw_mixer },
3418                 .init_verbs = { alc880_volume_init_verbs,
3419                                 alc880_lg_lw_init_verbs },
3420                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3421                 .dac_nids = alc880_dac_nids,
3422                 .dig_out_nid = ALC880_DIGOUT_NID,
3423                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3424                 .channel_mode = alc880_lg_lw_modes,
3425                 .input_mux = &alc880_lg_lw_capture_source,
3426                 .unsol_event = alc880_lg_lw_unsol_event,
3427                 .init_hook = alc880_lg_lw_automute,
3428         },
3429         [ALC880_MEDION_RIM] = {
3430                 .mixers = { alc880_medion_rim_mixer },
3431                 .init_verbs = { alc880_volume_init_verbs,
3432                                 alc880_medion_rim_init_verbs,
3433                                 alc_gpio2_init_verbs },
3434                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3435                 .dac_nids = alc880_dac_nids,
3436                 .dig_out_nid = ALC880_DIGOUT_NID,
3437                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3438                 .channel_mode = alc880_2_jack_modes,
3439                 .input_mux = &alc880_medion_rim_capture_source,
3440                 .unsol_event = alc880_medion_rim_unsol_event,
3441                 .init_hook = alc880_medion_rim_automute,
3442         },
3443 #ifdef CONFIG_SND_DEBUG
3444         [ALC880_TEST] = {
3445                 .mixers = { alc880_test_mixer },
3446                 .init_verbs = { alc880_test_init_verbs },
3447                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3448                 .dac_nids = alc880_test_dac_nids,
3449                 .dig_out_nid = ALC880_DIGOUT_NID,
3450                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3451                 .channel_mode = alc880_test_modes,
3452                 .input_mux = &alc880_test_capture_source,
3453         },
3454 #endif
3455 };
3456
3457 /*
3458  * Automatic parse of I/O pins from the BIOS configuration
3459  */
3460
3461 #define NUM_CONTROL_ALLOC       32
3462 #define NUM_VERB_ALLOC          32
3463
3464 enum {
3465         ALC_CTL_WIDGET_VOL,
3466         ALC_CTL_WIDGET_MUTE,
3467         ALC_CTL_BIND_MUTE,
3468 };
3469 static struct snd_kcontrol_new alc880_control_templates[] = {
3470         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3471         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3472         HDA_BIND_MUTE(NULL, 0, 0, 0),
3473 };
3474
3475 /* add dynamic controls */
3476 static int add_control(struct alc_spec *spec, int type, const char *name,
3477                        unsigned long val)
3478 {
3479         struct snd_kcontrol_new *knew;
3480
3481         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3482                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3483
3484                 /* array + terminator */
3485                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3486                 if (!knew)
3487                         return -ENOMEM;
3488                 if (spec->kctl_alloc) {
3489                         memcpy(knew, spec->kctl_alloc,
3490                                sizeof(*knew) * spec->num_kctl_alloc);
3491                         kfree(spec->kctl_alloc);
3492                 }
3493                 spec->kctl_alloc = knew;
3494                 spec->num_kctl_alloc = num;
3495         }
3496
3497         knew = &spec->kctl_alloc[spec->num_kctl_used];
3498         *knew = alc880_control_templates[type];
3499         knew->name = kstrdup(name, GFP_KERNEL);
3500         if (!knew->name)
3501                 return -ENOMEM;
3502         knew->private_value = val;
3503         spec->num_kctl_used++;
3504         return 0;
3505 }
3506
3507 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3508 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3509 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3510 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3511 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3512 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3513 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3514 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3515 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3516 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3517 #define ALC880_PIN_CD_NID               0x1c
3518
3519 /* fill in the dac_nids table from the parsed pin configuration */
3520 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3521                                      const struct auto_pin_cfg *cfg)
3522 {
3523         hda_nid_t nid;
3524         int assigned[4];
3525         int i, j;
3526
3527         memset(assigned, 0, sizeof(assigned));
3528         spec->multiout.dac_nids = spec->private_dac_nids;
3529
3530         /* check the pins hardwired to audio widget */
3531         for (i = 0; i < cfg->line_outs; i++) {
3532                 nid = cfg->line_out_pins[i];
3533                 if (alc880_is_fixed_pin(nid)) {
3534                         int idx = alc880_fixed_pin_idx(nid);
3535                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3536                         assigned[idx] = 1;
3537                 }
3538         }
3539         /* left pins can be connect to any audio widget */
3540         for (i = 0; i < cfg->line_outs; i++) {
3541                 nid = cfg->line_out_pins[i];
3542                 if (alc880_is_fixed_pin(nid))
3543                         continue;
3544                 /* search for an empty channel */
3545                 for (j = 0; j < cfg->line_outs; j++) {
3546                         if (!assigned[j]) {
3547                                 spec->multiout.dac_nids[i] =
3548                                         alc880_idx_to_dac(j);
3549                                 assigned[j] = 1;
3550                                 break;
3551                         }
3552                 }
3553         }
3554         spec->multiout.num_dacs = cfg->line_outs;
3555         return 0;
3556 }
3557
3558 /* add playback controls from the parsed DAC table */
3559 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3560                                              const struct auto_pin_cfg *cfg)
3561 {
3562         char name[32];
3563         static const char *chname[4] = {
3564                 "Front", "Surround", NULL /*CLFE*/, "Side"
3565         };
3566         hda_nid_t nid;
3567         int i, err;
3568
3569         for (i = 0; i < cfg->line_outs; i++) {
3570                 if (!spec->multiout.dac_nids[i])
3571                         continue;
3572                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3573                 if (i == 2) {
3574                         /* Center/LFE */
3575                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3576                                           "Center Playback Volume",
3577                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3578                                                               HDA_OUTPUT));
3579                         if (err < 0)
3580                                 return err;
3581                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3582                                           "LFE Playback Volume",
3583                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3584                                                               HDA_OUTPUT));
3585                         if (err < 0)
3586                                 return err;
3587                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3588                                           "Center Playback Switch",
3589                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3590                                                               HDA_INPUT));
3591                         if (err < 0)
3592                                 return err;
3593                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3594                                           "LFE Playback Switch",
3595                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3596                                                               HDA_INPUT));
3597                         if (err < 0)
3598                                 return err;
3599                 } else {
3600                         sprintf(name, "%s Playback Volume", chname[i]);
3601                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3602                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3603                                                               HDA_OUTPUT));
3604                         if (err < 0)
3605                                 return err;
3606                         sprintf(name, "%s Playback Switch", chname[i]);
3607                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3608                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3609                                                               HDA_INPUT));
3610                         if (err < 0)
3611                                 return err;
3612                 }
3613         }
3614         return 0;
3615 }
3616
3617 /* add playback controls for speaker and HP outputs */
3618 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3619                                         const char *pfx)
3620 {
3621         hda_nid_t nid;
3622         int err;
3623         char name[32];
3624
3625         if (!pin)
3626                 return 0;
3627
3628         if (alc880_is_fixed_pin(pin)) {
3629                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3630                 /* specify the DAC as the extra output */
3631                 if (!spec->multiout.hp_nid)
3632                         spec->multiout.hp_nid = nid;
3633                 else
3634                         spec->multiout.extra_out_nid[0] = nid;
3635                 /* control HP volume/switch on the output mixer amp */
3636                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3637                 sprintf(name, "%s Playback Volume", pfx);
3638                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3639                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3640                 if (err < 0)
3641                         return err;
3642                 sprintf(name, "%s Playback Switch", pfx);
3643                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3644                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3645                 if (err < 0)
3646                         return err;
3647         } else if (alc880_is_multi_pin(pin)) {
3648                 /* set manual connection */
3649                 /* we have only a switch on HP-out PIN */
3650                 sprintf(name, "%s Playback Switch", pfx);
3651                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3652                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3653                 if (err < 0)
3654                         return err;
3655         }
3656         return 0;
3657 }
3658
3659 /* create input playback/capture controls for the given pin */
3660 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3661                             const char *ctlname,
3662                             int idx, hda_nid_t mix_nid)
3663 {
3664         char name[32];
3665         int err;
3666
3667         sprintf(name, "%s Playback Volume", ctlname);
3668         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3669                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3670         if (err < 0)
3671                 return err;
3672         sprintf(name, "%s Playback Switch", ctlname);
3673         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3674                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3675         if (err < 0)
3676                 return err;
3677         return 0;
3678 }
3679
3680 /* create playback/capture controls for input pins */
3681 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3682                                                 const struct auto_pin_cfg *cfg)
3683 {
3684         struct hda_input_mux *imux = &spec->private_imux;
3685         int i, err, idx;
3686
3687         for (i = 0; i < AUTO_PIN_LAST; i++) {
3688                 if (alc880_is_input_pin(cfg->input_pins[i])) {
3689                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
3690                         err = new_analog_input(spec, cfg->input_pins[i],
3691                                                auto_pin_cfg_labels[i],
3692                                                idx, 0x0b);
3693                         if (err < 0)
3694                                 return err;
3695                         imux->items[imux->num_items].label =
3696                                 auto_pin_cfg_labels[i];
3697                         imux->items[imux->num_items].index =
3698                                 alc880_input_pin_idx(cfg->input_pins[i]);
3699                         imux->num_items++;
3700                 }
3701         }
3702         return 0;
3703 }
3704
3705 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3706                                unsigned int pin_type)
3707 {
3708         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3709                             pin_type);
3710         /* unmute pin */
3711         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3712                             AMP_OUT_UNMUTE);
3713 }
3714
3715 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3716                                               hda_nid_t nid, int pin_type,
3717                                               int dac_idx)
3718 {
3719         alc_set_pin_output(codec, nid, pin_type);
3720         /* need the manual connection? */
3721         if (alc880_is_multi_pin(nid)) {
3722                 struct alc_spec *spec = codec->spec;
3723                 int idx = alc880_multi_pin_idx(nid);
3724                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3725                                     AC_VERB_SET_CONNECT_SEL,
3726                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3727         }
3728 }
3729
3730 static int get_pin_type(int line_out_type)
3731 {
3732         if (line_out_type == AUTO_PIN_HP_OUT)
3733                 return PIN_HP;
3734         else
3735                 return PIN_OUT;
3736 }
3737
3738 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3739 {
3740         struct alc_spec *spec = codec->spec;
3741         int i;
3742
3743         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3744         for (i = 0; i < spec->autocfg.line_outs; i++) {
3745                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3746                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3747                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3748         }
3749 }
3750
3751 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3752 {
3753         struct alc_spec *spec = codec->spec;
3754         hda_nid_t pin;
3755
3756         pin = spec->autocfg.speaker_pins[0];
3757         if (pin) /* connect to front */
3758                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3759         pin = spec->autocfg.hp_pins[0];
3760         if (pin) /* connect to front */
3761                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3762 }
3763
3764 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3765 {
3766         struct alc_spec *spec = codec->spec;
3767         int i;
3768
3769         for (i = 0; i < AUTO_PIN_LAST; i++) {
3770                 hda_nid_t nid = spec->autocfg.input_pins[i];
3771                 if (alc880_is_input_pin(nid)) {
3772                         snd_hda_codec_write(codec, nid, 0,
3773                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
3774                                             i <= AUTO_PIN_FRONT_MIC ?
3775                                             PIN_VREF80 : PIN_IN);
3776                         if (nid != ALC880_PIN_CD_NID)
3777                                 snd_hda_codec_write(codec, nid, 0,
3778                                                     AC_VERB_SET_AMP_GAIN_MUTE,
3779                                                     AMP_OUT_MUTE);
3780                 }
3781         }
3782 }
3783
3784 /* parse the BIOS configuration and set up the alc_spec */
3785 /* return 1 if successful, 0 if the proper config is not found,
3786  * or a negative error code
3787  */
3788 static int alc880_parse_auto_config(struct hda_codec *codec)
3789 {
3790         struct alc_spec *spec = codec->spec;
3791         int err;
3792         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3793
3794         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3795                                            alc880_ignore);
3796         if (err < 0)
3797                 return err;
3798         if (!spec->autocfg.line_outs)
3799                 return 0; /* can't find valid BIOS pin config */
3800
3801         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3802         if (err < 0)
3803                 return err;
3804         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3805         if (err < 0)
3806                 return err;
3807         err = alc880_auto_create_extra_out(spec,
3808                                            spec->autocfg.speaker_pins[0],
3809                                            "Speaker");
3810         if (err < 0)
3811                 return err;
3812         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3813                                            "Headphone");
3814         if (err < 0)
3815                 return err;
3816         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3817         if (err < 0)
3818                 return err;
3819
3820         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3821
3822         if (spec->autocfg.dig_out_pin)
3823                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3824         if (spec->autocfg.dig_in_pin)
3825                 spec->dig_in_nid = ALC880_DIGIN_NID;
3826
3827         if (spec->kctl_alloc)
3828                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3829
3830         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3831
3832         spec->num_mux_defs = 1;
3833         spec->input_mux = &spec->private_imux;
3834
3835         return 1;
3836 }
3837
3838 /* additional initialization for auto-configuration model */
3839 static void alc880_auto_init(struct hda_codec *codec)
3840 {
3841         struct alc_spec *spec = codec->spec;
3842         alc880_auto_init_multi_out(codec);
3843         alc880_auto_init_extra_out(codec);
3844         alc880_auto_init_analog_input(codec);
3845         if (spec->unsol_event)
3846                 alc_inithook(codec);
3847 }
3848
3849 /*
3850  * OK, here we have finally the patch for ALC880
3851  */
3852
3853 static int patch_alc880(struct hda_codec *codec)
3854 {
3855         struct alc_spec *spec;
3856         int board_config;
3857         int err;
3858
3859         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3860         if (spec == NULL)
3861                 return -ENOMEM;
3862
3863         codec->spec = spec;
3864
3865         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3866                                                   alc880_models,
3867                                                   alc880_cfg_tbl);
3868         if (board_config < 0) {
3869                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3870                        "trying auto-probe from BIOS...\n");
3871                 board_config = ALC880_AUTO;
3872         }
3873
3874         if (board_config == ALC880_AUTO) {
3875                 /* automatic parse from the BIOS config */
3876                 err = alc880_parse_auto_config(codec);
3877                 if (err < 0) {
3878                         alc_free(codec);
3879                         return err;
3880                 } else if (!err) {
3881                         printk(KERN_INFO
3882                                "hda_codec: Cannot set up configuration "
3883                                "from BIOS.  Using 3-stack mode...\n");
3884                         board_config = ALC880_3ST;
3885                 }
3886         }
3887
3888         if (board_config != ALC880_AUTO)
3889                 setup_preset(spec, &alc880_presets[board_config]);
3890
3891         spec->stream_name_analog = "ALC880 Analog";
3892         spec->stream_analog_playback = &alc880_pcm_analog_playback;
3893         spec->stream_analog_capture = &alc880_pcm_analog_capture;
3894         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3895
3896         spec->stream_name_digital = "ALC880 Digital";
3897         spec->stream_digital_playback = &alc880_pcm_digital_playback;
3898         spec->stream_digital_capture = &alc880_pcm_digital_capture;
3899
3900         if (!spec->adc_nids && spec->input_mux) {
3901                 /* check whether NID 0x07 is valid */
3902                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3903                 /* get type */
3904                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3905                 if (wcap != AC_WID_AUD_IN) {
3906                         spec->adc_nids = alc880_adc_nids_alt;
3907                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3908                         spec->mixers[spec->num_mixers] =
3909                                 alc880_capture_alt_mixer;
3910                         spec->num_mixers++;
3911                 } else {
3912                         spec->adc_nids = alc880_adc_nids;
3913                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3914                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3915                         spec->num_mixers++;
3916                 }
3917         }
3918
3919         spec->vmaster_nid = 0x0c;
3920
3921         codec->patch_ops = alc_patch_ops;
3922         if (board_config == ALC880_AUTO)
3923                 spec->init_hook = alc880_auto_init;
3924 #ifdef CONFIG_SND_HDA_POWER_SAVE
3925         if (!spec->loopback.amplist)
3926                 spec->loopback.amplist = alc880_loopbacks;
3927 #endif
3928
3929         return 0;
3930 }
3931
3932
3933 /*
3934  * ALC260 support
3935  */
3936
3937 static hda_nid_t alc260_dac_nids[1] = {
3938         /* front */
3939         0x02,
3940 };
3941
3942 static hda_nid_t alc260_adc_nids[1] = {
3943         /* ADC0 */
3944         0x04,
3945 };
3946
3947 static hda_nid_t alc260_adc_nids_alt[1] = {
3948         /* ADC1 */
3949         0x05,
3950 };
3951
3952 static hda_nid_t alc260_hp_adc_nids[2] = {
3953         /* ADC1, 0 */
3954         0x05, 0x04
3955 };
3956
3957 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
3958  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
3959  */
3960 static hda_nid_t alc260_dual_adc_nids[2] = {
3961         /* ADC0, ADC1 */
3962         0x04, 0x05
3963 };
3964
3965 #define ALC260_DIGOUT_NID       0x03
3966 #define ALC260_DIGIN_NID        0x06
3967
3968 static struct hda_input_mux alc260_capture_source = {
3969         .num_items = 4,
3970         .items = {
3971                 { "Mic", 0x0 },
3972                 { "Front Mic", 0x1 },
3973                 { "Line", 0x2 },
3974                 { "CD", 0x4 },
3975         },
3976 };
3977
3978 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
3979  * headphone jack and the internal CD lines since these are the only pins at
3980  * which audio can appear.  For flexibility, also allow the option of
3981  * recording the mixer output on the second ADC (ADC0 doesn't have a
3982  * connection to the mixer output).
3983  */
3984 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
3985         {
3986                 .num_items = 3,
3987                 .items = {
3988                         { "Mic/Line", 0x0 },
3989                         { "CD", 0x4 },
3990                         { "Headphone", 0x2 },
3991                 },
3992         },
3993         {
3994                 .num_items = 4,
3995                 .items = {
3996                         { "Mic/Line", 0x0 },
3997                         { "CD", 0x4 },
3998                         { "Headphone", 0x2 },
3999                         { "Mixer", 0x5 },
4000                 },
4001         },
4002
4003 };
4004
4005 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4006  * the Fujitsu S702x, but jacks are marked differently.
4007  */
4008 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4009         {
4010                 .num_items = 4,
4011                 .items = {
4012                         { "Mic", 0x0 },
4013                         { "Line", 0x2 },
4014                         { "CD", 0x4 },
4015                         { "Headphone", 0x5 },
4016                 },
4017         },
4018         {
4019                 .num_items = 5,
4020                 .items = {
4021                         { "Mic", 0x0 },
4022                         { "Line", 0x2 },
4023                         { "CD", 0x4 },
4024                         { "Headphone", 0x6 },
4025                         { "Mixer", 0x5 },
4026                 },
4027         },
4028 };
4029 /*
4030  * This is just place-holder, so there's something for alc_build_pcms to look
4031  * at when it calculates the maximum number of channels. ALC260 has no mixer
4032  * element which allows changing the channel mode, so the verb list is
4033  * never used.
4034  */
4035 static struct hda_channel_mode alc260_modes[1] = {
4036         { 2, NULL },
4037 };
4038
4039
4040 /* Mixer combinations
4041  *
4042  * basic: base_output + input + pc_beep + capture
4043  * HP: base_output + input + capture_alt
4044  * HP_3013: hp_3013 + input + capture
4045  * fujitsu: fujitsu + capture
4046  * acer: acer + capture
4047  */
4048
4049 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4050         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4051         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4052         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4053         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4054         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4055         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4056         { } /* end */
4057 };
4058
4059 static struct snd_kcontrol_new alc260_input_mixer[] = {
4060         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4061         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4062         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4063         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4064         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4065         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4066         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4067         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4068         { } /* end */
4069 };
4070
4071 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4072         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4073         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4074         { } /* end */
4075 };
4076
4077 /* update HP, line and mono out pins according to the master switch */
4078 static void alc260_hp_master_update(struct hda_codec *codec,
4079                                     hda_nid_t hp, hda_nid_t line,
4080                                     hda_nid_t mono)
4081 {
4082         struct alc_spec *spec = codec->spec;
4083         unsigned int val = spec->master_sw ? PIN_HP : 0;
4084         /* change HP and line-out pins */
4085         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4086                             val);
4087         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4088                             val);
4089         /* mono (speaker) depending on the HP jack sense */
4090         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4091         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4092                             val);
4093 }
4094
4095 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4096                                    struct snd_ctl_elem_value *ucontrol)
4097 {
4098         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4099         struct alc_spec *spec = codec->spec;
4100         *ucontrol->value.integer.value = spec->master_sw;
4101         return 0;
4102 }
4103
4104 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4105                                    struct snd_ctl_elem_value *ucontrol)
4106 {
4107         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4108         struct alc_spec *spec = codec->spec;
4109         int val = !!*ucontrol->value.integer.value;
4110         hda_nid_t hp, line, mono;
4111
4112         if (val == spec->master_sw)
4113                 return 0;
4114         spec->master_sw = val;
4115         hp = (kcontrol->private_value >> 16) & 0xff;
4116         line = (kcontrol->private_value >> 8) & 0xff;
4117         mono = kcontrol->private_value & 0xff;
4118         alc260_hp_master_update(codec, hp, line, mono);
4119         return 1;
4120 }
4121
4122 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4123         {
4124                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4125                 .name = "Master Playback Switch",
4126                 .info = snd_ctl_boolean_mono_info,
4127                 .get = alc260_hp_master_sw_get,
4128                 .put = alc260_hp_master_sw_put,
4129                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4130         },
4131         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4132         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4133         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4134         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4135         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4136                               HDA_OUTPUT),
4137         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4138         { } /* end */
4139 };
4140
4141 static struct hda_verb alc260_hp_unsol_verbs[] = {
4142         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4143         {},
4144 };
4145
4146 static void alc260_hp_automute(struct hda_codec *codec)
4147 {
4148         struct alc_spec *spec = codec->spec;
4149         unsigned int present;
4150
4151         present = snd_hda_codec_read(codec, 0x10, 0,
4152                                      AC_VERB_GET_PIN_SENSE, 0);
4153         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4154         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4155 }
4156
4157 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4158 {
4159         if ((res >> 26) == ALC880_HP_EVENT)
4160                 alc260_hp_automute(codec);
4161 }
4162
4163 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4164         {
4165                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4166                 .name = "Master Playback Switch",
4167                 .info = snd_ctl_boolean_mono_info,
4168                 .get = alc260_hp_master_sw_get,
4169                 .put = alc260_hp_master_sw_put,
4170                 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
4171         },
4172         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4173         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4174         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4175         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4176         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4177         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4178         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4179         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4180         { } /* end */
4181 };
4182
4183 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4184         .ops = &snd_hda_bind_vol,
4185         .values = {
4186                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4187                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4188                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4189                 0
4190         },
4191 };
4192
4193 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4194         .ops = &snd_hda_bind_sw,
4195         .values = {
4196                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4197                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4198                 0
4199         },
4200 };
4201
4202 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4203         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4204         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4205         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4206         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4207         { } /* end */
4208 };
4209
4210 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4211         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4212         {},
4213 };
4214
4215 static void alc260_hp_3013_automute(struct hda_codec *codec)
4216 {
4217         struct alc_spec *spec = codec->spec;
4218         unsigned int present;
4219
4220         present = snd_hda_codec_read(codec, 0x15, 0,
4221                                      AC_VERB_GET_PIN_SENSE, 0);
4222         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4223         alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
4224 }
4225
4226 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4227                                        unsigned int res)
4228 {
4229         if ((res >> 26) == ALC880_HP_EVENT)
4230                 alc260_hp_3013_automute(codec);
4231 }
4232
4233 static void alc260_hp_3012_automute(struct hda_codec *codec)
4234 {
4235         unsigned int present, bits;
4236
4237         present = snd_hda_codec_read(codec, 0x10, 0,
4238                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4239
4240         bits = present ? 0 : PIN_OUT;
4241         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4242                             bits);
4243         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4244                             bits);
4245         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4246                             bits);
4247 }
4248
4249 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4250                                        unsigned int res)
4251 {
4252         if ((res >> 26) == ALC880_HP_EVENT)
4253                 alc260_hp_3012_automute(codec);
4254 }
4255
4256 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4257  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4258  */
4259 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4260         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4261         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4262         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4263         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4264         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4265         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4266         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4267         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4268         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4269         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4270         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4271         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4272         { } /* end */
4273 };
4274
4275 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4276  * versions of the ALC260 don't act on requests to enable mic bias from NID
4277  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4278  * datasheet doesn't mention this restriction.  At this stage it's not clear
4279  * whether this behaviour is intentional or is a hardware bug in chip
4280  * revisions available in early 2006.  Therefore for now allow the
4281  * "Headphone Jack Mode" control to span all choices, but if it turns out
4282  * that the lack of mic bias for this NID is intentional we could change the
4283  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4284  *
4285  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4286  * don't appear to make the mic bias available from the "line" jack, even
4287  * though the NID used for this jack (0x14) can supply it.  The theory is
4288  * that perhaps Acer have included blocking capacitors between the ALC260
4289  * and the output jack.  If this turns out to be the case for all such
4290  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4291  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4292  *
4293  * The C20x Tablet series have a mono internal speaker which is controlled
4294  * via the chip's Mono sum widget and pin complex, so include the necessary
4295  * controls for such models.  On models without a "mono speaker" the control
4296  * won't do anything.
4297  */
4298 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4299         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4300         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4301         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4302         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4303                               HDA_OUTPUT),
4304         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4305                            HDA_INPUT),
4306         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4307         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4308         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4309         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4310         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4311         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4312         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4313         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4314         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4315         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4316         { } /* end */
4317 };
4318
4319 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4320  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4321  */
4322 static struct snd_kcontrol_new alc260_will_mixer[] = {
4323         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4324         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4325         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4326         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4327         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4328         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4329         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4330         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4331         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4332         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4333         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4334         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4335         { } /* end */
4336 };
4337
4338 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4339  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4340  */
4341 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4342         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4343         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4344         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4345         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4346         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4347         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4348         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4349         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4350         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4351         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4352         { } /* end */
4353 };
4354
4355 /* capture mixer elements */
4356 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4357         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4358         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4359         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4360         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4361         {
4362                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4363                 /* The multiple "Capture Source" controls confuse alsamixer
4364                  * So call somewhat different..
4365                  */
4366                 /* .name = "Capture Source", */
4367                 .name = "Input Source",
4368                 .count = 2,
4369                 .info = alc_mux_enum_info,
4370                 .get = alc_mux_enum_get,
4371                 .put = alc_mux_enum_put,
4372         },
4373         { } /* end */
4374 };
4375
4376 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4377         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4378         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4379         {
4380                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4381                 /* The multiple "Capture Source" controls confuse alsamixer
4382                  * So call somewhat different..
4383                  */
4384                 /* .name = "Capture Source", */
4385                 .name = "Input Source",
4386                 .count = 1,
4387                 .info = alc_mux_enum_info,
4388                 .get = alc_mux_enum_get,
4389                 .put = alc_mux_enum_put,
4390         },
4391         { } /* end */
4392 };
4393
4394 /*
4395  * initialization verbs
4396  */
4397 static struct hda_verb alc260_init_verbs[] = {
4398         /* Line In pin widget for input */
4399         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4400         /* CD pin widget for input */
4401         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4402         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4403         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4404         /* Mic2 (front panel) pin widget for input and vref at 80% */
4405         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4406         /* LINE-2 is used for line-out in rear */
4407         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4408         /* select line-out */
4409         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4410         /* LINE-OUT pin */
4411         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4412         /* enable HP */
4413         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4414         /* enable Mono */
4415         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4416         /* mute capture amp left and right */
4417         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4418         /* set connection select to line in (default select for this ADC) */
4419         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4420         /* mute capture amp left and right */
4421         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4422         /* set connection select to line in (default select for this ADC) */
4423         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4424         /* set vol=0 Line-Out mixer amp left and right */
4425         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4426         /* unmute pin widget amp left and right (no gain on this amp) */
4427         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4428         /* set vol=0 HP mixer amp left and right */
4429         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4430         /* unmute pin widget amp left and right (no gain on this amp) */
4431         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4432         /* set vol=0 Mono mixer amp left and right */
4433         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4434         /* unmute pin widget amp left and right (no gain on this amp) */
4435         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4436         /* unmute LINE-2 out pin */
4437         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4438         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4439          * Line In 2 = 0x03
4440          */
4441         /* mute analog inputs */
4442         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4443         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4444         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4445         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4446         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4447         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4448         /* mute Front out path */
4449         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4450         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4451         /* mute Headphone out path */
4452         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4453         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4454         /* mute Mono out path */
4455         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4456         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4457         { }
4458 };
4459
4460 #if 0 /* should be identical with alc260_init_verbs? */
4461 static struct hda_verb alc260_hp_init_verbs[] = {
4462         /* Headphone and output */
4463         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4464         /* mono output */
4465         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4466         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4467         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4468         /* Mic2 (front panel) pin widget for input and vref at 80% */
4469         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4470         /* Line In pin widget for input */
4471         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4472         /* Line-2 pin widget for output */
4473         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4474         /* CD pin widget for input */
4475         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4476         /* unmute amp left and right */
4477         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4478         /* set connection select to line in (default select for this ADC) */
4479         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4480         /* unmute Line-Out mixer amp left and right (volume = 0) */
4481         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4482         /* mute pin widget amp left and right (no gain on this amp) */
4483         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4484         /* unmute HP mixer amp left and right (volume = 0) */
4485         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4486         /* mute pin widget amp left and right (no gain on this amp) */
4487         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4488         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4489          * Line In 2 = 0x03
4490          */
4491         /* mute analog inputs */
4492         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4493         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4494         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4495         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4496         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4497         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4498         /* Unmute Front out path */
4499         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4500         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4501         /* Unmute Headphone out path */
4502         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4503         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4504         /* Unmute Mono out path */
4505         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4506         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4507         { }
4508 };
4509 #endif
4510
4511 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4512         /* Line out and output */
4513         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4514         /* mono output */
4515         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4516         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4517         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4518         /* Mic2 (front panel) pin widget for input and vref at 80% */
4519         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4520         /* Line In pin widget for input */
4521         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4522         /* Headphone pin widget for output */
4523         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4524         /* CD pin widget for input */
4525         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4526         /* unmute amp left and right */
4527         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4528         /* set connection select to line in (default select for this ADC) */
4529         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4530         /* unmute Line-Out mixer amp left and right (volume = 0) */
4531         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4532         /* mute pin widget amp left and right (no gain on this amp) */
4533         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4534         /* unmute HP mixer amp left and right (volume = 0) */
4535         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4536         /* mute pin widget amp left and right (no gain on this amp) */
4537         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4538         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4539          * Line In 2 = 0x03
4540          */
4541         /* mute analog inputs */
4542         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4547         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4548         /* Unmute Front out path */
4549         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4550         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4551         /* Unmute Headphone out path */
4552         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4553         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4554         /* Unmute Mono out path */
4555         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4556         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4557         { }
4558 };
4559
4560 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4561  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4562  * audio = 0x16, internal speaker = 0x10.
4563  */
4564 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4565         /* Disable all GPIOs */
4566         {0x01, AC_VERB_SET_GPIO_MASK, 0},
4567         /* Internal speaker is connected to headphone pin */
4568         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4569         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4570         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4571         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4572         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4573         /* Ensure all other unused pins are disabled and muted. */
4574         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4575         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4576         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4577         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4578         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4579         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4580         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4581         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4582
4583         /* Disable digital (SPDIF) pins */
4584         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4585         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4586
4587         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4588          * when acting as an output.
4589          */
4590         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4591
4592         /* Start with output sum widgets muted and their output gains at min */
4593         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4594         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4595         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4596         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4597         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4598         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4599         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4600         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4601         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4602
4603         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4604         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4605         /* Unmute Line1 pin widget output buffer since it starts as an output.
4606          * If the pin mode is changed by the user the pin mode control will
4607          * take care of enabling the pin's input/output buffers as needed.
4608          * Therefore there's no need to enable the input buffer at this
4609          * stage.
4610          */
4611         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4612         /* Unmute input buffer of pin widget used for Line-in (no equiv
4613          * mixer ctrl)
4614          */
4615         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4616
4617         /* Mute capture amp left and right */
4618         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4619         /* Set ADC connection select to match default mixer setting - line
4620          * in (on mic1 pin)
4621          */
4622         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4623
4624         /* Do the same for the second ADC: mute capture input amp and
4625          * set ADC connection to line in (on mic1 pin)
4626          */
4627         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4628         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4629
4630         /* Mute all inputs to mixer widget (even unconnected ones) */
4631         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4632         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4633         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4634         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4635         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4636         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4637         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4638         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4639
4640         { }
4641 };
4642
4643 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4644  * similar laptops (adapted from Fujitsu init verbs).
4645  */
4646 static struct hda_verb alc260_acer_init_verbs[] = {
4647         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4648          * the headphone jack.  Turn this on and rely on the standard mute
4649          * methods whenever the user wants to turn these outputs off.
4650          */
4651         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4652         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4653         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4654         /* Internal speaker/Headphone jack is connected to Line-out pin */
4655         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4656         /* Internal microphone/Mic jack is connected to Mic1 pin */
4657         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4658         /* Line In jack is connected to Line1 pin */
4659         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4660         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4661         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4662         /* Ensure all other unused pins are disabled and muted. */
4663         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4664         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4665         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4666         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4667         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4668         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4669         /* Disable digital (SPDIF) pins */
4670         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4671         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4672
4673         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4674          * bus when acting as outputs.
4675          */
4676         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4677         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4678
4679         /* Start with output sum widgets muted and their output gains at min */
4680         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4681         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4682         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4683         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4684         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4685         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4686         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4687         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4688         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4689
4690         /* Unmute Line-out pin widget amp left and right
4691          * (no equiv mixer ctrl)
4692          */
4693         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4694         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4695         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4696         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4697          * inputs. If the pin mode is changed by the user the pin mode control
4698          * will take care of enabling the pin's input/output buffers as needed.
4699          * Therefore there's no need to enable the input buffer at this
4700          * stage.
4701          */
4702         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4703         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4704
4705         /* Mute capture amp left and right */
4706         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4707         /* Set ADC connection select to match default mixer setting - mic
4708          * (on mic1 pin)
4709          */
4710         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4711
4712         /* Do similar with the second ADC: mute capture input amp and
4713          * set ADC connection to mic to match ALSA's default state.
4714          */
4715         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4716         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4717
4718         /* Mute all inputs to mixer widget (even unconnected ones) */
4719         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4720         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4721         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4722         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4723         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4724         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4725         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4726         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4727
4728         { }
4729 };
4730
4731 static struct hda_verb alc260_will_verbs[] = {
4732         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4733         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4734         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4735         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4736         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4737         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4738         {}
4739 };
4740
4741 static struct hda_verb alc260_replacer_672v_verbs[] = {
4742         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4743         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4744         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4745
4746         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4747         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4748         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4749
4750         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4751         {}
4752 };
4753
4754 /* toggle speaker-output according to the hp-jack state */
4755 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4756 {
4757         unsigned int present;
4758
4759         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4760         present = snd_hda_codec_read(codec, 0x0f, 0,
4761                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4762         if (present) {
4763                 snd_hda_codec_write_cache(codec, 0x01, 0,
4764                                           AC_VERB_SET_GPIO_DATA, 1);
4765                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4766                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4767                                           PIN_HP);
4768         } else {
4769                 snd_hda_codec_write_cache(codec, 0x01, 0,
4770                                           AC_VERB_SET_GPIO_DATA, 0);
4771                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4772                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4773                                           PIN_OUT);
4774         }
4775 }
4776
4777 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4778                                        unsigned int res)
4779 {
4780         if ((res >> 26) == ALC880_HP_EVENT)
4781                 alc260_replacer_672v_automute(codec);
4782 }
4783
4784 static struct hda_verb alc260_hp_dc7600_verbs[] = {
4785         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
4786         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4787         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4788         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4789         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4790         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4791         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4792         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4793         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4794         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4795         {}
4796 };
4797
4798 /* Test configuration for debugging, modelled after the ALC880 test
4799  * configuration.
4800  */
4801 #ifdef CONFIG_SND_DEBUG
4802 static hda_nid_t alc260_test_dac_nids[1] = {
4803         0x02,
4804 };
4805 static hda_nid_t alc260_test_adc_nids[2] = {
4806         0x04, 0x05,
4807 };
4808 /* For testing the ALC260, each input MUX needs its own definition since
4809  * the signal assignments are different.  This assumes that the first ADC
4810  * is NID 0x04.
4811  */
4812 static struct hda_input_mux alc260_test_capture_sources[2] = {
4813         {
4814                 .num_items = 7,
4815                 .items = {
4816                         { "MIC1 pin", 0x0 },
4817                         { "MIC2 pin", 0x1 },
4818                         { "LINE1 pin", 0x2 },
4819                         { "LINE2 pin", 0x3 },
4820                         { "CD pin", 0x4 },
4821                         { "LINE-OUT pin", 0x5 },
4822                         { "HP-OUT pin", 0x6 },
4823                 },
4824         },
4825         {
4826                 .num_items = 8,
4827                 .items = {
4828                         { "MIC1 pin", 0x0 },
4829                         { "MIC2 pin", 0x1 },
4830                         { "LINE1 pin", 0x2 },
4831                         { "LINE2 pin", 0x3 },
4832                         { "CD pin", 0x4 },
4833                         { "Mixer", 0x5 },
4834                         { "LINE-OUT pin", 0x6 },
4835                         { "HP-OUT pin", 0x7 },
4836                 },
4837         },
4838 };
4839 static struct snd_kcontrol_new alc260_test_mixer[] = {
4840         /* Output driver widgets */
4841         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4842         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4843         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4844         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4845         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4846         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4847
4848         /* Modes for retasking pin widgets
4849          * Note: the ALC260 doesn't seem to act on requests to enable mic
4850          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
4851          * mention this restriction.  At this stage it's not clear whether
4852          * this behaviour is intentional or is a hardware bug in chip
4853          * revisions available at least up until early 2006.  Therefore for
4854          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4855          * choices, but if it turns out that the lack of mic bias for these
4856          * NIDs is intentional we could change their modes from
4857          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4858          */
4859         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4860         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4861         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4862         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4863         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4864         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4865
4866         /* Loopback mixer controls */
4867         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4868         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4869         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4870         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4871         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4872         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4873         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4874         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4875         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4876         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4877         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4878         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4879         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4880         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4881         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4882         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4883
4884         /* Controls for GPIO pins, assuming they are configured as outputs */
4885         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4886         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4887         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4888         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4889
4890         /* Switches to allow the digital IO pins to be enabled.  The datasheet
4891          * is ambigious as to which NID is which; testing on laptops which
4892          * make this output available should provide clarification.
4893          */
4894         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4895         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4896
4897         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
4898          * this output to turn on an external amplifier.
4899          */
4900         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4901         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4902
4903         { } /* end */
4904 };
4905 static struct hda_verb alc260_test_init_verbs[] = {
4906         /* Enable all GPIOs as outputs with an initial value of 0 */
4907         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4908         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4909         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4910
4911         /* Enable retasking pins as output, initially without power amp */
4912         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4913         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4914         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4915         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4916         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4917         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4918
4919         /* Disable digital (SPDIF) pins initially, but users can enable
4920          * them via a mixer switch.  In the case of SPDIF-out, this initverb
4921          * payload also sets the generation to 0, output to be in "consumer"
4922          * PCM format, copyright asserted, no pre-emphasis and no validity
4923          * control.
4924          */
4925         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4926         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4927
4928         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
4929          * OUT1 sum bus when acting as an output.
4930          */
4931         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4932         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
4933         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4934         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
4935
4936         /* Start with output sum widgets muted and their output gains at min */
4937         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4938         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4939         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4940         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4941         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4942         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4943         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4944         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4945         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4946
4947         /* Unmute retasking pin widget output buffers since the default
4948          * state appears to be output.  As the pin mode is changed by the
4949          * user the pin mode control will take care of enabling the pin's
4950          * input/output buffers as needed.
4951          */
4952         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4953         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4954         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4955         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4956         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4957         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4958         /* Also unmute the mono-out pin widget */
4959         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4960
4961         /* Mute capture amp left and right */
4962         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4963         /* Set ADC connection select to match default mixer setting (mic1
4964          * pin)
4965          */
4966         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4967
4968         /* Do the same for the second ADC: mute capture input amp and
4969          * set ADC connection to mic1 pin
4970          */
4971         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4972         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4973
4974         /* Mute all inputs to mixer widget (even unconnected ones) */
4975         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4976         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4977         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4978         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4979         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4980         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4981         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4982         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4983
4984         { }
4985 };
4986 #endif
4987
4988 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
4989 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
4990
4991 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
4992 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
4993
4994 /*
4995  * for BIOS auto-configuration
4996  */
4997
4998 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
4999                                         const char *pfx)
5000 {
5001         hda_nid_t nid_vol;
5002         unsigned long vol_val, sw_val;
5003         char name[32];
5004         int err;
5005
5006         if (nid >= 0x0f && nid < 0x11) {
5007                 nid_vol = nid - 0x7;
5008                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5009                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5010         } else if (nid == 0x11) {
5011                 nid_vol = nid - 0x7;
5012                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5013                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5014         } else if (nid >= 0x12 && nid <= 0x15) {
5015                 nid_vol = 0x08;
5016                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5017                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5018         } else
5019                 return 0; /* N/A */
5020
5021         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5022         err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5023         if (err < 0)
5024                 return err;
5025         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5026         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5027         if (err < 0)
5028                 return err;
5029         return 1;
5030 }
5031
5032 /* add playback controls from the parsed DAC table */
5033 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5034                                              const struct auto_pin_cfg *cfg)
5035 {
5036         hda_nid_t nid;
5037         int err;
5038
5039         spec->multiout.num_dacs = 1;
5040         spec->multiout.dac_nids = spec->private_dac_nids;
5041         spec->multiout.dac_nids[0] = 0x02;
5042
5043         nid = cfg->line_out_pins[0];
5044         if (nid) {
5045                 err = alc260_add_playback_controls(spec, nid, "Front");
5046                 if (err < 0)
5047                         return err;
5048         }
5049
5050         nid = cfg->speaker_pins[0];
5051         if (nid) {
5052                 err = alc260_add_playback_controls(spec, nid, "Speaker");
5053                 if (err < 0)
5054                         return err;
5055         }
5056
5057         nid = cfg->hp_pins[0];
5058         if (nid) {
5059                 err = alc260_add_playback_controls(spec, nid, "Headphone");
5060                 if (err < 0)
5061                         return err;
5062         }
5063         return 0;
5064 }
5065
5066 /* create playback/capture controls for input pins */
5067 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5068                                                 const struct auto_pin_cfg *cfg)
5069 {
5070         struct hda_input_mux *imux = &spec->private_imux;
5071         int i, err, idx;
5072
5073         for (i = 0; i < AUTO_PIN_LAST; i++) {
5074                 if (cfg->input_pins[i] >= 0x12) {
5075                         idx = cfg->input_pins[i] - 0x12;
5076                         err = new_analog_input(spec, cfg->input_pins[i],
5077                                                auto_pin_cfg_labels[i], idx,
5078                                                0x07);
5079                         if (err < 0)
5080                                 return err;
5081                         imux->items[imux->num_items].label =
5082                                 auto_pin_cfg_labels[i];
5083                         imux->items[imux->num_items].index = idx;
5084                         imux->num_items++;
5085                 }
5086                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5087                         idx = cfg->input_pins[i] - 0x09;
5088                         err = new_analog_input(spec, cfg->input_pins[i],
5089                                                auto_pin_cfg_labels[i], idx,
5090                                                0x07);
5091                         if (err < 0)
5092                                 return err;
5093                         imux->items[imux->num_items].label =
5094                                 auto_pin_cfg_labels[i];
5095                         imux->items[imux->num_items].index = idx;
5096                         imux->num_items++;
5097                 }
5098         }
5099         return 0;
5100 }
5101
5102 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5103                                               hda_nid_t nid, int pin_type,
5104                                               int sel_idx)
5105 {
5106         alc_set_pin_output(codec, nid, pin_type);
5107         /* need the manual connection? */
5108         if (nid >= 0x12) {
5109                 int idx = nid - 0x12;
5110                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5111                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5112         }
5113 }
5114
5115 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5116 {
5117         struct alc_spec *spec = codec->spec;
5118         hda_nid_t nid;
5119
5120         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5121         nid = spec->autocfg.line_out_pins[0];
5122         if (nid) {
5123                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5124                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5125         }
5126
5127         nid = spec->autocfg.speaker_pins[0];
5128         if (nid)
5129                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5130
5131         nid = spec->autocfg.hp_pins[0];
5132         if (nid)
5133                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5134 }
5135
5136 #define ALC260_PIN_CD_NID               0x16
5137 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5138 {
5139         struct alc_spec *spec = codec->spec;
5140         int i;
5141
5142         for (i = 0; i < AUTO_PIN_LAST; i++) {
5143                 hda_nid_t nid = spec->autocfg.input_pins[i];
5144                 if (nid >= 0x12) {
5145                         snd_hda_codec_write(codec, nid, 0,
5146                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
5147                                             i <= AUTO_PIN_FRONT_MIC ?
5148                                             PIN_VREF80 : PIN_IN);
5149                         if (nid != ALC260_PIN_CD_NID)
5150                                 snd_hda_codec_write(codec, nid, 0,
5151                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5152                                                     AMP_OUT_MUTE);
5153                 }
5154         }
5155 }
5156
5157 /*
5158  * generic initialization of ADC, input mixers and output mixers
5159  */
5160 static struct hda_verb alc260_volume_init_verbs[] = {
5161         /*
5162          * Unmute ADC0-1 and set the default input to mic-in
5163          */
5164         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5165         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5166         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5167         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5168
5169         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5170          * mixer widget
5171          * Note: PASD motherboards uses the Line In 2 as the input for
5172          * front panel mic (mic 2)
5173          */
5174         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5175         /* mute analog inputs */
5176         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5177         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5178         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5179         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5180         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5181
5182         /*
5183          * Set up output mixers (0x08 - 0x0a)
5184          */
5185         /* set vol=0 to output mixers */
5186         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5187         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5188         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5189         /* set up input amps for analog loopback */
5190         /* Amp Indices: DAC = 0, mixer = 1 */
5191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5192         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5193         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5194         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5195         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5196         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5197
5198         { }
5199 };
5200
5201 static int alc260_parse_auto_config(struct hda_codec *codec)
5202 {
5203         struct alc_spec *spec = codec->spec;
5204         unsigned int wcap;
5205         int err;
5206         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5207
5208         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5209                                            alc260_ignore);
5210         if (err < 0)
5211                 return err;
5212         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5213         if (err < 0)
5214                 return err;
5215         if (!spec->kctl_alloc)
5216                 return 0; /* can't find valid BIOS pin config */
5217         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5218         if (err < 0)
5219                 return err;
5220
5221         spec->multiout.max_channels = 2;
5222
5223         if (spec->autocfg.dig_out_pin)
5224                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5225         if (spec->kctl_alloc)
5226                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5227
5228         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
5229
5230         spec->num_mux_defs = 1;
5231         spec->input_mux = &spec->private_imux;
5232
5233         /* check whether NID 0x04 is valid */
5234         wcap = get_wcaps(codec, 0x04);
5235         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5236         if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5237                 spec->adc_nids = alc260_adc_nids_alt;
5238                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5239                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
5240         } else {
5241                 spec->adc_nids = alc260_adc_nids;
5242                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5243                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
5244         }
5245         spec->num_mixers++;
5246
5247         return 1;
5248 }
5249
5250 /* additional initialization for auto-configuration model */
5251 static void alc260_auto_init(struct hda_codec *codec)
5252 {
5253         struct alc_spec *spec = codec->spec;
5254         alc260_auto_init_multi_out(codec);
5255         alc260_auto_init_analog_input(codec);
5256         if (spec->unsol_event)
5257                 alc_inithook(codec);
5258 }
5259
5260 #ifdef CONFIG_SND_HDA_POWER_SAVE
5261 static struct hda_amp_list alc260_loopbacks[] = {
5262         { 0x07, HDA_INPUT, 0 },
5263         { 0x07, HDA_INPUT, 1 },
5264         { 0x07, HDA_INPUT, 2 },
5265         { 0x07, HDA_INPUT, 3 },
5266         { 0x07, HDA_INPUT, 4 },
5267         { } /* end */
5268 };
5269 #endif
5270
5271 /*
5272  * ALC260 configurations
5273  */
5274 static const char *alc260_models[ALC260_MODEL_LAST] = {
5275         [ALC260_BASIC]          = "basic",
5276         [ALC260_HP]             = "hp",
5277         [ALC260_HP_3013]        = "hp-3013",
5278         [ALC260_HP_DC7600]      = "hp-dc7600",
5279         [ALC260_FUJITSU_S702X]  = "fujitsu",
5280         [ALC260_ACER]           = "acer",
5281         [ALC260_WILL]           = "will",
5282         [ALC260_REPLACER_672V]  = "replacer",
5283 #ifdef CONFIG_SND_DEBUG
5284         [ALC260_TEST]           = "test",
5285 #endif
5286         [ALC260_AUTO]           = "auto",
5287 };
5288
5289 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5290         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5291         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5292         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5293         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5294         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5295         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5296         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5297         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5298         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5299         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5300         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5301         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5302         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5303         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5304         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5305         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5306         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5307         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5308         {}
5309 };
5310
5311 static struct alc_config_preset alc260_presets[] = {
5312         [ALC260_BASIC] = {
5313                 .mixers = { alc260_base_output_mixer,
5314                             alc260_input_mixer,
5315                             alc260_pc_beep_mixer,
5316                             alc260_capture_mixer },
5317                 .init_verbs = { alc260_init_verbs },
5318                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5319                 .dac_nids = alc260_dac_nids,
5320                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5321                 .adc_nids = alc260_adc_nids,
5322                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5323                 .channel_mode = alc260_modes,
5324                 .input_mux = &alc260_capture_source,
5325         },
5326         [ALC260_HP] = {
5327                 .mixers = { alc260_hp_output_mixer,
5328                             alc260_input_mixer,
5329                             alc260_capture_alt_mixer },
5330                 .init_verbs = { alc260_init_verbs,
5331                                 alc260_hp_unsol_verbs },
5332                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5333                 .dac_nids = alc260_dac_nids,
5334                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5335                 .adc_nids = alc260_hp_adc_nids,
5336                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5337                 .channel_mode = alc260_modes,
5338                 .input_mux = &alc260_capture_source,
5339                 .unsol_event = alc260_hp_unsol_event,
5340                 .init_hook = alc260_hp_automute,
5341         },
5342         [ALC260_HP_DC7600] = {
5343                 .mixers = { alc260_hp_dc7600_mixer,
5344                             alc260_input_mixer,
5345                             alc260_capture_alt_mixer },
5346                 .init_verbs = { alc260_init_verbs,
5347                                 alc260_hp_dc7600_verbs },
5348                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5349                 .dac_nids = alc260_dac_nids,
5350                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5351                 .adc_nids = alc260_hp_adc_nids,
5352                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5353                 .channel_mode = alc260_modes,
5354                 .input_mux = &alc260_capture_source,
5355                 .unsol_event = alc260_hp_3012_unsol_event,
5356                 .init_hook = alc260_hp_3012_automute,
5357         },
5358         [ALC260_HP_3013] = {
5359                 .mixers = { alc260_hp_3013_mixer,
5360                             alc260_input_mixer,
5361                             alc260_capture_alt_mixer },
5362                 .init_verbs = { alc260_hp_3013_init_verbs,
5363                                 alc260_hp_3013_unsol_verbs },
5364                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5365                 .dac_nids = alc260_dac_nids,
5366                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5367                 .adc_nids = alc260_hp_adc_nids,
5368                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5369                 .channel_mode = alc260_modes,
5370                 .input_mux = &alc260_capture_source,
5371                 .unsol_event = alc260_hp_3013_unsol_event,
5372                 .init_hook = alc260_hp_3013_automute,
5373         },
5374         [ALC260_FUJITSU_S702X] = {
5375                 .mixers = { alc260_fujitsu_mixer,
5376                             alc260_capture_mixer },
5377                 .init_verbs = { alc260_fujitsu_init_verbs },
5378                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5379                 .dac_nids = alc260_dac_nids,
5380                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5381                 .adc_nids = alc260_dual_adc_nids,
5382                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5383                 .channel_mode = alc260_modes,
5384                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5385                 .input_mux = alc260_fujitsu_capture_sources,
5386         },
5387         [ALC260_ACER] = {
5388                 .mixers = { alc260_acer_mixer,
5389                             alc260_capture_mixer },
5390                 .init_verbs = { alc260_acer_init_verbs },
5391                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5392                 .dac_nids = alc260_dac_nids,
5393                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5394                 .adc_nids = alc260_dual_adc_nids,
5395                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5396                 .channel_mode = alc260_modes,
5397                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5398                 .input_mux = alc260_acer_capture_sources,
5399         },
5400         [ALC260_WILL] = {
5401                 .mixers = { alc260_will_mixer,
5402                             alc260_capture_mixer },
5403                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5404                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5405                 .dac_nids = alc260_dac_nids,
5406                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5407                 .adc_nids = alc260_adc_nids,
5408                 .dig_out_nid = ALC260_DIGOUT_NID,
5409                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5410                 .channel_mode = alc260_modes,
5411                 .input_mux = &alc260_capture_source,
5412         },
5413         [ALC260_REPLACER_672V] = {
5414                 .mixers = { alc260_replacer_672v_mixer,
5415                             alc260_capture_mixer },
5416                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5417                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5418                 .dac_nids = alc260_dac_nids,
5419                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5420                 .adc_nids = alc260_adc_nids,
5421                 .dig_out_nid = ALC260_DIGOUT_NID,
5422                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5423                 .channel_mode = alc260_modes,
5424                 .input_mux = &alc260_capture_source,
5425                 .unsol_event = alc260_replacer_672v_unsol_event,
5426                 .init_hook = alc260_replacer_672v_automute,
5427         },
5428 #ifdef CONFIG_SND_DEBUG
5429         [ALC260_TEST] = {
5430                 .mixers = { alc260_test_mixer,
5431                             alc260_capture_mixer },
5432                 .init_verbs = { alc260_test_init_verbs },
5433                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5434                 .dac_nids = alc260_test_dac_nids,
5435                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5436                 .adc_nids = alc260_test_adc_nids,
5437                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5438                 .channel_mode = alc260_modes,
5439                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5440                 .input_mux = alc260_test_capture_sources,
5441         },
5442 #endif
5443 };
5444
5445 static int patch_alc260(struct hda_codec *codec)
5446 {
5447         struct alc_spec *spec;
5448         int err, board_config;
5449
5450         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5451         if (spec == NULL)
5452                 return -ENOMEM;
5453
5454         codec->spec = spec;
5455
5456         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5457                                                   alc260_models,
5458                                                   alc260_cfg_tbl);
5459         if (board_config < 0) {
5460                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5461                            "trying auto-probe from BIOS...\n");
5462                 board_config = ALC260_AUTO;
5463         }
5464
5465         if (board_config == ALC260_AUTO) {
5466                 /* automatic parse from the BIOS config */
5467                 err = alc260_parse_auto_config(codec);
5468                 if (err < 0) {
5469                         alc_free(codec);
5470                         return err;
5471                 } else if (!err) {
5472                         printk(KERN_INFO
5473                                "hda_codec: Cannot set up configuration "
5474                                "from BIOS.  Using base mode...\n");
5475                         board_config = ALC260_BASIC;
5476                 }
5477         }
5478
5479         if (board_config != ALC260_AUTO)
5480                 setup_preset(spec, &alc260_presets[board_config]);
5481
5482         spec->stream_name_analog = "ALC260 Analog";
5483         spec->stream_analog_playback = &alc260_pcm_analog_playback;
5484         spec->stream_analog_capture = &alc260_pcm_analog_capture;
5485
5486         spec->stream_name_digital = "ALC260 Digital";
5487         spec->stream_digital_playback = &alc260_pcm_digital_playback;
5488         spec->stream_digital_capture = &alc260_pcm_digital_capture;
5489
5490         spec->vmaster_nid = 0x08;
5491
5492         codec->patch_ops = alc_patch_ops;
5493         if (board_config == ALC260_AUTO)
5494                 spec->init_hook = alc260_auto_init;
5495 #ifdef CONFIG_SND_HDA_POWER_SAVE
5496         if (!spec->loopback.amplist)
5497                 spec->loopback.amplist = alc260_loopbacks;
5498 #endif
5499
5500         return 0;
5501 }
5502
5503
5504 /*
5505  * ALC882 support
5506  *
5507  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5508  * configuration.  Each pin widget can choose any input DACs and a mixer.
5509  * Each ADC is connected from a mixer of all inputs.  This makes possible
5510  * 6-channel independent captures.
5511  *
5512  * In addition, an independent DAC for the multi-playback (not used in this
5513  * driver yet).
5514  */
5515 #define ALC882_DIGOUT_NID       0x06
5516 #define ALC882_DIGIN_NID        0x0a
5517
5518 static struct hda_channel_mode alc882_ch_modes[1] = {
5519         { 8, NULL }
5520 };
5521
5522 static hda_nid_t alc882_dac_nids[4] = {
5523         /* front, rear, clfe, rear_surr */
5524         0x02, 0x03, 0x04, 0x05
5525 };
5526
5527 /* identical with ALC880 */
5528 #define alc882_adc_nids         alc880_adc_nids
5529 #define alc882_adc_nids_alt     alc880_adc_nids_alt
5530
5531 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5532 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5533
5534 /* input MUX */
5535 /* FIXME: should be a matrix-type input source selection */
5536
5537 static struct hda_input_mux alc882_capture_source = {
5538         .num_items = 4,
5539         .items = {
5540                 { "Mic", 0x0 },
5541                 { "Front Mic", 0x1 },
5542                 { "Line", 0x2 },
5543                 { "CD", 0x4 },
5544         },
5545 };
5546 #define alc882_mux_enum_info alc_mux_enum_info
5547 #define alc882_mux_enum_get alc_mux_enum_get
5548
5549 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5550                                struct snd_ctl_elem_value *ucontrol)
5551 {
5552         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5553         struct alc_spec *spec = codec->spec;
5554         const struct hda_input_mux *imux = spec->input_mux;
5555         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5556         hda_nid_t nid = spec->capsrc_nids ?
5557                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
5558         unsigned int *cur_val = &spec->cur_mux[adc_idx];
5559         unsigned int i, idx;
5560
5561         idx = ucontrol->value.enumerated.item[0];
5562         if (idx >= imux->num_items)
5563                 idx = imux->num_items - 1;
5564         if (*cur_val == idx)
5565                 return 0;
5566         for (i = 0; i < imux->num_items; i++) {
5567                 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5568                 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5569                                          imux->items[i].index,
5570                                          HDA_AMP_MUTE, v);
5571         }
5572         *cur_val = idx;
5573         return 1;
5574 }
5575
5576 /*
5577  * 2ch mode
5578  */
5579 static struct hda_verb alc882_3ST_ch2_init[] = {
5580         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5581         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5582         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5583         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5584         { } /* end */
5585 };
5586
5587 /*
5588  * 6ch mode
5589  */
5590 static struct hda_verb alc882_3ST_ch6_init[] = {
5591         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5592         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5593         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5594         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5595         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5596         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5597         { } /* end */
5598 };
5599
5600 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5601         { 2, alc882_3ST_ch2_init },
5602         { 6, alc882_3ST_ch6_init },
5603 };
5604
5605 /*
5606  * 6ch mode
5607  */
5608 static struct hda_verb alc882_sixstack_ch6_init[] = {
5609         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5610         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5611         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5612         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5613         { } /* end */
5614 };
5615
5616 /*
5617  * 8ch mode
5618  */
5619 static struct hda_verb alc882_sixstack_ch8_init[] = {
5620         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5621         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5622         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5623         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5624         { } /* end */
5625 };
5626
5627 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5628         { 6, alc882_sixstack_ch6_init },
5629         { 8, alc882_sixstack_ch8_init },
5630 };
5631
5632 /*
5633  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5634  */
5635
5636 /*
5637  * 2ch mode
5638  */
5639 static struct hda_verb alc885_mbp_ch2_init[] = {
5640         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5641         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5642         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5643         { } /* end */
5644 };
5645
5646 /*
5647  * 6ch mode
5648  */
5649 static struct hda_verb alc885_mbp_ch6_init[] = {
5650         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5651         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5652         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5653         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5654         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5655         { } /* end */
5656 };
5657
5658 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5659         { 2, alc885_mbp_ch2_init },
5660         { 6, alc885_mbp_ch6_init },
5661 };
5662
5663
5664 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5665  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5666  */
5667 static struct snd_kcontrol_new alc882_base_mixer[] = {
5668         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5669         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5670         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5671         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5672         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5673         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5674         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5675         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5676         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5677         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5678         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5679         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5680         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5681         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5682         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5683         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5684         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5685         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5686         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5687         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5688         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5689         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5690         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5691         { } /* end */
5692 };
5693
5694 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5695         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5696         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5697         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5698         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5699         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5700         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5701         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5702         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5703         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5704         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5705         { } /* end */
5706 };
5707 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5708         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5709         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5710         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5711         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5712         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5713         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5714         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5715         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5716         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5717         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5718         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5719         { } /* end */
5720 };
5721
5722 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5723         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5724         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5725         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5726         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5727         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5728         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5729         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5730         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5731         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5732         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5733         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5734         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5735         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5736         { } /* end */
5737 };
5738
5739 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5740  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5741  */
5742 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5743         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5744         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5745         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5746         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5747         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5748         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5749         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5750         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5751         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5752         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5753         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5754         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5755         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5756         { } /* end */
5757 };
5758
5759 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5760         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5761         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5762         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5763         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5764         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5765         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5766         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5767         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5768         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5769         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5770         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5771         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5772         { } /* end */
5773 };
5774
5775 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5776         {
5777                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5778                 .name = "Channel Mode",
5779                 .info = alc_ch_mode_info,
5780                 .get = alc_ch_mode_get,
5781                 .put = alc_ch_mode_put,
5782         },
5783         { } /* end */
5784 };
5785
5786 static struct hda_verb alc882_init_verbs[] = {
5787         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5788         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5789         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5790         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5791         /* Rear mixer */
5792         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5793         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5794         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5795         /* CLFE mixer */
5796         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5797         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5798         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5799         /* Side mixer */
5800         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5801         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5802         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5803
5804         /* Front Pin: output 0 (0x0c) */
5805         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5806         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5807         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5808         /* Rear Pin: output 1 (0x0d) */
5809         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5810         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5811         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5812         /* CLFE Pin: output 2 (0x0e) */
5813         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5814         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5815         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5816         /* Side Pin: output 3 (0x0f) */
5817         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5818         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5819         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5820         /* Mic (rear) pin: input vref at 80% */
5821         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5822         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5823         /* Front Mic pin: input vref at 80% */
5824         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5825         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5826         /* Line In pin: input */
5827         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5828         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5829         /* Line-2 In: Headphone output (output 0 - 0x0c) */
5830         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5831         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5832         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5833         /* CD pin widget for input */
5834         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5835
5836         /* FIXME: use matrix-type input source selection */
5837         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5838         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5839         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5840         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5841         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5842         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5843         /* Input mixer2 */
5844         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5845         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5846         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5847         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5848         /* Input mixer3 */
5849         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5850         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5851         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5852         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5853         /* ADC1: mute amp left and right */
5854         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5855         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5856         /* ADC2: mute amp left and right */
5857         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5858         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5859         /* ADC3: mute amp left and right */
5860         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5861         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5862
5863         { }
5864 };
5865
5866 static struct hda_verb alc882_eapd_verbs[] = {
5867         /* change to EAPD mode */
5868         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5869         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5870         { }
5871 };
5872
5873 /* Mac Pro test */
5874 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5875         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5876         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5877         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5878         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5879         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5880         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5881         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5882         { } /* end */
5883 };
5884
5885 static struct hda_verb alc882_macpro_init_verbs[] = {
5886         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5887         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5888         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5889         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5890         /* Front Pin: output 0 (0x0c) */
5891         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5892         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5893         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5894         /* Front Mic pin: input vref at 80% */
5895         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5896         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5897         /* Speaker:  output */
5898         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5899         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5900         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5901         /* Headphone output (output 0 - 0x0c) */
5902         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5903         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5904         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5905
5906         /* FIXME: use matrix-type input source selection */
5907         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5908         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5909         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5910         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5911         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5912         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5913         /* Input mixer2 */
5914         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5915         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5916         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5917         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5918         /* Input mixer3 */
5919         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5920         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5921         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5922         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5923         /* ADC1: mute amp left and right */
5924         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5925         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5926         /* ADC2: mute amp left and right */
5927         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5928         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5929         /* ADC3: mute amp left and right */
5930         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5931         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5932
5933         { }
5934 };
5935
5936 /* Macbook Pro rev3 */
5937 static struct hda_verb alc885_mbp3_init_verbs[] = {
5938         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5939         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5940         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5941         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5942         /* Rear mixer */
5943         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5944         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5945         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5946         /* Front Pin: output 0 (0x0c) */
5947         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5948         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5949         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5950         /* HP Pin: output 0 (0x0d) */
5951         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
5952         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5953         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5954         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
5955         /* Mic (rear) pin: input vref at 80% */
5956         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5957         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5958         /* Front Mic pin: input vref at 80% */
5959         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5960         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5961         /* Line In pin: use output 1 when in LineOut mode */
5962         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5963         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5964         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
5965
5966         /* FIXME: use matrix-type input source selection */
5967         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5968         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5969         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5970         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5971         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5972         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5973         /* Input mixer2 */
5974         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5975         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5976         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5977         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5978         /* Input mixer3 */
5979         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5980         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5981         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5982         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5983         /* ADC1: mute amp left and right */
5984         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5985         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5986         /* ADC2: mute amp left and right */
5987         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5988         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5989         /* ADC3: mute amp left and right */
5990         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5991         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5992
5993         { }
5994 };
5995
5996 /* iMac 24 mixer. */
5997 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
5998         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5999         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6000         { } /* end */
6001 };
6002
6003 /* iMac 24 init verbs. */
6004 static struct hda_verb alc885_imac24_init_verbs[] = {
6005         /* Internal speakers: output 0 (0x0c) */
6006         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6007         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6008         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6009         /* Internal speakers: output 0 (0x0c) */
6010         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6011         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6012         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6013         /* Headphone: output 0 (0x0c) */
6014         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6015         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6016         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6017         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6018         /* Front Mic: input vref at 80% */
6019         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6020         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6021         { }
6022 };
6023
6024 /* Toggle speaker-output according to the hp-jack state */
6025 static void alc885_imac24_automute(struct hda_codec *codec)
6026 {
6027         unsigned int present;
6028
6029         present = snd_hda_codec_read(codec, 0x14, 0,
6030                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6031         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6032                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6033         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6034                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6035 }
6036
6037 /* Processes unsolicited events. */
6038 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6039                                       unsigned int res)
6040 {
6041         /* Headphone insertion or removal. */
6042         if ((res >> 26) == ALC880_HP_EVENT)
6043                 alc885_imac24_automute(codec);
6044 }
6045
6046 static void alc885_mbp3_automute(struct hda_codec *codec)
6047 {
6048         unsigned int present;
6049
6050         present = snd_hda_codec_read(codec, 0x15, 0,
6051                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6052         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6053                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6054         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6055                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6056
6057 }
6058 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6059                                     unsigned int res)
6060 {
6061         /* Headphone insertion or removal. */
6062         if ((res >> 26) == ALC880_HP_EVENT)
6063                 alc885_mbp3_automute(codec);
6064 }
6065
6066
6067 static struct hda_verb alc882_targa_verbs[] = {
6068         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6069         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6070
6071         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6072         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6073
6074         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6075         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6076         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6077
6078         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6079         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6080         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6081         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6082         { } /* end */
6083 };
6084
6085 /* toggle speaker-output according to the hp-jack state */
6086 static void alc882_targa_automute(struct hda_codec *codec)
6087 {
6088         unsigned int present;
6089
6090         present = snd_hda_codec_read(codec, 0x14, 0,
6091                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6092         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6093                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6094         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6095                                   present ? 1 : 3);
6096 }
6097
6098 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6099 {
6100         /* Looks like the unsol event is incompatible with the standard
6101          * definition.  4bit tag is placed at 26 bit!
6102          */
6103         if (((res >> 26) == ALC880_HP_EVENT)) {
6104                 alc882_targa_automute(codec);
6105         }
6106 }
6107
6108 static struct hda_verb alc882_asus_a7j_verbs[] = {
6109         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6110         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6111
6112         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6113         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6114         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6115
6116         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6117         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6118         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6119
6120         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6121         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6122         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6123         { } /* end */
6124 };
6125
6126 static struct hda_verb alc882_asus_a7m_verbs[] = {
6127         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6128         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6129
6130         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6131         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6132         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6133
6134         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6135         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6136         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6137
6138         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6139         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6140         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6141         { } /* end */
6142 };
6143
6144 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6145 {
6146         unsigned int gpiostate, gpiomask, gpiodir;
6147
6148         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6149                                        AC_VERB_GET_GPIO_DATA, 0);
6150
6151         if (!muted)
6152                 gpiostate |= (1 << pin);
6153         else
6154                 gpiostate &= ~(1 << pin);
6155
6156         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6157                                       AC_VERB_GET_GPIO_MASK, 0);
6158         gpiomask |= (1 << pin);
6159
6160         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6161                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6162         gpiodir |= (1 << pin);
6163
6164
6165         snd_hda_codec_write(codec, codec->afg, 0,
6166                             AC_VERB_SET_GPIO_MASK, gpiomask);
6167         snd_hda_codec_write(codec, codec->afg, 0,
6168                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6169
6170         msleep(1);
6171
6172         snd_hda_codec_write(codec, codec->afg, 0,
6173                             AC_VERB_SET_GPIO_DATA, gpiostate);
6174 }
6175
6176 /* set up GPIO at initialization */
6177 static void alc885_macpro_init_hook(struct hda_codec *codec)
6178 {
6179         alc882_gpio_mute(codec, 0, 0);
6180         alc882_gpio_mute(codec, 1, 0);
6181 }
6182
6183 /* set up GPIO and update auto-muting at initialization */
6184 static void alc885_imac24_init_hook(struct hda_codec *codec)
6185 {
6186         alc885_macpro_init_hook(codec);
6187         alc885_imac24_automute(codec);
6188 }
6189
6190 /*
6191  * generic initialization of ADC, input mixers and output mixers
6192  */
6193 static struct hda_verb alc882_auto_init_verbs[] = {
6194         /*
6195          * Unmute ADC0-2 and set the default input to mic-in
6196          */
6197         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6198         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6199         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6200         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6201         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6202         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6203
6204         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6205          * mixer widget
6206          * Note: PASD motherboards uses the Line In 2 as the input for
6207          * front panel mic (mic 2)
6208          */
6209         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6210         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6211         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6212         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6213         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6214         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6215
6216         /*
6217          * Set up output mixers (0x0c - 0x0f)
6218          */
6219         /* set vol=0 to output mixers */
6220         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6221         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6222         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6223         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6224         /* set up input amps for analog loopback */
6225         /* Amp Indices: DAC = 0, mixer = 1 */
6226         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6227         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6228         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6229         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6230         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6231         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6232         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6233         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6234         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6235         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6236
6237         /* FIXME: use matrix-type input source selection */
6238         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6239         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6240         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6241         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6242         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6243         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6244         /* Input mixer2 */
6245         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6246         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6247         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6248         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6249         /* Input mixer3 */
6250         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6251         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6252         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6253         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6254
6255         { }
6256 };
6257
6258 /* capture mixer elements */
6259 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
6260         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6261         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6262         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6263         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6264         {
6265                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6266                 /* The multiple "Capture Source" controls confuse alsamixer
6267                  * So call somewhat different..
6268                  */
6269                 /* .name = "Capture Source", */
6270                 .name = "Input Source",
6271                 .count = 2,
6272                 .info = alc882_mux_enum_info,
6273                 .get = alc882_mux_enum_get,
6274                 .put = alc882_mux_enum_put,
6275         },
6276         { } /* end */
6277 };
6278
6279 static struct snd_kcontrol_new alc882_capture_mixer[] = {
6280         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
6281         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
6282         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
6283         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
6284         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
6285         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
6286         {
6287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6288                 /* The multiple "Capture Source" controls confuse alsamixer
6289                  * So call somewhat different..
6290                  */
6291                 /* .name = "Capture Source", */
6292                 .name = "Input Source",
6293                 .count = 3,
6294                 .info = alc882_mux_enum_info,
6295                 .get = alc882_mux_enum_get,
6296                 .put = alc882_mux_enum_put,
6297         },
6298         { } /* end */
6299 };
6300
6301 #ifdef CONFIG_SND_HDA_POWER_SAVE
6302 #define alc882_loopbacks        alc880_loopbacks
6303 #endif
6304
6305 /* pcm configuration: identiacal with ALC880 */
6306 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6307 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6308 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6309 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6310
6311 /*
6312  * configuration and preset
6313  */
6314 static const char *alc882_models[ALC882_MODEL_LAST] = {
6315         [ALC882_3ST_DIG]        = "3stack-dig",
6316         [ALC882_6ST_DIG]        = "6stack-dig",
6317         [ALC882_ARIMA]          = "arima",
6318         [ALC882_W2JC]           = "w2jc",
6319         [ALC882_TARGA]          = "targa",
6320         [ALC882_ASUS_A7J]       = "asus-a7j",
6321         [ALC882_ASUS_A7M]       = "asus-a7m",
6322         [ALC885_MACPRO]         = "macpro",
6323         [ALC885_MBP3]           = "mbp3",
6324         [ALC885_IMAC24]         = "imac24",
6325         [ALC882_AUTO]           = "auto",
6326 };
6327
6328 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6329         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6330         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6331         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6332         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6333         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6334         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6335         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6336         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6337         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6338         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6339         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6340         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6341         {}
6342 };
6343
6344 static struct alc_config_preset alc882_presets[] = {
6345         [ALC882_3ST_DIG] = {
6346                 .mixers = { alc882_base_mixer },
6347                 .init_verbs = { alc882_init_verbs },
6348                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6349                 .dac_nids = alc882_dac_nids,
6350                 .dig_out_nid = ALC882_DIGOUT_NID,
6351                 .dig_in_nid = ALC882_DIGIN_NID,
6352                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6353                 .channel_mode = alc882_ch_modes,
6354                 .need_dac_fix = 1,
6355                 .input_mux = &alc882_capture_source,
6356         },
6357         [ALC882_6ST_DIG] = {
6358                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6359                 .init_verbs = { alc882_init_verbs },
6360                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6361                 .dac_nids = alc882_dac_nids,
6362                 .dig_out_nid = ALC882_DIGOUT_NID,
6363                 .dig_in_nid = ALC882_DIGIN_NID,
6364                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6365                 .channel_mode = alc882_sixstack_modes,
6366                 .input_mux = &alc882_capture_source,
6367         },
6368         [ALC882_ARIMA] = {
6369                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6370                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6371                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6372                 .dac_nids = alc882_dac_nids,
6373                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6374                 .channel_mode = alc882_sixstack_modes,
6375                 .input_mux = &alc882_capture_source,
6376         },
6377         [ALC882_W2JC] = {
6378                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6379                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6380                                 alc880_gpio1_init_verbs },
6381                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6382                 .dac_nids = alc882_dac_nids,
6383                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6384                 .channel_mode = alc880_threestack_modes,
6385                 .need_dac_fix = 1,
6386                 .input_mux = &alc882_capture_source,
6387                 .dig_out_nid = ALC882_DIGOUT_NID,
6388         },
6389         [ALC885_MBP3] = {
6390                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6391                 .init_verbs = { alc885_mbp3_init_verbs,
6392                                 alc880_gpio1_init_verbs },
6393                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6394                 .dac_nids = alc882_dac_nids,
6395                 .channel_mode = alc885_mbp_6ch_modes,
6396                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6397                 .input_mux = &alc882_capture_source,
6398                 .dig_out_nid = ALC882_DIGOUT_NID,
6399                 .dig_in_nid = ALC882_DIGIN_NID,
6400                 .unsol_event = alc885_mbp3_unsol_event,
6401                 .init_hook = alc885_mbp3_automute,
6402         },
6403         [ALC885_MACPRO] = {
6404                 .mixers = { alc882_macpro_mixer },
6405                 .init_verbs = { alc882_macpro_init_verbs },
6406                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6407                 .dac_nids = alc882_dac_nids,
6408                 .dig_out_nid = ALC882_DIGOUT_NID,
6409                 .dig_in_nid = ALC882_DIGIN_NID,
6410                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6411                 .channel_mode = alc882_ch_modes,
6412                 .input_mux = &alc882_capture_source,
6413                 .init_hook = alc885_macpro_init_hook,
6414         },
6415         [ALC885_IMAC24] = {
6416                 .mixers = { alc885_imac24_mixer },
6417                 .init_verbs = { alc885_imac24_init_verbs },
6418                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6419                 .dac_nids = alc882_dac_nids,
6420                 .dig_out_nid = ALC882_DIGOUT_NID,
6421                 .dig_in_nid = ALC882_DIGIN_NID,
6422                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6423                 .channel_mode = alc882_ch_modes,
6424                 .input_mux = &alc882_capture_source,
6425                 .unsol_event = alc885_imac24_unsol_event,
6426                 .init_hook = alc885_imac24_init_hook,
6427         },
6428         [ALC882_TARGA] = {
6429                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6430                             alc882_capture_mixer },
6431                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6432                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6433                 .dac_nids = alc882_dac_nids,
6434                 .dig_out_nid = ALC882_DIGOUT_NID,
6435                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6436                 .adc_nids = alc882_adc_nids,
6437                 .capsrc_nids = alc882_capsrc_nids,
6438                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6439                 .channel_mode = alc882_3ST_6ch_modes,
6440                 .need_dac_fix = 1,
6441                 .input_mux = &alc882_capture_source,
6442                 .unsol_event = alc882_targa_unsol_event,
6443                 .init_hook = alc882_targa_automute,
6444         },
6445         [ALC882_ASUS_A7J] = {
6446                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6447                             alc882_capture_mixer },
6448                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6449                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6450                 .dac_nids = alc882_dac_nids,
6451                 .dig_out_nid = ALC882_DIGOUT_NID,
6452                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6453                 .adc_nids = alc882_adc_nids,
6454                 .capsrc_nids = alc882_capsrc_nids,
6455                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6456                 .channel_mode = alc882_3ST_6ch_modes,
6457                 .need_dac_fix = 1,
6458                 .input_mux = &alc882_capture_source,
6459         },
6460         [ALC882_ASUS_A7M] = {
6461                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6462                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6463                                 alc880_gpio1_init_verbs,
6464                                 alc882_asus_a7m_verbs },
6465                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6466                 .dac_nids = alc882_dac_nids,
6467                 .dig_out_nid = ALC882_DIGOUT_NID,
6468                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6469                 .channel_mode = alc880_threestack_modes,
6470                 .need_dac_fix = 1,
6471                 .input_mux = &alc882_capture_source,
6472         },
6473 };
6474
6475
6476 /*
6477  * Pin config fixes
6478  */
6479 enum {
6480         PINFIX_ABIT_AW9D_MAX
6481 };
6482
6483 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6484         { 0x15, 0x01080104 }, /* side */
6485         { 0x16, 0x01011012 }, /* rear */
6486         { 0x17, 0x01016011 }, /* clfe */
6487         { }
6488 };
6489
6490 static const struct alc_pincfg *alc882_pin_fixes[] = {
6491         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6492 };
6493
6494 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6495         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6496         {}
6497 };
6498
6499 /*
6500  * BIOS auto configuration
6501  */
6502 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6503                                               hda_nid_t nid, int pin_type,
6504                                               int dac_idx)
6505 {
6506         /* set as output */
6507         struct alc_spec *spec = codec->spec;
6508         int idx;
6509
6510         alc_set_pin_output(codec, nid, pin_type);
6511         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6512                 idx = 4;
6513         else
6514                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6515         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6516
6517 }
6518
6519 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6520 {
6521         struct alc_spec *spec = codec->spec;
6522         int i;
6523
6524         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6525         for (i = 0; i <= HDA_SIDE; i++) {
6526                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6527                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6528                 if (nid)
6529                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6530                                                           i);
6531         }
6532 }
6533
6534 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6535 {
6536         struct alc_spec *spec = codec->spec;
6537         hda_nid_t pin;
6538
6539         pin = spec->autocfg.hp_pins[0];
6540         if (pin) /* connect to front */
6541                 /* use dac 0 */
6542                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6543         pin = spec->autocfg.speaker_pins[0];
6544         if (pin)
6545                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6546 }
6547
6548 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
6549 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
6550
6551 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6552 {
6553         struct alc_spec *spec = codec->spec;
6554         int i;
6555
6556         for (i = 0; i < AUTO_PIN_LAST; i++) {
6557                 hda_nid_t nid = spec->autocfg.input_pins[i];
6558                 unsigned int vref;
6559                 if (!nid)
6560                         continue;
6561                 vref = PIN_IN;
6562                 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6563                         unsigned int pincap;
6564                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6565                         if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6566                             AC_PINCAP_VREF_80)
6567                                 vref = PIN_VREF80;
6568                 }
6569                 snd_hda_codec_write(codec, nid, 0,
6570                                     AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6571                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6572                         snd_hda_codec_write(codec, nid, 0,
6573                                             AC_VERB_SET_AMP_GAIN_MUTE,
6574                                             AMP_OUT_MUTE);
6575         }
6576 }
6577
6578 static void alc882_auto_init_input_src(struct hda_codec *codec)
6579 {
6580         struct alc_spec *spec = codec->spec;
6581         const struct hda_input_mux *imux = spec->input_mux;
6582         int c;
6583
6584         for (c = 0; c < spec->num_adc_nids; c++) {
6585                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
6586                 hda_nid_t nid = spec->capsrc_nids[c];
6587                 int conns, mute, idx, item;
6588
6589                 conns = snd_hda_get_connections(codec, nid, conn_list,
6590                                                 ARRAY_SIZE(conn_list));
6591                 if (conns < 0)
6592                         continue;
6593                 for (idx = 0; idx < conns; idx++) {
6594                         /* if the current connection is the selected one,
6595                          * unmute it as default - otherwise mute it
6596                          */
6597                         mute = AMP_IN_MUTE(idx);
6598                         for (item = 0; item < imux->num_items; item++) {
6599                                 if (imux->items[item].index == idx) {
6600                                         if (spec->cur_mux[c] == item)
6601                                                 mute = AMP_IN_UNMUTE(idx);
6602                                         break;
6603                                 }
6604                         }
6605                         snd_hda_codec_write(codec, nid, 0,
6606                                             AC_VERB_SET_AMP_GAIN_MUTE, mute);
6607                 }
6608         }
6609 }
6610
6611 /* add mic boosts if needed */
6612 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6613 {
6614         struct alc_spec *spec = codec->spec;
6615         int err;
6616         hda_nid_t nid;
6617
6618         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6619         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6620                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6621                                   "Mic Boost",
6622                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6623                 if (err < 0)
6624                         return err;
6625         }
6626         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6627         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6628                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6629                                   "Front Mic Boost",
6630                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6631                 if (err < 0)
6632                         return err;
6633         }
6634         return 0;
6635 }
6636
6637 /* almost identical with ALC880 parser... */
6638 static int alc882_parse_auto_config(struct hda_codec *codec)
6639 {
6640         struct alc_spec *spec = codec->spec;
6641         int err = alc880_parse_auto_config(codec);
6642
6643         if (err < 0)
6644                 return err;
6645         else if (!err)
6646                 return 0; /* no config found */
6647
6648         err = alc_auto_add_mic_boost(codec);
6649         if (err < 0)
6650                 return err;
6651
6652         /* hack - override the init verbs */
6653         spec->init_verbs[0] = alc882_auto_init_verbs;
6654
6655         return 1; /* config found */
6656 }
6657
6658 /* additional initialization for auto-configuration model */
6659 static void alc882_auto_init(struct hda_codec *codec)
6660 {
6661         struct alc_spec *spec = codec->spec;
6662         alc882_auto_init_multi_out(codec);
6663         alc882_auto_init_hp_out(codec);
6664         alc882_auto_init_analog_input(codec);
6665         alc882_auto_init_input_src(codec);
6666         if (spec->unsol_event)
6667                 alc_inithook(codec);
6668 }
6669
6670 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6671
6672 static int patch_alc882(struct hda_codec *codec)
6673 {
6674         struct alc_spec *spec;
6675         int err, board_config;
6676
6677         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6678         if (spec == NULL)
6679                 return -ENOMEM;
6680
6681         codec->spec = spec;
6682
6683         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6684                                                   alc882_models,
6685                                                   alc882_cfg_tbl);
6686
6687         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6688                 /* Pick up systems that don't supply PCI SSID */
6689                 switch (codec->subsystem_id) {
6690                 case 0x106b0c00: /* Mac Pro */
6691                         board_config = ALC885_MACPRO;
6692                         break;
6693                 case 0x106b1000: /* iMac 24 */
6694                 case 0x106b2800: /* AppleTV */
6695                         board_config = ALC885_IMAC24;
6696                         break;
6697                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
6698                 case 0x106b00a4: /* MacbookPro4,1 */
6699                 case 0x106b2c00: /* Macbook Pro rev3 */
6700                 case 0x106b3600: /* Macbook 3.1 */
6701                         board_config = ALC885_MBP3;
6702                         break;
6703                 default:
6704                         /* ALC889A is handled better as ALC888-compatible */
6705                         if (codec->revision_id == 0x100101 ||
6706                             codec->revision_id == 0x100103) {
6707                                 alc_free(codec);
6708                                 return patch_alc883(codec);
6709                         }
6710                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6711                                          "trying auto-probe from BIOS...\n");
6712                         board_config = ALC882_AUTO;
6713                 }
6714         }
6715
6716         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6717
6718         if (board_config == ALC882_AUTO) {
6719                 /* automatic parse from the BIOS config */
6720                 err = alc882_parse_auto_config(codec);
6721                 if (err < 0) {
6722                         alc_free(codec);
6723                         return err;
6724                 } else if (!err) {
6725                         printk(KERN_INFO
6726                                "hda_codec: Cannot set up configuration "
6727                                "from BIOS.  Using base mode...\n");
6728                         board_config = ALC882_3ST_DIG;
6729                 }
6730         }
6731
6732         if (board_config != ALC882_AUTO)
6733                 setup_preset(spec, &alc882_presets[board_config]);
6734
6735         if (codec->vendor_id == 0x10ec0885) {
6736                 spec->stream_name_analog = "ALC885 Analog";
6737                 spec->stream_name_digital = "ALC885 Digital";
6738         } else {
6739                 spec->stream_name_analog = "ALC882 Analog";
6740                 spec->stream_name_digital = "ALC882 Digital";
6741         }
6742
6743         spec->stream_analog_playback = &alc882_pcm_analog_playback;
6744         spec->stream_analog_capture = &alc882_pcm_analog_capture;
6745         /* FIXME: setup DAC5 */
6746         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6747         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6748
6749         spec->stream_digital_playback = &alc882_pcm_digital_playback;
6750         spec->stream_digital_capture = &alc882_pcm_digital_capture;
6751
6752         if (!spec->adc_nids && spec->input_mux) {
6753                 /* check whether NID 0x07 is valid */
6754                 unsigned int wcap = get_wcaps(codec, 0x07);
6755                 /* get type */
6756                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6757                 if (wcap != AC_WID_AUD_IN) {
6758                         spec->adc_nids = alc882_adc_nids_alt;
6759                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6760                         spec->capsrc_nids = alc882_capsrc_nids_alt;
6761                         spec->mixers[spec->num_mixers] =
6762                                 alc882_capture_alt_mixer;
6763                         spec->num_mixers++;
6764                 } else {
6765                         spec->adc_nids = alc882_adc_nids;
6766                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6767                         spec->capsrc_nids = alc882_capsrc_nids;
6768                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6769                         spec->num_mixers++;
6770                 }
6771         }
6772
6773         spec->vmaster_nid = 0x0c;
6774
6775         codec->patch_ops = alc_patch_ops;
6776         if (board_config == ALC882_AUTO)
6777                 spec->init_hook = alc882_auto_init;
6778 #ifdef CONFIG_SND_HDA_POWER_SAVE
6779         if (!spec->loopback.amplist)
6780                 spec->loopback.amplist = alc882_loopbacks;
6781 #endif
6782
6783         return 0;
6784 }
6785
6786 /*
6787  * ALC883 support
6788  *
6789  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6790  * configuration.  Each pin widget can choose any input DACs and a mixer.
6791  * Each ADC is connected from a mixer of all inputs.  This makes possible
6792  * 6-channel independent captures.
6793  *
6794  * In addition, an independent DAC for the multi-playback (not used in this
6795  * driver yet).
6796  */
6797 #define ALC883_DIGOUT_NID       0x06
6798 #define ALC883_DIGIN_NID        0x0a
6799
6800 static hda_nid_t alc883_dac_nids[4] = {
6801         /* front, rear, clfe, rear_surr */
6802         0x02, 0x03, 0x04, 0x05
6803 };
6804
6805 static hda_nid_t alc883_adc_nids[2] = {
6806         /* ADC1-2 */
6807         0x08, 0x09,
6808 };
6809
6810 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6811
6812 /* input MUX */
6813 /* FIXME: should be a matrix-type input source selection */
6814
6815 static struct hda_input_mux alc883_capture_source = {
6816         .num_items = 4,
6817         .items = {
6818                 { "Mic", 0x0 },
6819                 { "Front Mic", 0x1 },
6820                 { "Line", 0x2 },
6821                 { "CD", 0x4 },
6822         },
6823 };
6824
6825 static struct hda_input_mux alc883_3stack_6ch_intel = {
6826         .num_items = 4,
6827         .items = {
6828                 { "Mic", 0x1 },
6829                 { "Front Mic", 0x0 },
6830                 { "Line", 0x2 },
6831                 { "CD", 0x4 },
6832         },
6833 };
6834
6835 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6836         .num_items = 2,
6837         .items = {
6838                 { "Mic", 0x1 },
6839                 { "Line", 0x2 },
6840         },
6841 };
6842
6843 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6844         .num_items = 4,
6845         .items = {
6846                 { "Mic", 0x0 },
6847                 { "iMic", 0x1 },
6848                 { "Line", 0x2 },
6849                 { "CD", 0x4 },
6850         },
6851 };
6852
6853 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6854         .num_items = 2,
6855         .items = {
6856                 { "Mic", 0x0 },
6857                 { "Int Mic", 0x1 },
6858         },
6859 };
6860
6861 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6862         .num_items = 3,
6863         .items = {
6864                 { "Mic", 0x0 },
6865                 { "Front Mic", 0x1 },
6866                 { "Line", 0x4 },
6867         },
6868 };
6869
6870 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6871         .num_items = 2,
6872         .items = {
6873                 { "Mic", 0x0 },
6874                 { "Line", 0x2 },
6875         },
6876 };
6877
6878 #define alc883_mux_enum_info alc_mux_enum_info
6879 #define alc883_mux_enum_get alc_mux_enum_get
6880 /* ALC883 has the ALC882-type input selection */
6881 #define alc883_mux_enum_put alc882_mux_enum_put
6882
6883 /*
6884  * 2ch mode
6885  */
6886 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6887         { 2, NULL }
6888 };
6889
6890 /*
6891  * 2ch mode
6892  */
6893 static struct hda_verb alc883_3ST_ch2_init[] = {
6894         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6895         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6896         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6897         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6898         { } /* end */
6899 };
6900
6901 /*
6902  * 4ch mode
6903  */
6904 static struct hda_verb alc883_3ST_ch4_init[] = {
6905         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6906         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6907         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6908         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6909         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6910         { } /* end */
6911 };
6912
6913 /*
6914  * 6ch mode
6915  */
6916 static struct hda_verb alc883_3ST_ch6_init[] = {
6917         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6918         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6919         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6920         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6921         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6922         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6923         { } /* end */
6924 };
6925
6926 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
6927         { 2, alc883_3ST_ch2_init },
6928         { 4, alc883_3ST_ch4_init },
6929         { 6, alc883_3ST_ch6_init },
6930 };
6931
6932 /*
6933  * 2ch mode
6934  */
6935 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6936         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6937         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6938         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6939         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6940         { } /* end */
6941 };
6942
6943 /*
6944  * 4ch mode
6945  */
6946 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6947         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6948         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6949         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6950         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6951         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6952         { } /* end */
6953 };
6954
6955 /*
6956  * 6ch mode
6957  */
6958 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6959         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6960         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6961         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6962         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6963         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6964         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6965         { } /* end */
6966 };
6967
6968 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6969         { 2, alc883_3ST_ch2_intel_init },
6970         { 4, alc883_3ST_ch4_intel_init },
6971         { 6, alc883_3ST_ch6_intel_init },
6972 };
6973
6974 /*
6975  * 6ch mode
6976  */
6977 static struct hda_verb alc883_sixstack_ch6_init[] = {
6978         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6979         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6980         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6981         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6982         { } /* end */
6983 };
6984
6985 /*
6986  * 8ch mode
6987  */
6988 static struct hda_verb alc883_sixstack_ch8_init[] = {
6989         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6990         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6991         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6992         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6993         { } /* end */
6994 };
6995
6996 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6997         { 6, alc883_sixstack_ch6_init },
6998         { 8, alc883_sixstack_ch8_init },
6999 };
7000
7001 static struct hda_verb alc883_medion_eapd_verbs[] = {
7002         /* eanable EAPD on medion laptop */
7003         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7004         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7005         { }
7006 };
7007
7008 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7009  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7010  */
7011
7012 static struct snd_kcontrol_new alc883_base_mixer[] = {
7013         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7014         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7015         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7016         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7017         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7018         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7019         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7020         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7021         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7022         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7023         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7024         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7025         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7026         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7027         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7028         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7029         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7030         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7031         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7032         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7033         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7034         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7035         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7036         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7037         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7038         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7039         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7040         {
7041                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7042                 /* .name = "Capture Source", */
7043                 .name = "Input Source",
7044                 .count = 2,
7045                 .info = alc883_mux_enum_info,
7046                 .get = alc883_mux_enum_get,
7047                 .put = alc883_mux_enum_put,
7048         },
7049         { } /* end */
7050 };
7051
7052 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7053         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7054         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7055         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7056         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7057         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7058         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7059         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7060         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7061         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7062         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7063         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7064         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7065         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7066         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7067         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7068         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7069         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7070         {
7071                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7072                 /* .name = "Capture Source", */
7073                 .name = "Input Source",
7074                 .count = 2,
7075                 .info = alc883_mux_enum_info,
7076                 .get = alc883_mux_enum_get,
7077                 .put = alc883_mux_enum_put,
7078         },
7079         { } /* end */
7080 };
7081
7082 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7083         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7084         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7085         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7086         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7087         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7088         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7089         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7090         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7091         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7092         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7093         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7094         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7095         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7096         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7097         {
7098                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7099                 /* .name = "Capture Source", */
7100                 .name = "Input Source",
7101                 .count = 2,
7102                 .info = alc883_mux_enum_info,
7103                 .get = alc883_mux_enum_get,
7104                 .put = alc883_mux_enum_put,
7105         },
7106         { } /* end */
7107 };
7108
7109 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7110         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7111         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7112         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7113         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7114         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7115         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7116         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7117         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7118         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7119         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7120         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7121         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7122         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7123         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7124         {
7125                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7126                 /* .name = "Capture Source", */
7127                 .name = "Input Source",
7128                 .count = 2,
7129                 .info = alc883_mux_enum_info,
7130                 .get = alc883_mux_enum_get,
7131                 .put = alc883_mux_enum_put,
7132         },
7133         { } /* end */
7134 };
7135
7136 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7137         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7138         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7139         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7140         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7141         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7142         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7143         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7144         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7145         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7146         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7147         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7148         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7149         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7150         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7151         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7152         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7153         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7154         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7155         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7156         {
7157                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7158                 /* .name = "Capture Source", */
7159                 .name = "Input Source",
7160                 .count = 2,
7161                 .info = alc883_mux_enum_info,
7162                 .get = alc883_mux_enum_get,
7163                 .put = alc883_mux_enum_put,
7164         },
7165         { } /* end */
7166 };
7167
7168 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7169         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7170         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7171         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7172         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7173         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7174         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7175         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7176         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7177         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7178         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7179         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7180         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7181         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7182         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7183         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7185         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7186         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7187         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7188         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7189         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7190         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7191         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7192         {
7193                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7194                 /* .name = "Capture Source", */
7195                 .name = "Input Source",
7196                 .count = 1,
7197                 .info = alc883_mux_enum_info,
7198                 .get = alc883_mux_enum_get,
7199                 .put = alc883_mux_enum_put,
7200         },
7201         { } /* end */
7202 };
7203
7204 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7205         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7206         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7207         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7208         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7209         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7210                               HDA_OUTPUT),
7211         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7212         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7213         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7214         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7215         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7216         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7217         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7218         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7219         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7220         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7221         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7222         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7223         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7224         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7225         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7226         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7227         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7228         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7229         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7230         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7231         {
7232                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7233                 /* .name = "Capture Source", */
7234                 .name = "Input Source",
7235                 .count = 2,
7236                 .info = alc883_mux_enum_info,
7237                 .get = alc883_mux_enum_get,
7238                 .put = alc883_mux_enum_put,
7239         },
7240         { } /* end */
7241 };
7242
7243 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7244         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7245         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7246         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7247         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7248         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7249         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7250         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7251         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7252         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7253         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7254         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7255         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7256         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7257         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7258         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7259         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7260         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7261         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7262         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7263         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7264         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7265         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7266         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7267
7268         {
7269                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7270                 /* .name = "Capture Source", */
7271                 .name = "Input Source",
7272                 .count = 1,
7273                 .info = alc883_mux_enum_info,
7274                 .get = alc883_mux_enum_get,
7275                 .put = alc883_mux_enum_put,
7276         },
7277         { } /* end */
7278 };
7279
7280 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7281         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7282         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7283         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7284         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7285         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7286         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7287         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7288         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7289         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7290         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7291         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7292         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7293         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7294         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7295         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7296         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7297         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7298         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7299         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7300         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7301         {
7302                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7303                 /* .name = "Capture Source", */
7304                 .name = "Input Source",
7305                 .count = 2,
7306                 .info = alc883_mux_enum_info,
7307                 .get = alc883_mux_enum_get,
7308                 .put = alc883_mux_enum_put,
7309         },
7310         { } /* end */
7311 };
7312
7313 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7314         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7315         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7316         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7317         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7318         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7319         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7320         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7321         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7322         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7323         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7324         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7325         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7326         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7327         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7328         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7329         {
7330                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7331                 /* .name = "Capture Source", */
7332                 .name = "Input Source",
7333                 .count = 2,
7334                 .info = alc883_mux_enum_info,
7335                 .get = alc883_mux_enum_get,
7336                 .put = alc883_mux_enum_put,
7337         },
7338         { } /* end */
7339 };
7340
7341 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7342         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7343         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7344         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7345         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7346         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7348         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7349         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7350         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7351         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7352         {
7353                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7354                 /* .name = "Capture Source", */
7355                 .name = "Input Source",
7356                 .count = 1,
7357                 .info = alc883_mux_enum_info,
7358                 .get = alc883_mux_enum_get,
7359                 .put = alc883_mux_enum_put,
7360         },
7361         { } /* end */
7362 };
7363
7364 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7365         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7366         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7367         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7368         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7369         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7370         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7371         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7372         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7373         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7374         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7375         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7376         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7377         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7378         {
7379                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7380                 /* .name = "Capture Source", */
7381                 .name = "Input Source",
7382                 .count = 2,
7383                 .info = alc883_mux_enum_info,
7384                 .get = alc883_mux_enum_get,
7385                 .put = alc883_mux_enum_put,
7386         },
7387         { } /* end */
7388 };
7389
7390 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7391         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7392         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7393         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7394         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7395         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7396         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7397         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7398         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7399         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7400         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7401         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7402         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7403         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7404         {
7405                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7406                 /* .name = "Capture Source", */
7407                 .name = "Input Source",
7408                 .count = 2,
7409                 .info = alc883_mux_enum_info,
7410                 .get = alc883_mux_enum_get,
7411                 .put = alc883_mux_enum_put,
7412         },
7413         { } /* end */
7414 };
7415
7416 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7417         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7418         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7419         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7420         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7421         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7422         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7423         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7424         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7425         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7426         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7427         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7428         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7429         {
7430                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7431                 /* .name = "Capture Source", */
7432                 .name = "Input Source",
7433                 .count = 2,
7434                 .info = alc883_mux_enum_info,
7435                 .get = alc883_mux_enum_get,
7436                 .put = alc883_mux_enum_put,
7437         },
7438         { } /* end */
7439 };
7440
7441 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7442         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7443         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7444         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7445         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7446         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7447                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7448         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7449         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7450         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7451         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7452         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7453         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7454         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7455         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7456         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7457         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7458         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7459         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7460         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7461         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7462         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7463         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7464         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7465         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7466         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7467         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7468         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7469         {
7470                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7471                 /* .name = "Capture Source", */
7472                 .name = "Input Source",
7473                 .count = 2,
7474                 .info = alc883_mux_enum_info,
7475                 .get = alc883_mux_enum_get,
7476                 .put = alc883_mux_enum_put,
7477         },
7478         { } /* end */
7479 };
7480
7481 static struct hda_bind_ctls alc883_bind_cap_vol = {
7482         .ops = &snd_hda_bind_vol,
7483         .values = {
7484                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7485                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7486                 0
7487         },
7488 };
7489
7490 static struct hda_bind_ctls alc883_bind_cap_switch = {
7491         .ops = &snd_hda_bind_sw,
7492         .values = {
7493                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7494                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7495                 0
7496         },
7497 };
7498
7499 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7500         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7501         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7502         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7503         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7504         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7505         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7506         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7507         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7508         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7509         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7510         {
7511                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7512                 /* .name = "Capture Source", */
7513                 .name = "Input Source",
7514                 .count = 1,
7515                 .info = alc883_mux_enum_info,
7516                 .get = alc883_mux_enum_get,
7517                 .put = alc883_mux_enum_put,
7518         },
7519         { } /* end */
7520 };
7521
7522 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7523         {
7524                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7525                 .name = "Channel Mode",
7526                 .info = alc_ch_mode_info,
7527                 .get = alc_ch_mode_get,
7528                 .put = alc_ch_mode_put,
7529         },
7530         { } /* end */
7531 };
7532
7533 static struct hda_verb alc883_init_verbs[] = {
7534         /* ADC1: mute amp left and right */
7535         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7536         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7537         /* ADC2: mute amp left and right */
7538         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7539         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7540         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7541         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7542         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7543         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7544         /* Rear mixer */
7545         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7546         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7547         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7548         /* CLFE mixer */
7549         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7550         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7551         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7552         /* Side mixer */
7553         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7554         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7555         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7556
7557         /* mute analog input loopbacks */
7558         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7559         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7560         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7561         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7562         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7563
7564         /* Front Pin: output 0 (0x0c) */
7565         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7566         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7567         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7568         /* Rear Pin: output 1 (0x0d) */
7569         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7570         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7571         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7572         /* CLFE Pin: output 2 (0x0e) */
7573         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7574         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7575         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7576         /* Side Pin: output 3 (0x0f) */
7577         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7578         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7579         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7580         /* Mic (rear) pin: input vref at 80% */
7581         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7582         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7583         /* Front Mic pin: input vref at 80% */
7584         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7585         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7586         /* Line In pin: input */
7587         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7588         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7589         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7590         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7591         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7592         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7593         /* CD pin widget for input */
7594         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7595
7596         /* FIXME: use matrix-type input source selection */
7597         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7598         /* Input mixer2 */
7599         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7600         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7601         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7602         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7603         /* Input mixer3 */
7604         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7605         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7606         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7607         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7608         { }
7609 };
7610
7611 /* toggle speaker-output according to the hp-jack state */
7612 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7613 {
7614         unsigned int present;
7615
7616         present = snd_hda_codec_read(codec, 0x15, 0,
7617                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7618         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7619                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7620         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7621                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7622 }
7623
7624 /* auto-toggle front mic */
7625 /*
7626 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7627 {
7628         unsigned int present;
7629         unsigned char bits;
7630
7631         present = snd_hda_codec_read(codec, 0x18, 0,
7632                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7633         bits = present ? HDA_AMP_MUTE : 0;
7634         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7635 }
7636 */
7637
7638 static void alc883_mitac_automute(struct hda_codec *codec)
7639 {
7640         alc883_mitac_hp_automute(codec);
7641         /* alc883_mitac_mic_automute(codec); */
7642 }
7643
7644 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7645                                            unsigned int res)
7646 {
7647         switch (res >> 26) {
7648         case ALC880_HP_EVENT:
7649                 alc883_mitac_hp_automute(codec);
7650                 break;
7651         case ALC880_MIC_EVENT:
7652                 /* alc883_mitac_mic_automute(codec); */
7653                 break;
7654         }
7655 }
7656
7657 static struct hda_verb alc883_mitac_verbs[] = {
7658         /* HP */
7659         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7660         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7661         /* Subwoofer */
7662         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7663         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7664
7665         /* enable unsolicited event */
7666         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7667         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7668
7669         { } /* end */
7670 };
7671
7672 static struct hda_verb alc883_clevo_m720_verbs[] = {
7673         /* HP */
7674         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7675         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7676         /* Int speaker */
7677         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7678         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7679
7680         /* enable unsolicited event */
7681         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7682         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7683
7684         { } /* end */
7685 };
7686
7687 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7688         /* HP */
7689         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7690         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7691         /* Subwoofer */
7692         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7693         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7694
7695         /* enable unsolicited event */
7696         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7697
7698         { } /* end */
7699 };
7700
7701 static struct hda_verb alc883_tagra_verbs[] = {
7702         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7703         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7704
7705         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7706         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7707
7708         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7709         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7710         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7711
7712         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7713         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7714         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7715         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7716
7717         { } /* end */
7718 };
7719
7720 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7721         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7722         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7723         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7724         { } /* end */
7725 };
7726
7727 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7728         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7729         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7730         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7731         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7732         { } /* end */
7733 };
7734
7735 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7736         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7737         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7738         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7739         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7740         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7741         { } /* end */
7742 };
7743
7744 static struct hda_verb alc883_haier_w66_verbs[] = {
7745         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7746         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7747
7748         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7749
7750         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7751         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7752         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7753         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7754         { } /* end */
7755 };
7756
7757 static struct hda_verb alc888_lenovo_sky_verbs[] = {
7758         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7759         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7760         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7761         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7762         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7763         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7764         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7765         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7766         { } /* end */
7767 };
7768
7769 static struct hda_verb alc888_3st_hp_verbs[] = {
7770         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7771         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7772         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7773         { }
7774 };
7775
7776 static struct hda_verb alc888_6st_dell_verbs[] = {
7777         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7778         { }
7779 };
7780
7781 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7782         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7783         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7784         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7785         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7786         { }
7787 };
7788
7789 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7790         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7791         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7792         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7793         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7794         { }
7795 };
7796
7797 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7798         { 2, alc888_3st_hp_2ch_init },
7799         { 6, alc888_3st_hp_6ch_init },
7800 };
7801
7802 /* toggle front-jack and RCA according to the hp-jack state */
7803 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7804 {
7805         unsigned int present;
7806
7807         present = snd_hda_codec_read(codec, 0x1b, 0,
7808                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7809         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7810                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7811         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7812                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7813 }
7814
7815 /* toggle RCA according to the front-jack state */
7816 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7817 {
7818         unsigned int present;
7819
7820         present = snd_hda_codec_read(codec, 0x14, 0,
7821                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7822         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7823                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7824 }
7825
7826 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7827                                              unsigned int res)
7828 {
7829         if ((res >> 26) == ALC880_HP_EVENT)
7830                 alc888_lenovo_ms7195_front_automute(codec);
7831         if ((res >> 26) == ALC880_FRONT_EVENT)
7832                 alc888_lenovo_ms7195_rca_automute(codec);
7833 }
7834
7835 static struct hda_verb alc883_medion_md2_verbs[] = {
7836         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7837         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7838
7839         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7840
7841         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7842         { } /* end */
7843 };
7844
7845 /* toggle speaker-output according to the hp-jack state */
7846 static void alc883_medion_md2_automute(struct hda_codec *codec)
7847 {
7848         unsigned int present;
7849
7850         present = snd_hda_codec_read(codec, 0x14, 0,
7851                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7852         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7853                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7854 }
7855
7856 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7857                                           unsigned int res)
7858 {
7859         if ((res >> 26) == ALC880_HP_EVENT)
7860                 alc883_medion_md2_automute(codec);
7861 }
7862
7863 /* toggle speaker-output according to the hp-jack state */
7864 static void alc883_tagra_automute(struct hda_codec *codec)
7865 {
7866         unsigned int present;
7867         unsigned char bits;
7868
7869         present = snd_hda_codec_read(codec, 0x14, 0,
7870                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7871         bits = present ? HDA_AMP_MUTE : 0;
7872         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7873                                  HDA_AMP_MUTE, bits);
7874         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7875                                   present ? 1 : 3);
7876 }
7877
7878 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7879 {
7880         if ((res >> 26) == ALC880_HP_EVENT)
7881                 alc883_tagra_automute(codec);
7882 }
7883
7884 /* toggle speaker-output according to the hp-jack state */
7885 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7886 {
7887         unsigned int present;
7888         unsigned char bits;
7889
7890         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7891                 & AC_PINSENSE_PRESENCE;
7892         bits = present ? HDA_AMP_MUTE : 0;
7893         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7894                                  HDA_AMP_MUTE, bits);
7895 }
7896
7897 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7898 {
7899         unsigned int present;
7900
7901         present = snd_hda_codec_read(codec, 0x18, 0,
7902                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7903         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7904                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7905 }
7906
7907 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7908 {
7909         alc883_clevo_m720_hp_automute(codec);
7910         alc883_clevo_m720_mic_automute(codec);
7911 }
7912
7913 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7914                                            unsigned int res)
7915 {
7916         switch (res >> 26) {
7917         case ALC880_HP_EVENT:
7918                 alc883_clevo_m720_hp_automute(codec);
7919                 break;
7920         case ALC880_MIC_EVENT:
7921                 alc883_clevo_m720_mic_automute(codec);
7922                 break;
7923         }
7924 }
7925
7926 /* toggle speaker-output according to the hp-jack state */
7927 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
7928 {
7929         unsigned int present;
7930         unsigned char bits;
7931
7932         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
7933                 & AC_PINSENSE_PRESENCE;
7934         bits = present ? HDA_AMP_MUTE : 0;
7935         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7936                                  HDA_AMP_MUTE, bits);
7937 }
7938
7939 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
7940                                                   unsigned int res)
7941 {
7942         if ((res >> 26) == ALC880_HP_EVENT)
7943                 alc883_2ch_fujitsu_pi2515_automute(codec);
7944 }
7945
7946 static void alc883_haier_w66_automute(struct hda_codec *codec)
7947 {
7948         unsigned int present;
7949         unsigned char bits;
7950
7951         present = snd_hda_codec_read(codec, 0x1b, 0,
7952                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7953         bits = present ? 0x80 : 0;
7954         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7955                                  0x80, bits);
7956 }
7957
7958 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
7959                                          unsigned int res)
7960 {
7961         if ((res >> 26) == ALC880_HP_EVENT)
7962                 alc883_haier_w66_automute(codec);
7963 }
7964
7965 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
7966 {
7967         unsigned int present;
7968         unsigned char bits;
7969
7970         present = snd_hda_codec_read(codec, 0x14, 0,
7971                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7972         bits = present ? HDA_AMP_MUTE : 0;
7973         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7974                                  HDA_AMP_MUTE, bits);
7975 }
7976
7977 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
7978 {
7979         unsigned int present;
7980         unsigned char bits;
7981
7982         present = snd_hda_codec_read(codec, 0x1b, 0,
7983                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7984         bits = present ? HDA_AMP_MUTE : 0;
7985         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7986                                  HDA_AMP_MUTE, bits);
7987         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7988                                  HDA_AMP_MUTE, bits);
7989 }
7990
7991 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
7992                                            unsigned int res)
7993 {
7994         if ((res >> 26) == ALC880_HP_EVENT)
7995                 alc883_lenovo_101e_all_automute(codec);
7996         if ((res >> 26) == ALC880_FRONT_EVENT)
7997                 alc883_lenovo_101e_ispeaker_automute(codec);
7998 }
7999
8000 /* toggle speaker-output according to the hp-jack state */
8001 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8002 {
8003         unsigned int present;
8004
8005         present = snd_hda_codec_read(codec, 0x14, 0,
8006                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8007         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8008                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8009         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8010                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8011 }
8012
8013 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8014                                            unsigned int res)
8015 {
8016         if ((res >> 26) == ALC880_HP_EVENT)
8017                 alc883_acer_aspire_automute(codec);
8018 }
8019
8020 static struct hda_verb alc883_acer_eapd_verbs[] = {
8021         /* HP Pin: output 0 (0x0c) */
8022         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8023         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8024         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8025         /* Front Pin: output 0 (0x0c) */
8026         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8027         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8028         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8029         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8030         /* eanable EAPD on medion laptop */
8031         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8032         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8033         /* enable unsolicited event */
8034         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8035         { }
8036 };
8037
8038 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8039 {
8040         unsigned int present;
8041
8042         present = snd_hda_codec_read(codec, 0x1b, 0,
8043                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8044         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8045                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8046         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8047                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8048         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8049                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8050         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8051                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8052 }
8053
8054 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8055                                              unsigned int res)
8056 {
8057         switch (res >> 26) {
8058         case ALC880_HP_EVENT:
8059                 printk("hp_event\n");
8060                 alc888_6st_dell_front_automute(codec);
8061                 break;
8062         }
8063 }
8064
8065 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8066 {
8067         unsigned int mute;
8068         unsigned int present;
8069
8070         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8071         present = snd_hda_codec_read(codec, 0x1b, 0,
8072                                      AC_VERB_GET_PIN_SENSE, 0);
8073         present = (present & 0x80000000) != 0;
8074         if (present) {
8075                 /* mute internal speaker */
8076                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8077                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8078                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8079                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8080                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8081                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8082                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8083                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8084                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8085                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8086         } else {
8087                 /* unmute internal speaker if necessary */
8088                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8089                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8090                                          HDA_AMP_MUTE, mute);
8091                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8092                                          HDA_AMP_MUTE, mute);
8093                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8094                                          HDA_AMP_MUTE, mute);
8095                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8096                                          HDA_AMP_MUTE, mute);
8097                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8098                                          HDA_AMP_MUTE, mute);
8099         }
8100 }
8101
8102 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8103                                              unsigned int res)
8104 {
8105         if ((res >> 26) == ALC880_HP_EVENT)
8106                 alc888_lenovo_sky_front_automute(codec);
8107 }
8108
8109 /*
8110  * generic initialization of ADC, input mixers and output mixers
8111  */
8112 static struct hda_verb alc883_auto_init_verbs[] = {
8113         /*
8114          * Unmute ADC0-2 and set the default input to mic-in
8115          */
8116         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8117         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8118         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8119         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8120
8121         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8122          * mixer widget
8123          * Note: PASD motherboards uses the Line In 2 as the input for
8124          * front panel mic (mic 2)
8125          */
8126         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8127         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8128         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8129         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8130         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8131         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8132
8133         /*
8134          * Set up output mixers (0x0c - 0x0f)
8135          */
8136         /* set vol=0 to output mixers */
8137         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8138         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8139         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8140         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8141         /* set up input amps for analog loopback */
8142         /* Amp Indices: DAC = 0, mixer = 1 */
8143         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8144         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8145         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8146         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8147         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8148         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8149         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8150         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8151         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8152         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8153
8154         /* FIXME: use matrix-type input source selection */
8155         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8156         /* Input mixer1 */
8157         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8158         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8159         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8160         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8161         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8162         /* Input mixer2 */
8163         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8164         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8165         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8166         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8167         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8168
8169         { }
8170 };
8171
8172 /* capture mixer elements */
8173 static struct snd_kcontrol_new alc883_capture_mixer[] = {
8174         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
8175         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
8176         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
8177         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
8178         {
8179                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8180                 /* The multiple "Capture Source" controls confuse alsamixer
8181                  * So call somewhat different..
8182                  */
8183                 /* .name = "Capture Source", */
8184                 .name = "Input Source",
8185                 .count = 2,
8186                 .info = alc882_mux_enum_info,
8187                 .get = alc882_mux_enum_get,
8188                 .put = alc882_mux_enum_put,
8189         },
8190         { } /* end */
8191 };
8192
8193 static struct hda_verb alc888_asus_m90v_verbs[] = {
8194         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8195         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8196         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8197         /* enable unsolicited event */
8198         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8199         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8200         { } /* end */
8201 };
8202
8203 static void alc883_nb_mic_automute(struct hda_codec *codec)
8204 {
8205         unsigned int present;
8206
8207         present = snd_hda_codec_read(codec, 0x18, 0,
8208                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8209         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8210                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8211         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8212                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8213 }
8214
8215 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8216 {
8217         unsigned int present;
8218         unsigned char bits;
8219
8220         present = snd_hda_codec_read(codec, 0x1b, 0,
8221                                      AC_VERB_GET_PIN_SENSE, 0)
8222                 & AC_PINSENSE_PRESENCE;
8223         bits = present ? 0 : PIN_OUT;
8224         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8225                             bits);
8226         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8227                             bits);
8228         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8229                             bits);
8230 }
8231
8232 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8233                                            unsigned int res)
8234 {
8235         switch (res >> 26) {
8236         case ALC880_HP_EVENT:
8237                 alc883_M90V_speaker_automute(codec);
8238                 break;
8239         case ALC880_MIC_EVENT:
8240                 alc883_nb_mic_automute(codec);
8241                 break;
8242         }
8243 }
8244
8245 static void alc883_mode2_inithook(struct hda_codec *codec)
8246 {
8247         alc883_M90V_speaker_automute(codec);
8248         alc883_nb_mic_automute(codec);
8249 }
8250
8251 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8252         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8253         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8254         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8255         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8256         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8257         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8258         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8259         /* enable unsolicited event */
8260         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8261         { } /* end */
8262 };
8263
8264 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8265 {
8266         unsigned int present;
8267         unsigned char bits;
8268
8269         present = snd_hda_codec_read(codec, 0x14, 0,
8270                                      AC_VERB_GET_PIN_SENSE, 0)
8271                 & AC_PINSENSE_PRESENCE;
8272         bits = present ? 0 : PIN_OUT;
8273         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8274                             bits);
8275 }
8276
8277 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8278                                            unsigned int res)
8279 {
8280         switch (res >> 26) {
8281         case ALC880_HP_EVENT:
8282                 alc883_eee1601_speaker_automute(codec);
8283                 break;
8284         }
8285 }
8286
8287 static void alc883_eee1601_inithook(struct hda_codec *codec)
8288 {
8289         alc883_eee1601_speaker_automute(codec);
8290 }
8291
8292 #ifdef CONFIG_SND_HDA_POWER_SAVE
8293 #define alc883_loopbacks        alc880_loopbacks
8294 #endif
8295
8296 /* pcm configuration: identiacal with ALC880 */
8297 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8298 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8299 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8300 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8301 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8302
8303 /*
8304  * configuration and preset
8305  */
8306 static const char *alc883_models[ALC883_MODEL_LAST] = {
8307         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8308         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8309         [ALC883_3ST_6ch]        = "3stack-6ch",
8310         [ALC883_6ST_DIG]        = "6stack-dig",
8311         [ALC883_TARGA_DIG]      = "targa-dig",
8312         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8313         [ALC883_ACER]           = "acer",
8314         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8315         [ALC883_MEDION]         = "medion",
8316         [ALC883_MEDION_MD2]     = "medion-md2",
8317         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8318         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8319         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8320         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8321         [ALC888_LENOVO_SKY] = "lenovo-sky",
8322         [ALC883_HAIER_W66]      = "haier-w66",
8323         [ALC888_3ST_HP]         = "3stack-hp",
8324         [ALC888_6ST_DELL]       = "6stack-dell",
8325         [ALC883_MITAC]          = "mitac",
8326         [ALC883_CLEVO_M720]     = "clevo-m720",
8327         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8328         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8329         [ALC883_AUTO]           = "auto",
8330 };
8331
8332 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8333         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8334         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8335         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8336         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8337         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8338         SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
8339         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8340         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8341         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8342         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8343         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8344         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8345         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8346         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8347         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8348         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8349         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8350         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8351         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8352         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8353         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8354         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8355         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8356         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8357         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8358         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8359         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8360         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8361         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8362         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8363         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8364         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8365         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8366         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8367         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8368         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8369         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8370         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8371         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8372         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8373         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8374         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8375         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8376         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8377         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8378         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8379         SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
8380         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8381         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8382         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8383         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8384         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8385         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8386         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8387         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8388         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8389         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8390         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8391         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8392         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8393         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8394         {}
8395 };
8396
8397 static struct alc_config_preset alc883_presets[] = {
8398         [ALC883_3ST_2ch_DIG] = {
8399                 .mixers = { alc883_3ST_2ch_mixer },
8400                 .init_verbs = { alc883_init_verbs },
8401                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8402                 .dac_nids = alc883_dac_nids,
8403                 .dig_out_nid = ALC883_DIGOUT_NID,
8404                 .dig_in_nid = ALC883_DIGIN_NID,
8405                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8406                 .channel_mode = alc883_3ST_2ch_modes,
8407                 .input_mux = &alc883_capture_source,
8408         },
8409         [ALC883_3ST_6ch_DIG] = {
8410                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8411                 .init_verbs = { alc883_init_verbs },
8412                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8413                 .dac_nids = alc883_dac_nids,
8414                 .dig_out_nid = ALC883_DIGOUT_NID,
8415                 .dig_in_nid = ALC883_DIGIN_NID,
8416                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8417                 .channel_mode = alc883_3ST_6ch_modes,
8418                 .need_dac_fix = 1,
8419                 .input_mux = &alc883_capture_source,
8420         },
8421         [ALC883_3ST_6ch] = {
8422                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8423                 .init_verbs = { alc883_init_verbs },
8424                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8425                 .dac_nids = alc883_dac_nids,
8426                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8427                 .channel_mode = alc883_3ST_6ch_modes,
8428                 .need_dac_fix = 1,
8429                 .input_mux = &alc883_capture_source,
8430         },
8431         [ALC883_3ST_6ch_INTEL] = {
8432                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8433                 .init_verbs = { alc883_init_verbs },
8434                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8435                 .dac_nids = alc883_dac_nids,
8436                 .dig_out_nid = ALC883_DIGOUT_NID,
8437                 .dig_in_nid = ALC883_DIGIN_NID,
8438                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8439                 .channel_mode = alc883_3ST_6ch_intel_modes,
8440                 .need_dac_fix = 1,
8441                 .input_mux = &alc883_3stack_6ch_intel,
8442         },
8443         [ALC883_6ST_DIG] = {
8444                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8445                 .init_verbs = { alc883_init_verbs },
8446                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8447                 .dac_nids = alc883_dac_nids,
8448                 .dig_out_nid = ALC883_DIGOUT_NID,
8449                 .dig_in_nid = ALC883_DIGIN_NID,
8450                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8451                 .channel_mode = alc883_sixstack_modes,
8452                 .input_mux = &alc883_capture_source,
8453         },
8454         [ALC883_TARGA_DIG] = {
8455                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8456                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8457                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8458                 .dac_nids = alc883_dac_nids,
8459                 .dig_out_nid = ALC883_DIGOUT_NID,
8460                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8461                 .channel_mode = alc883_3ST_6ch_modes,
8462                 .need_dac_fix = 1,
8463                 .input_mux = &alc883_capture_source,
8464                 .unsol_event = alc883_tagra_unsol_event,
8465                 .init_hook = alc883_tagra_automute,
8466         },
8467         [ALC883_TARGA_2ch_DIG] = {
8468                 .mixers = { alc883_tagra_2ch_mixer},
8469                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8470                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8471                 .dac_nids = alc883_dac_nids,
8472                 .dig_out_nid = ALC883_DIGOUT_NID,
8473                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8474                 .channel_mode = alc883_3ST_2ch_modes,
8475                 .input_mux = &alc883_capture_source,
8476                 .unsol_event = alc883_tagra_unsol_event,
8477                 .init_hook = alc883_tagra_automute,
8478         },
8479         [ALC883_ACER] = {
8480                 .mixers = { alc883_base_mixer },
8481                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8482                  * and the headphone jack.  Turn this on and rely on the
8483                  * standard mute methods whenever the user wants to turn
8484                  * these outputs off.
8485                  */
8486                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8487                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8488                 .dac_nids = alc883_dac_nids,
8489                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8490                 .channel_mode = alc883_3ST_2ch_modes,
8491                 .input_mux = &alc883_capture_source,
8492         },
8493         [ALC883_ACER_ASPIRE] = {
8494                 .mixers = { alc883_acer_aspire_mixer },
8495                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8496                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8497                 .dac_nids = alc883_dac_nids,
8498                 .dig_out_nid = ALC883_DIGOUT_NID,
8499                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8500                 .channel_mode = alc883_3ST_2ch_modes,
8501                 .input_mux = &alc883_capture_source,
8502                 .unsol_event = alc883_acer_aspire_unsol_event,
8503                 .init_hook = alc883_acer_aspire_automute,
8504         },
8505         [ALC883_MEDION] = {
8506                 .mixers = { alc883_fivestack_mixer,
8507                             alc883_chmode_mixer },
8508                 .init_verbs = { alc883_init_verbs,
8509                                 alc883_medion_eapd_verbs },
8510                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8511                 .dac_nids = alc883_dac_nids,
8512                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8513                 .channel_mode = alc883_sixstack_modes,
8514                 .input_mux = &alc883_capture_source,
8515         },
8516         [ALC883_MEDION_MD2] = {
8517                 .mixers = { alc883_medion_md2_mixer},
8518                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8519                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8520                 .dac_nids = alc883_dac_nids,
8521                 .dig_out_nid = ALC883_DIGOUT_NID,
8522                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8523                 .channel_mode = alc883_3ST_2ch_modes,
8524                 .input_mux = &alc883_capture_source,
8525                 .unsol_event = alc883_medion_md2_unsol_event,
8526                 .init_hook = alc883_medion_md2_automute,
8527         },
8528         [ALC883_LAPTOP_EAPD] = {
8529                 .mixers = { alc883_base_mixer },
8530                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8531                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8532                 .dac_nids = alc883_dac_nids,
8533                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8534                 .channel_mode = alc883_3ST_2ch_modes,
8535                 .input_mux = &alc883_capture_source,
8536         },
8537         [ALC883_CLEVO_M720] = {
8538                 .mixers = { alc883_clevo_m720_mixer },
8539                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8540                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8541                 .dac_nids = alc883_dac_nids,
8542                 .dig_out_nid = ALC883_DIGOUT_NID,
8543                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8544                 .channel_mode = alc883_3ST_2ch_modes,
8545                 .input_mux = &alc883_capture_source,
8546                 .unsol_event = alc883_clevo_m720_unsol_event,
8547                 .init_hook = alc883_clevo_m720_automute,
8548         },
8549         [ALC883_LENOVO_101E_2ch] = {
8550                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8551                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8552                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8553                 .dac_nids = alc883_dac_nids,
8554                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8555                 .channel_mode = alc883_3ST_2ch_modes,
8556                 .input_mux = &alc883_lenovo_101e_capture_source,
8557                 .unsol_event = alc883_lenovo_101e_unsol_event,
8558                 .init_hook = alc883_lenovo_101e_all_automute,
8559         },
8560         [ALC883_LENOVO_NB0763] = {
8561                 .mixers = { alc883_lenovo_nb0763_mixer },
8562                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8563                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8564                 .dac_nids = alc883_dac_nids,
8565                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8566                 .channel_mode = alc883_3ST_2ch_modes,
8567                 .need_dac_fix = 1,
8568                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8569                 .unsol_event = alc883_medion_md2_unsol_event,
8570                 .init_hook = alc883_medion_md2_automute,
8571         },
8572         [ALC888_LENOVO_MS7195_DIG] = {
8573                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8574                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8575                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8576                 .dac_nids = alc883_dac_nids,
8577                 .dig_out_nid = ALC883_DIGOUT_NID,
8578                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8579                 .channel_mode = alc883_3ST_6ch_modes,
8580                 .need_dac_fix = 1,
8581                 .input_mux = &alc883_capture_source,
8582                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8583                 .init_hook = alc888_lenovo_ms7195_front_automute,
8584         },
8585         [ALC883_HAIER_W66] = {
8586                 .mixers = { alc883_tagra_2ch_mixer},
8587                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8588                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8589                 .dac_nids = alc883_dac_nids,
8590                 .dig_out_nid = ALC883_DIGOUT_NID,
8591                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8592                 .channel_mode = alc883_3ST_2ch_modes,
8593                 .input_mux = &alc883_capture_source,
8594                 .unsol_event = alc883_haier_w66_unsol_event,
8595                 .init_hook = alc883_haier_w66_automute,
8596         },
8597         [ALC888_3ST_HP] = {
8598                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8599                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8600                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8601                 .dac_nids = alc883_dac_nids,
8602                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8603                 .channel_mode = alc888_3st_hp_modes,
8604                 .need_dac_fix = 1,
8605                 .input_mux = &alc883_capture_source,
8606         },
8607         [ALC888_6ST_DELL] = {
8608                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8609                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8610                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8611                 .dac_nids = alc883_dac_nids,
8612                 .dig_out_nid = ALC883_DIGOUT_NID,
8613                 .dig_in_nid = ALC883_DIGIN_NID,
8614                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8615                 .channel_mode = alc883_sixstack_modes,
8616                 .input_mux = &alc883_capture_source,
8617                 .unsol_event = alc888_6st_dell_unsol_event,
8618                 .init_hook = alc888_6st_dell_front_automute,
8619         },
8620         [ALC883_MITAC] = {
8621                 .mixers = { alc883_mitac_mixer },
8622                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8623                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8624                 .dac_nids = alc883_dac_nids,
8625                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8626                 .channel_mode = alc883_3ST_2ch_modes,
8627                 .input_mux = &alc883_capture_source,
8628                 .unsol_event = alc883_mitac_unsol_event,
8629                 .init_hook = alc883_mitac_automute,
8630         },
8631         [ALC883_FUJITSU_PI2515] = {
8632                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8633                 .init_verbs = { alc883_init_verbs,
8634                                 alc883_2ch_fujitsu_pi2515_verbs},
8635                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8636                 .dac_nids = alc883_dac_nids,
8637                 .dig_out_nid = ALC883_DIGOUT_NID,
8638                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8639                 .channel_mode = alc883_3ST_2ch_modes,
8640                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8641                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8642                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8643         },
8644         [ALC888_LENOVO_SKY] = {
8645                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8646                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8647                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8648                 .dac_nids = alc883_dac_nids,
8649                 .dig_out_nid = ALC883_DIGOUT_NID,
8650                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
8651                 .adc_nids = alc883_adc_nids,
8652                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8653                 .channel_mode = alc883_sixstack_modes,
8654                 .need_dac_fix = 1,
8655                 .input_mux = &alc883_lenovo_sky_capture_source,
8656                 .unsol_event = alc883_lenovo_sky_unsol_event,
8657                 .init_hook = alc888_lenovo_sky_front_automute,
8658         },
8659         [ALC888_ASUS_M90V] = {
8660                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8661                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
8662                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8663                 .dac_nids = alc883_dac_nids,
8664                 .dig_out_nid = ALC883_DIGOUT_NID,
8665                 .dig_in_nid = ALC883_DIGIN_NID,
8666                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8667                 .channel_mode = alc883_3ST_6ch_modes,
8668                 .need_dac_fix = 1,
8669                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8670                 .unsol_event = alc883_mode2_unsol_event,
8671                 .init_hook = alc883_mode2_inithook,
8672         },
8673         [ALC888_ASUS_EEE1601] = {
8674                 .mixers = { alc883_asus_eee1601_mixer },
8675                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
8676                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8677                 .dac_nids = alc883_dac_nids,
8678                 .dig_out_nid = ALC883_DIGOUT_NID,
8679                 .dig_in_nid = ALC883_DIGIN_NID,
8680                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8681                 .channel_mode = alc883_3ST_2ch_modes,
8682                 .need_dac_fix = 1,
8683                 .input_mux = &alc883_asus_eee1601_capture_source,
8684                 .unsol_event = alc883_eee1601_unsol_event,
8685                 .init_hook = alc883_eee1601_inithook,
8686         },
8687 };
8688
8689
8690 /*
8691  * BIOS auto configuration
8692  */
8693 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8694                                               hda_nid_t nid, int pin_type,
8695                                               int dac_idx)
8696 {
8697         /* set as output */
8698         struct alc_spec *spec = codec->spec;
8699         int idx;
8700
8701         alc_set_pin_output(codec, nid, pin_type);
8702         if (spec->multiout.dac_nids[dac_idx] == 0x25)
8703                 idx = 4;
8704         else
8705                 idx = spec->multiout.dac_nids[dac_idx] - 2;
8706         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8707
8708 }
8709
8710 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8711 {
8712         struct alc_spec *spec = codec->spec;
8713         int i;
8714
8715         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8716         for (i = 0; i <= HDA_SIDE; i++) {
8717                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8718                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8719                 if (nid)
8720                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8721                                                           i);
8722         }
8723 }
8724
8725 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8726 {
8727         struct alc_spec *spec = codec->spec;
8728         hda_nid_t pin;
8729
8730         pin = spec->autocfg.hp_pins[0];
8731         if (pin) /* connect to front */
8732                 /* use dac 0 */
8733                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8734         pin = spec->autocfg.speaker_pins[0];
8735         if (pin)
8736                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8737 }
8738
8739 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
8740 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
8741
8742 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8743 {
8744         struct alc_spec *spec = codec->spec;
8745         int i;
8746
8747         for (i = 0; i < AUTO_PIN_LAST; i++) {
8748                 hda_nid_t nid = spec->autocfg.input_pins[i];
8749                 if (alc883_is_input_pin(nid)) {
8750                         snd_hda_codec_write(codec, nid, 0,
8751                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
8752                                             (i <= AUTO_PIN_FRONT_MIC ?
8753                                              PIN_VREF80 : PIN_IN));
8754                         if (nid != ALC883_PIN_CD_NID)
8755                                 snd_hda_codec_write(codec, nid, 0,
8756                                                     AC_VERB_SET_AMP_GAIN_MUTE,
8757                                                     AMP_OUT_MUTE);
8758                 }
8759         }
8760 }
8761
8762 #define alc883_auto_init_input_src      alc882_auto_init_input_src
8763
8764 /* almost identical with ALC880 parser... */
8765 static int alc883_parse_auto_config(struct hda_codec *codec)
8766 {
8767         struct alc_spec *spec = codec->spec;
8768         int err = alc880_parse_auto_config(codec);
8769
8770         if (err < 0)
8771                 return err;
8772         else if (!err)
8773                 return 0; /* no config found */
8774
8775         err = alc_auto_add_mic_boost(codec);
8776         if (err < 0)
8777                 return err;
8778
8779         /* hack - override the init verbs */
8780         spec->init_verbs[0] = alc883_auto_init_verbs;
8781         spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8782         spec->num_mixers++;
8783
8784         return 1; /* config found */
8785 }
8786
8787 /* additional initialization for auto-configuration model */
8788 static void alc883_auto_init(struct hda_codec *codec)
8789 {
8790         struct alc_spec *spec = codec->spec;
8791         alc883_auto_init_multi_out(codec);
8792         alc883_auto_init_hp_out(codec);
8793         alc883_auto_init_analog_input(codec);
8794         alc883_auto_init_input_src(codec);
8795         if (spec->unsol_event)
8796                 alc_inithook(codec);
8797 }
8798
8799 static int patch_alc883(struct hda_codec *codec)
8800 {
8801         struct alc_spec *spec;
8802         int err, board_config;
8803
8804         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8805         if (spec == NULL)
8806                 return -ENOMEM;
8807
8808         codec->spec = spec;
8809
8810         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8811
8812         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8813                                                   alc883_models,
8814                                                   alc883_cfg_tbl);
8815         if (board_config < 0) {
8816                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8817                        "trying auto-probe from BIOS...\n");
8818                 board_config = ALC883_AUTO;
8819         }
8820
8821         if (board_config == ALC883_AUTO) {
8822                 /* automatic parse from the BIOS config */
8823                 err = alc883_parse_auto_config(codec);
8824                 if (err < 0) {
8825                         alc_free(codec);
8826                         return err;
8827                 } else if (!err) {
8828                         printk(KERN_INFO
8829                                "hda_codec: Cannot set up configuration "
8830                                "from BIOS.  Using base mode...\n");
8831                         board_config = ALC883_3ST_2ch_DIG;
8832                 }
8833         }
8834
8835         if (board_config != ALC883_AUTO)
8836                 setup_preset(spec, &alc883_presets[board_config]);
8837
8838         switch (codec->vendor_id) {
8839         case 0x10ec0888:
8840                 spec->stream_name_analog = "ALC888 Analog";
8841                 spec->stream_name_digital = "ALC888 Digital";
8842                 break;
8843         case 0x10ec0889:
8844                 spec->stream_name_analog = "ALC889 Analog";
8845                 spec->stream_name_digital = "ALC889 Digital";
8846                 break;
8847         default:
8848                 spec->stream_name_analog = "ALC883 Analog";
8849                 spec->stream_name_digital = "ALC883 Digital";
8850                 break;
8851         }
8852
8853         spec->stream_analog_playback = &alc883_pcm_analog_playback;
8854         spec->stream_analog_capture = &alc883_pcm_analog_capture;
8855         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8856
8857         spec->stream_digital_playback = &alc883_pcm_digital_playback;
8858         spec->stream_digital_capture = &alc883_pcm_digital_capture;
8859
8860         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8861         spec->adc_nids = alc883_adc_nids;
8862         spec->capsrc_nids = alc883_capsrc_nids;
8863
8864         spec->vmaster_nid = 0x0c;
8865
8866         codec->patch_ops = alc_patch_ops;
8867         if (board_config == ALC883_AUTO)
8868                 spec->init_hook = alc883_auto_init;
8869
8870 #ifdef CONFIG_SND_HDA_POWER_SAVE
8871         if (!spec->loopback.amplist)
8872                 spec->loopback.amplist = alc883_loopbacks;
8873 #endif
8874
8875         return 0;
8876 }
8877
8878 /*
8879  * ALC262 support
8880  */
8881
8882 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
8883 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
8884
8885 #define alc262_dac_nids         alc260_dac_nids
8886 #define alc262_adc_nids         alc882_adc_nids
8887 #define alc262_adc_nids_alt     alc882_adc_nids_alt
8888 #define alc262_capsrc_nids      alc882_capsrc_nids
8889 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
8890
8891 #define alc262_modes            alc260_modes
8892 #define alc262_capture_source   alc882_capture_source
8893
8894 static hda_nid_t alc262_dmic_adc_nids[1] = {
8895         /* ADC0 */
8896         0x09
8897 };
8898
8899 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
8900
8901 static struct snd_kcontrol_new alc262_base_mixer[] = {
8902         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8903         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8904         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8905         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8906         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8907         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8908         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8909         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8910         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8911         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8912         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8913         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8914         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8915            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8916         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8917         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8918         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8919         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8920         { } /* end */
8921 };
8922
8923 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8924         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8925         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8926         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8927         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8928         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8929         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8930         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8932         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8933         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8934         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8935         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8936         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8937            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8938         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8939         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8940         { } /* end */
8941 };
8942
8943 /* update HP, line and mono-out pins according to the master switch */
8944 static void alc262_hp_master_update(struct hda_codec *codec)
8945 {
8946         struct alc_spec *spec = codec->spec;
8947         int val = spec->master_sw;
8948
8949         /* HP & line-out */
8950         snd_hda_codec_write_cache(codec, 0x1b, 0,
8951                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8952                                   val ? PIN_HP : 0);
8953         snd_hda_codec_write_cache(codec, 0x15, 0,
8954                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8955                                   val ? PIN_HP : 0);
8956         /* mono (speaker) depending on the HP jack sense */
8957         val = val && !spec->jack_present;
8958         snd_hda_codec_write_cache(codec, 0x16, 0,
8959                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8960                                   val ? PIN_OUT : 0);
8961 }
8962
8963 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8964 {
8965         struct alc_spec *spec = codec->spec;
8966         unsigned int presence;
8967         presence = snd_hda_codec_read(codec, 0x1b, 0,
8968                                       AC_VERB_GET_PIN_SENSE, 0);
8969         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8970         alc262_hp_master_update(codec);
8971 }
8972
8973 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8974 {
8975         if ((res >> 26) != ALC880_HP_EVENT)
8976                 return;
8977         alc262_hp_bpc_automute(codec);
8978 }
8979
8980 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8981 {
8982         struct alc_spec *spec = codec->spec;
8983         unsigned int presence;
8984         presence = snd_hda_codec_read(codec, 0x15, 0,
8985                                       AC_VERB_GET_PIN_SENSE, 0);
8986         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8987         alc262_hp_master_update(codec);
8988 }
8989
8990 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8991                                            unsigned int res)
8992 {
8993         if ((res >> 26) != ALC880_HP_EVENT)
8994                 return;
8995         alc262_hp_wildwest_automute(codec);
8996 }
8997
8998 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
8999                                    struct snd_ctl_elem_value *ucontrol)
9000 {
9001         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9002         struct alc_spec *spec = codec->spec;
9003         *ucontrol->value.integer.value = spec->master_sw;
9004         return 0;
9005 }
9006
9007 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9008                                    struct snd_ctl_elem_value *ucontrol)
9009 {
9010         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9011         struct alc_spec *spec = codec->spec;
9012         int val = !!*ucontrol->value.integer.value;
9013
9014         if (val == spec->master_sw)
9015                 return 0;
9016         spec->master_sw = val;
9017         alc262_hp_master_update(codec);
9018         return 1;
9019 }
9020
9021 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9022         {
9023                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9024                 .name = "Master Playback Switch",
9025                 .info = snd_ctl_boolean_mono_info,
9026                 .get = alc262_hp_master_sw_get,
9027                 .put = alc262_hp_master_sw_put,
9028         },
9029         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9030         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9031         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9032         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9033                               HDA_OUTPUT),
9034         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9035                             HDA_OUTPUT),
9036         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9037         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9038         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9039         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9040         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9041         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9042         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9043         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9044         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9045         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9046         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9047         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9048         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9049         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9050         { } /* end */
9051 };
9052
9053 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9054         {
9055                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9056                 .name = "Master Playback Switch",
9057                 .info = snd_ctl_boolean_mono_info,
9058                 .get = alc262_hp_master_sw_get,
9059                 .put = alc262_hp_master_sw_put,
9060         },
9061         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9062         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9063         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9064         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9065         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9066                               HDA_OUTPUT),
9067         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9068                             HDA_OUTPUT),
9069         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9070         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9071         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9072         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9073         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9074         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9075         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9076         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9077         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9078         { } /* end */
9079 };
9080
9081 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9082         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9083         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9084         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9085         { } /* end */
9086 };
9087
9088 /* mute/unmute internal speaker according to the hp jack and mute state */
9089 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9090 {
9091         struct alc_spec *spec = codec->spec;
9092
9093         if (force || !spec->sense_updated) {
9094                 unsigned int present;
9095                 present = snd_hda_codec_read(codec, 0x15, 0,
9096                                              AC_VERB_GET_PIN_SENSE, 0);
9097                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9098                 spec->sense_updated = 1;
9099         }
9100         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9101                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9102 }
9103
9104 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9105                                         unsigned int res)
9106 {
9107         if ((res >> 26) != ALC880_HP_EVENT)
9108                 return;
9109         alc262_hp_t5735_automute(codec, 1);
9110 }
9111
9112 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9113 {
9114         alc262_hp_t5735_automute(codec, 1);
9115 }
9116
9117 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9118         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9119         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9120         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9121         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9122         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9123         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9124         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9125         { } /* end */
9126 };
9127
9128 static struct hda_verb alc262_hp_t5735_verbs[] = {
9129         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9130         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9131
9132         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9133         { }
9134 };
9135
9136 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9137         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9138         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9139         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9140         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9141         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9142         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9143         { } /* end */
9144 };
9145
9146 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9147         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9148         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9149         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9150         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9151         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9152         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9153         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9154         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9155         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9156         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9157         {}
9158 };
9159
9160 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9161         .num_items = 1,
9162         .items = {
9163                 { "Line", 0x1 },
9164         },
9165 };
9166
9167 /* bind hp and internal speaker mute (with plug check) */
9168 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9169                                      struct snd_ctl_elem_value *ucontrol)
9170 {
9171         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9172         long *valp = ucontrol->value.integer.value;
9173         int change;
9174
9175         /* change hp mute */
9176         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9177                                           HDA_AMP_MUTE,
9178                                           valp[0] ? 0 : HDA_AMP_MUTE);
9179         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9180                                            HDA_AMP_MUTE,
9181                                            valp[1] ? 0 : HDA_AMP_MUTE);
9182         if (change) {
9183                 /* change speaker according to HP jack state */
9184                 struct alc_spec *spec = codec->spec;
9185                 unsigned int mute;
9186                 if (spec->jack_present)
9187                         mute = HDA_AMP_MUTE;
9188                 else
9189                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9190                                                       HDA_OUTPUT, 0);
9191                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9192                                          HDA_AMP_MUTE, mute);
9193         }
9194         return change;
9195 }
9196
9197 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9198         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9199         {
9200                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9201                 .name = "Master Playback Switch",
9202                 .info = snd_hda_mixer_amp_switch_info,
9203                 .get = snd_hda_mixer_amp_switch_get,
9204                 .put = alc262_sony_master_sw_put,
9205                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9206         },
9207         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9208         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9209         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9210         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9211         { } /* end */
9212 };
9213
9214 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9215         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9216         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9217         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9218         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9219         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9220         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9221         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9222         { } /* end */
9223 };
9224
9225 #define alc262_capture_mixer            alc882_capture_mixer
9226 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9227
9228 /*
9229  * generic initialization of ADC, input mixers and output mixers
9230  */
9231 static struct hda_verb alc262_init_verbs[] = {
9232         /*
9233          * Unmute ADC0-2 and set the default input to mic-in
9234          */
9235         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9236         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9237         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9238         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9239         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9240         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9241
9242         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9243          * mixer widget
9244          * Note: PASD motherboards uses the Line In 2 as the input for
9245          * front panel mic (mic 2)
9246          */
9247         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9248         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9249         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9250         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9251         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9252         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9253
9254         /*
9255          * Set up output mixers (0x0c - 0x0e)
9256          */
9257         /* set vol=0 to output mixers */
9258         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9259         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9260         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9261         /* set up input amps for analog loopback */
9262         /* Amp Indices: DAC = 0, mixer = 1 */
9263         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9264         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9265         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9266         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9267         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9268         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9269
9270         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9271         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9272         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9273         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9274         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9275         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9276
9277         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9278         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9279         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9280         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9281         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9282
9283         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9284         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9285
9286         /* FIXME: use matrix-type input source selection */
9287         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9288         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9289         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9290         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9291         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9292         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9293         /* Input mixer2 */
9294         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9295         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9296         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9297         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9298         /* Input mixer3 */
9299         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9300         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9301         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9302         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9303
9304         { }
9305 };
9306
9307 static struct hda_verb alc262_eapd_verbs[] = {
9308         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9309         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9310         { }
9311 };
9312
9313 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9314         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9315         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9316         {}
9317 };
9318
9319 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9320         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9321         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9322         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9323
9324         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9325         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9326         {}
9327 };
9328
9329 static struct hda_verb alc262_sony_unsol_verbs[] = {
9330         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9331         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9332         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9333
9334         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9335         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9336         {}
9337 };
9338
9339 static struct hda_input_mux alc262_dmic_capture_source = {
9340         .num_items = 2,
9341         .items = {
9342                 { "Int DMic", 0x9 },
9343                 { "Mic", 0x0 },
9344         },
9345 };
9346
9347 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9348         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9349         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9350         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9351         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9352         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9353         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9354         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9355         {
9356                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9357                 /* The multiple "Capture Source" controls confuse alsamixer
9358                  * So call somewhat different..
9359                  */
9360                 /* .name = "Capture Source", */
9361                 .name = "Input Source",
9362                 .count = 1,
9363                 .info = alc_mux_enum_info,
9364                 .get = alc_mux_enum_get,
9365                 .put = alc_mux_enum_put,
9366         },
9367         { } /* end */
9368 };
9369
9370 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9371         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9372         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9373         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9374         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9375         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9376         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9377         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9378         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9379         {}
9380 };
9381
9382 static void alc262_dmic_automute(struct hda_codec *codec)
9383 {
9384         unsigned int present;
9385
9386         present = snd_hda_codec_read(codec, 0x18, 0,
9387                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9388         snd_hda_codec_write(codec, 0x22, 0,
9389                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9390 }
9391
9392 /* toggle speaker-output according to the hp-jack state */
9393 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9394 {
9395         unsigned int present;
9396         unsigned char bits;
9397
9398         present = snd_hda_codec_read(codec, 0x15, 0,
9399                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9400         bits = present ? 0 : PIN_OUT;
9401         snd_hda_codec_write(codec, 0x14, 0,
9402                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9403 }
9404
9405
9406
9407 /* unsolicited event for HP jack sensing */
9408 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9409                                        unsigned int res)
9410 {
9411         if ((res >> 26) == ALC880_HP_EVENT)
9412                 alc262_toshiba_s06_speaker_automute(codec);
9413         if ((res >> 26) == ALC880_MIC_EVENT)
9414                 alc262_dmic_automute(codec);
9415
9416 }
9417
9418 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9419 {
9420         alc262_toshiba_s06_speaker_automute(codec);
9421         alc262_dmic_automute(codec);
9422 }
9423
9424 /* mute/unmute internal speaker according to the hp jack and mute state */
9425 static void alc262_hippo_automute(struct hda_codec *codec)
9426 {
9427         struct alc_spec *spec = codec->spec;
9428         unsigned int mute;
9429         unsigned int present;
9430
9431         /* need to execute and sync at first */
9432         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9433         present = snd_hda_codec_read(codec, 0x15, 0,
9434                                      AC_VERB_GET_PIN_SENSE, 0);
9435         spec->jack_present = (present & 0x80000000) != 0;
9436         if (spec->jack_present) {
9437                 /* mute internal speaker */
9438                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9439                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9440         } else {
9441                 /* unmute internal speaker if necessary */
9442                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9443                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9444                                          HDA_AMP_MUTE, mute);
9445         }
9446 }
9447
9448 /* unsolicited event for HP jack sensing */
9449 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9450                                        unsigned int res)
9451 {
9452         if ((res >> 26) != ALC880_HP_EVENT)
9453                 return;
9454         alc262_hippo_automute(codec);
9455 }
9456
9457 static void alc262_hippo1_automute(struct hda_codec *codec)
9458 {
9459         unsigned int mute;
9460         unsigned int present;
9461
9462         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9463         present = snd_hda_codec_read(codec, 0x1b, 0,
9464                                      AC_VERB_GET_PIN_SENSE, 0);
9465         present = (present & 0x80000000) != 0;
9466         if (present) {
9467                 /* mute internal speaker */
9468                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9469                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9470         } else {
9471                 /* unmute internal speaker if necessary */
9472                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9473                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9474                                          HDA_AMP_MUTE, mute);
9475         }
9476 }
9477
9478 /* unsolicited event for HP jack sensing */
9479 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9480                                        unsigned int res)
9481 {
9482         if ((res >> 26) != ALC880_HP_EVENT)
9483                 return;
9484         alc262_hippo1_automute(codec);
9485 }
9486
9487 /*
9488  * nec model
9489  *  0x15 = headphone
9490  *  0x16 = internal speaker
9491  *  0x18 = external mic
9492  */
9493
9494 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9495         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9496         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9497
9498         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9499         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9500         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9501
9502         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9503         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9504         { } /* end */
9505 };
9506
9507 static struct hda_verb alc262_nec_verbs[] = {
9508         /* Unmute Speaker */
9509         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9510
9511         /* Headphone */
9512         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9513         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9514
9515         /* External mic to headphone */
9516         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9517         /* External mic to speaker */
9518         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9519         {}
9520 };
9521
9522 /*
9523  * fujitsu model
9524  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
9525  *  0x1b = port replicator headphone out
9526  */
9527
9528 #define ALC_HP_EVENT    0x37
9529
9530 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9531         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9532         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9533         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9534         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9535         {}
9536 };
9537
9538 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9539         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9540         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9541         {}
9542 };
9543
9544 static struct hda_input_mux alc262_fujitsu_capture_source = {
9545         .num_items = 3,
9546         .items = {
9547                 { "Mic", 0x0 },
9548                 { "Int Mic", 0x1 },
9549                 { "CD", 0x4 },
9550         },
9551 };
9552
9553 static struct hda_input_mux alc262_HP_capture_source = {
9554         .num_items = 5,
9555         .items = {
9556                 { "Mic", 0x0 },
9557                 { "Front Mic", 0x1 },
9558                 { "Line", 0x2 },
9559                 { "CD", 0x4 },
9560                 { "AUX IN", 0x6 },
9561         },
9562 };
9563
9564 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9565         .num_items = 4,
9566         .items = {
9567                 { "Mic", 0x0 },
9568                 { "Front Mic", 0x2 },
9569                 { "Line", 0x1 },
9570                 { "CD", 0x4 },
9571         },
9572 };
9573
9574 /* mute/unmute internal speaker according to the hp jacks and mute state */
9575 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9576 {
9577         struct alc_spec *spec = codec->spec;
9578         unsigned int mute;
9579
9580         if (force || !spec->sense_updated) {
9581                 unsigned int present;
9582                 /* need to execute and sync at first */
9583                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9584                 /* check laptop HP jack */
9585                 present = snd_hda_codec_read(codec, 0x14, 0,
9586                                              AC_VERB_GET_PIN_SENSE, 0);
9587                 /* need to execute and sync at first */
9588                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9589                 /* check docking HP jack */
9590                 present |= snd_hda_codec_read(codec, 0x1b, 0,
9591                                               AC_VERB_GET_PIN_SENSE, 0);
9592                 if (present & AC_PINSENSE_PRESENCE)
9593                         spec->jack_present = 1;
9594                 else
9595                         spec->jack_present = 0;
9596                 spec->sense_updated = 1;
9597         }
9598         /* unmute internal speaker only if both HPs are unplugged and
9599          * master switch is on
9600          */
9601         if (spec->jack_present)
9602                 mute = HDA_AMP_MUTE;
9603         else
9604                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9605         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9606                                  HDA_AMP_MUTE, mute);
9607 }
9608
9609 /* unsolicited event for HP jack sensing */
9610 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9611                                        unsigned int res)
9612 {
9613         if ((res >> 26) != ALC_HP_EVENT)
9614                 return;
9615         alc262_fujitsu_automute(codec, 1);
9616 }
9617
9618 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9619 {
9620         alc262_fujitsu_automute(codec, 1);
9621 }
9622
9623 /* bind volumes of both NID 0x0c and 0x0d */
9624 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9625         .ops = &snd_hda_bind_vol,
9626         .values = {
9627                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9628                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9629                 0
9630         },
9631 };
9632
9633 /* mute/unmute internal speaker according to the hp jack and mute state */
9634 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9635 {
9636         struct alc_spec *spec = codec->spec;
9637         unsigned int mute;
9638
9639         if (force || !spec->sense_updated) {
9640                 unsigned int present_int_hp;
9641                 /* need to execute and sync at first */
9642                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9643                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9644                                         AC_VERB_GET_PIN_SENSE, 0);
9645                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9646                 spec->sense_updated = 1;
9647         }
9648         if (spec->jack_present) {
9649                 /* mute internal speaker */
9650                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9651                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9652                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9653                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9654         } else {
9655                 /* unmute internal speaker if necessary */
9656                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9657                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9658                                          HDA_AMP_MUTE, mute);
9659                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9660                                          HDA_AMP_MUTE, mute);
9661         }
9662 }
9663
9664 /* unsolicited event for HP jack sensing */
9665 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9666                                        unsigned int res)
9667 {
9668         if ((res >> 26) != ALC_HP_EVENT)
9669                 return;
9670         alc262_lenovo_3000_automute(codec, 1);
9671 }
9672
9673 /* bind hp and internal speaker mute (with plug check) */
9674 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9675                                          struct snd_ctl_elem_value *ucontrol)
9676 {
9677         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9678         long *valp = ucontrol->value.integer.value;
9679         int change;
9680
9681         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9682                                                  HDA_AMP_MUTE,
9683                                                  valp ? 0 : HDA_AMP_MUTE);
9684         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9685                                                  HDA_AMP_MUTE,
9686                                                  valp ? 0 : HDA_AMP_MUTE);
9687
9688         if (change)
9689                 alc262_fujitsu_automute(codec, 0);
9690         return change;
9691 }
9692
9693 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9694         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9695         {
9696                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9697                 .name = "Master Playback Switch",
9698                 .info = snd_hda_mixer_amp_switch_info,
9699                 .get = snd_hda_mixer_amp_switch_get,
9700                 .put = alc262_fujitsu_master_sw_put,
9701                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9702         },
9703         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9704         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9705         HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9706         HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9707         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9708         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9709         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9710         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9711         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9712         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9713         { } /* end */
9714 };
9715
9716 /* bind hp and internal speaker mute (with plug check) */
9717 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9718                                          struct snd_ctl_elem_value *ucontrol)
9719 {
9720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9721         long *valp = ucontrol->value.integer.value;
9722         int change;
9723
9724         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9725                                                  HDA_AMP_MUTE,
9726                                                  valp ? 0 : HDA_AMP_MUTE);
9727
9728         if (change)
9729                 alc262_lenovo_3000_automute(codec, 0);
9730         return change;
9731 }
9732
9733 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9734         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9735         {
9736                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9737                 .name = "Master Playback Switch",
9738                 .info = snd_hda_mixer_amp_switch_info,
9739                 .get = snd_hda_mixer_amp_switch_get,
9740                 .put = alc262_lenovo_3000_master_sw_put,
9741                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9742         },
9743         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9744         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9745         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9748         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9749         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9750         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9751         { } /* end */
9752 };
9753
9754 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
9755         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9756         {
9757                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9758                 .name = "Master Playback Switch",
9759                 .info = snd_hda_mixer_amp_switch_info,
9760                 .get = snd_hda_mixer_amp_switch_get,
9761                 .put = alc262_sony_master_sw_put,
9762                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9763         },
9764         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9765         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9766         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9767         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9768         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9769         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9770         { } /* end */
9771 };
9772
9773 /* additional init verbs for Benq laptops */
9774 static struct hda_verb alc262_EAPD_verbs[] = {
9775         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9776         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
9777         {}
9778 };
9779
9780 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9781         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9782         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9783
9784         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9785         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
9786         {}
9787 };
9788
9789 /* Samsung Q1 Ultra Vista model setup */
9790 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9791         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9792         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9793         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9794         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9795         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9796         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9797         { } /* end */
9798 };
9799
9800 static struct hda_verb alc262_ultra_verbs[] = {
9801         /* output mixer */
9802         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9803         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9804         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9805         /* speaker */
9806         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9807         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9808         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9809         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9810         /* HP */
9811         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9812         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9813         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9814         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9815         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9816         /* internal mic */
9817         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9818         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9819         /* ADC, choose mic */
9820         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9821         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9822         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9823         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9824         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9825         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9826         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9827         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9828         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9829         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9830         {}
9831 };
9832
9833 /* mute/unmute internal speaker according to the hp jack and mute state */
9834 static void alc262_ultra_automute(struct hda_codec *codec)
9835 {
9836         struct alc_spec *spec = codec->spec;
9837         unsigned int mute;
9838
9839         mute = 0;
9840         /* auto-mute only when HP is used as HP */
9841         if (!spec->cur_mux[0]) {
9842                 unsigned int present;
9843                 /* need to execute and sync at first */
9844                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9845                 present = snd_hda_codec_read(codec, 0x15, 0,
9846                                              AC_VERB_GET_PIN_SENSE, 0);
9847                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9848                 if (spec->jack_present)
9849                         mute = HDA_AMP_MUTE;
9850         }
9851         /* mute/unmute internal speaker */
9852         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9853                                  HDA_AMP_MUTE, mute);
9854         /* mute/unmute HP */
9855         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9856                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9857 }
9858
9859 /* unsolicited event for HP jack sensing */
9860 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9861                                        unsigned int res)
9862 {
9863         if ((res >> 26) != ALC880_HP_EVENT)
9864                 return;
9865         alc262_ultra_automute(codec);
9866 }
9867
9868 static struct hda_input_mux alc262_ultra_capture_source = {
9869         .num_items = 2,
9870         .items = {
9871                 { "Mic", 0x1 },
9872                 { "Headphone", 0x7 },
9873         },
9874 };
9875
9876 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9877                                      struct snd_ctl_elem_value *ucontrol)
9878 {
9879         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9880         struct alc_spec *spec = codec->spec;
9881         int ret;
9882
9883         ret = alc882_mux_enum_put(kcontrol, ucontrol);
9884         if (!ret)
9885                 return 0;
9886         /* reprogram the HP pin as mic or HP according to the input source */
9887         snd_hda_codec_write_cache(codec, 0x15, 0,
9888                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9889                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9890         alc262_ultra_automute(codec); /* mute/unmute HP */
9891         return ret;
9892 }
9893
9894 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9895         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9896         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9897         {
9898                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9899                 .name = "Capture Source",
9900                 .info = alc882_mux_enum_info,
9901                 .get = alc882_mux_enum_get,
9902                 .put = alc262_ultra_mux_enum_put,
9903         },
9904         { } /* end */
9905 };
9906
9907 /* add playback controls from the parsed DAC table */
9908 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9909                                              const struct auto_pin_cfg *cfg)
9910 {
9911         hda_nid_t nid;
9912         int err;
9913
9914         spec->multiout.num_dacs = 1;    /* only use one dac */
9915         spec->multiout.dac_nids = spec->private_dac_nids;
9916         spec->multiout.dac_nids[0] = 2;
9917
9918         nid = cfg->line_out_pins[0];
9919         if (nid) {
9920                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9921                                   "Front Playback Volume",
9922                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
9923                 if (err < 0)
9924                         return err;
9925                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9926                                   "Front Playback Switch",
9927                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9928                 if (err < 0)
9929                         return err;
9930         }
9931
9932         nid = cfg->speaker_pins[0];
9933         if (nid) {
9934                 if (nid == 0x16) {
9935                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9936                                           "Speaker Playback Volume",
9937                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9938                                                               HDA_OUTPUT));
9939                         if (err < 0)
9940                                 return err;
9941                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9942                                           "Speaker Playback Switch",
9943                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9944                                                               HDA_OUTPUT));
9945                         if (err < 0)
9946                                 return err;
9947                 } else {
9948                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9949                                           "Speaker Playback Switch",
9950                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9951                                                               HDA_OUTPUT));
9952                         if (err < 0)
9953                                 return err;
9954                 }
9955         }
9956         nid = cfg->hp_pins[0];
9957         if (nid) {
9958                 /* spec->multiout.hp_nid = 2; */
9959                 if (nid == 0x16) {
9960                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9961                                           "Headphone Playback Volume",
9962                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9963                                                               HDA_OUTPUT));
9964                         if (err < 0)
9965                                 return err;
9966                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9967                                           "Headphone Playback Switch",
9968                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9969                                                               HDA_OUTPUT));
9970                         if (err < 0)
9971                                 return err;
9972                 } else {
9973                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9974                                           "Headphone Playback Switch",
9975                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9976                                                               HDA_OUTPUT));
9977                         if (err < 0)
9978                                 return err;
9979                 }
9980         }
9981         return 0;
9982 }
9983
9984 /* identical with ALC880 */
9985 #define alc262_auto_create_analog_input_ctls \
9986         alc880_auto_create_analog_input_ctls
9987
9988 /*
9989  * generic initialization of ADC, input mixers and output mixers
9990  */
9991 static struct hda_verb alc262_volume_init_verbs[] = {
9992         /*
9993          * Unmute ADC0-2 and set the default input to mic-in
9994          */
9995         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9996         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9997         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9998         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9999         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10000         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10001
10002         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10003          * mixer widget
10004          * Note: PASD motherboards uses the Line In 2 as the input for
10005          * front panel mic (mic 2)
10006          */
10007         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10008         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10009         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10010         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10011         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10012         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10013
10014         /*
10015          * Set up output mixers (0x0c - 0x0f)
10016          */
10017         /* set vol=0 to output mixers */
10018         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10019         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10020         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10021
10022         /* set up input amps for analog loopback */
10023         /* Amp Indices: DAC = 0, mixer = 1 */
10024         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10025         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10026         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10027         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10028         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10029         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10030
10031         /* FIXME: use matrix-type input source selection */
10032         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10033         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10034         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10035         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10036         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10037         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10038         /* Input mixer2 */
10039         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10040         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10041         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10042         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10043         /* Input mixer3 */
10044         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10045         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10046         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10047         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10048
10049         { }
10050 };
10051
10052 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10053         /*
10054          * Unmute ADC0-2 and set the default input to mic-in
10055          */
10056         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10057         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10058         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10059         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10060         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10061         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10062
10063         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10064          * mixer widget
10065          * Note: PASD motherboards uses the Line In 2 as the input for
10066          * front panel mic (mic 2)
10067          */
10068         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10069         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10070         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10071         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10072         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10073         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10074         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10075         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10076
10077         /*
10078          * Set up output mixers (0x0c - 0x0e)
10079          */
10080         /* set vol=0 to output mixers */
10081         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10082         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10083         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10084
10085         /* set up input amps for analog loopback */
10086         /* Amp Indices: DAC = 0, mixer = 1 */
10087         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10088         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10089         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10090         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10091         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10092         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10093
10094         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10095         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10096         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10097
10098         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10099         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10100
10101         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10102         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10103
10104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10105         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10106         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10107         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10108         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10109
10110         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10111         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10112         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10113         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10114         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10115         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10116
10117
10118         /* FIXME: use matrix-type input source selection */
10119         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10120         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10121         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10122         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10123         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10124         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10125         /* Input mixer2 */
10126         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10127         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10128         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10129         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10130         /* Input mixer3 */
10131         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10132         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10133         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10134         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10135
10136         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10137
10138         { }
10139 };
10140
10141 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10142         /*
10143          * Unmute ADC0-2 and set the default input to mic-in
10144          */
10145         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10146         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10147         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10148         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10149         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10150         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10151
10152         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10153          * mixer widget
10154          * Note: PASD motherboards uses the Line In 2 as the input for front
10155          * panel mic (mic 2)
10156          */
10157         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10158         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10159         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10160         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10161         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10162         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10163         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10164         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10165         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10166         /*
10167          * Set up output mixers (0x0c - 0x0e)
10168          */
10169         /* set vol=0 to output mixers */
10170         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10171         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10172         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10173
10174         /* set up input amps for analog loopback */
10175         /* Amp Indices: DAC = 0, mixer = 1 */
10176         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10177         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10178         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10179         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10180         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10181         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10182
10183
10184         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10185         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10186         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10187         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10188         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10189         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10190         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10191
10192         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10193         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10194
10195         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10196         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10197
10198         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10199         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10200         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10201         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10202         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10203         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10204
10205         /* FIXME: use matrix-type input source selection */
10206         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10207         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10208         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10210         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10212         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10213         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10214         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10215         /* Input mixer2 */
10216         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10217         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10218         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10219         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10220         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10221         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10222         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10223         /* Input mixer3 */
10224         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10225         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10226         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10227         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10228         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10229         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10230         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10231
10232         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10233
10234         { }
10235 };
10236
10237 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10238
10239         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10240         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10241         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10242
10243         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10244         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10245         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10246         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10247
10248         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10249         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10250         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10251         {}
10252 };
10253
10254
10255 #ifdef CONFIG_SND_HDA_POWER_SAVE
10256 #define alc262_loopbacks        alc880_loopbacks
10257 #endif
10258
10259 /* pcm configuration: identiacal with ALC880 */
10260 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10261 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10262 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10263 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10264
10265 /*
10266  * BIOS auto configuration
10267  */
10268 static int alc262_parse_auto_config(struct hda_codec *codec)
10269 {
10270         struct alc_spec *spec = codec->spec;
10271         int err;
10272         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10273
10274         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10275                                            alc262_ignore);
10276         if (err < 0)
10277                 return err;
10278         if (!spec->autocfg.line_outs)
10279                 return 0; /* can't find valid BIOS pin config */
10280         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10281         if (err < 0)
10282                 return err;
10283         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10284         if (err < 0)
10285                 return err;
10286
10287         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10288
10289         if (spec->autocfg.dig_out_pin)
10290                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10291         if (spec->autocfg.dig_in_pin)
10292                 spec->dig_in_nid = ALC262_DIGIN_NID;
10293
10294         if (spec->kctl_alloc)
10295                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10296
10297         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
10298         spec->num_mux_defs = 1;
10299         spec->input_mux = &spec->private_imux;
10300
10301         err = alc_auto_add_mic_boost(codec);
10302         if (err < 0)
10303                 return err;
10304
10305         return 1;
10306 }
10307
10308 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10309 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10310 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10311 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10312
10313
10314 /* init callback for auto-configuration model -- overriding the default init */
10315 static void alc262_auto_init(struct hda_codec *codec)
10316 {
10317         struct alc_spec *spec = codec->spec;
10318         alc262_auto_init_multi_out(codec);
10319         alc262_auto_init_hp_out(codec);
10320         alc262_auto_init_analog_input(codec);
10321         alc262_auto_init_input_src(codec);
10322         if (spec->unsol_event)
10323                 alc_inithook(codec);
10324 }
10325
10326 /*
10327  * configuration and preset
10328  */
10329 static const char *alc262_models[ALC262_MODEL_LAST] = {
10330         [ALC262_BASIC]          = "basic",
10331         [ALC262_HIPPO]          = "hippo",
10332         [ALC262_HIPPO_1]        = "hippo_1",
10333         [ALC262_FUJITSU]        = "fujitsu",
10334         [ALC262_HP_BPC]         = "hp-bpc",
10335         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10336         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10337         [ALC262_HP_RP5700]      = "hp-rp5700",
10338         [ALC262_BENQ_ED8]       = "benq",
10339         [ALC262_BENQ_T31]       = "benq-t31",
10340         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10341         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10342         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10343         [ALC262_ULTRA]          = "ultra",
10344         [ALC262_LENOVO_3000]    = "lenovo-3000",
10345         [ALC262_NEC]            = "nec",
10346         [ALC262_AUTO]           = "auto",
10347 };
10348
10349 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10350         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10351         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10352         SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
10353         SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
10354         SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
10355         SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
10356         SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
10357         SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
10358         SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
10359         SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
10360         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10361         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10362         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10363         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10364         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10365         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10366         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10367         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10368         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10369         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10370         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10371         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10372                       ALC262_HP_TC_T5735),
10373         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10374         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10375         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10376         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10377         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10378         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10379         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10380                       ALC262_TOSHIBA_RX1),
10381         SND_PCI_QUIRK(0x1179, 0x0268, "Toshiba S06", ALC262_TOSHIBA_S06),
10382         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10383         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10384         SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
10385         SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
10386         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10387         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10388         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10389         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10390         {}
10391 };
10392
10393 static struct alc_config_preset alc262_presets[] = {
10394         [ALC262_BASIC] = {
10395                 .mixers = { alc262_base_mixer },
10396                 .init_verbs = { alc262_init_verbs },
10397                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10398                 .dac_nids = alc262_dac_nids,
10399                 .hp_nid = 0x03,
10400                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10401                 .channel_mode = alc262_modes,
10402                 .input_mux = &alc262_capture_source,
10403         },
10404         [ALC262_HIPPO] = {
10405                 .mixers = { alc262_base_mixer },
10406                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10407                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10408                 .dac_nids = alc262_dac_nids,
10409                 .hp_nid = 0x03,
10410                 .dig_out_nid = ALC262_DIGOUT_NID,
10411                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10412                 .channel_mode = alc262_modes,
10413                 .input_mux = &alc262_capture_source,
10414                 .unsol_event = alc262_hippo_unsol_event,
10415                 .init_hook = alc262_hippo_automute,
10416         },
10417         [ALC262_HIPPO_1] = {
10418                 .mixers = { alc262_hippo1_mixer },
10419                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10420                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10421                 .dac_nids = alc262_dac_nids,
10422                 .hp_nid = 0x02,
10423                 .dig_out_nid = ALC262_DIGOUT_NID,
10424                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10425                 .channel_mode = alc262_modes,
10426                 .input_mux = &alc262_capture_source,
10427                 .unsol_event = alc262_hippo1_unsol_event,
10428                 .init_hook = alc262_hippo1_automute,
10429         },
10430         [ALC262_FUJITSU] = {
10431                 .mixers = { alc262_fujitsu_mixer },
10432                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10433                                 alc262_fujitsu_unsol_verbs },
10434                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10435                 .dac_nids = alc262_dac_nids,
10436                 .hp_nid = 0x03,
10437                 .dig_out_nid = ALC262_DIGOUT_NID,
10438                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10439                 .channel_mode = alc262_modes,
10440                 .input_mux = &alc262_fujitsu_capture_source,
10441                 .unsol_event = alc262_fujitsu_unsol_event,
10442                 .init_hook = alc262_fujitsu_init_hook,
10443         },
10444         [ALC262_HP_BPC] = {
10445                 .mixers = { alc262_HP_BPC_mixer },
10446                 .init_verbs = { alc262_HP_BPC_init_verbs },
10447                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10448                 .dac_nids = alc262_dac_nids,
10449                 .hp_nid = 0x03,
10450                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10451                 .channel_mode = alc262_modes,
10452                 .input_mux = &alc262_HP_capture_source,
10453                 .unsol_event = alc262_hp_bpc_unsol_event,
10454                 .init_hook = alc262_hp_bpc_automute,
10455         },
10456         [ALC262_HP_BPC_D7000_WF] = {
10457                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10458                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10459                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10460                 .dac_nids = alc262_dac_nids,
10461                 .hp_nid = 0x03,
10462                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10463                 .channel_mode = alc262_modes,
10464                 .input_mux = &alc262_HP_D7000_capture_source,
10465                 .unsol_event = alc262_hp_wildwest_unsol_event,
10466                 .init_hook = alc262_hp_wildwest_automute,
10467         },
10468         [ALC262_HP_BPC_D7000_WL] = {
10469                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10470                             alc262_HP_BPC_WildWest_option_mixer },
10471                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10472                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10473                 .dac_nids = alc262_dac_nids,
10474                 .hp_nid = 0x03,
10475                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10476                 .channel_mode = alc262_modes,
10477                 .input_mux = &alc262_HP_D7000_capture_source,
10478                 .unsol_event = alc262_hp_wildwest_unsol_event,
10479                 .init_hook = alc262_hp_wildwest_automute,
10480         },
10481         [ALC262_HP_TC_T5735] = {
10482                 .mixers = { alc262_hp_t5735_mixer },
10483                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10484                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10485                 .dac_nids = alc262_dac_nids,
10486                 .hp_nid = 0x03,
10487                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10488                 .channel_mode = alc262_modes,
10489                 .input_mux = &alc262_capture_source,
10490                 .unsol_event = alc262_hp_t5735_unsol_event,
10491                 .init_hook = alc262_hp_t5735_init_hook,
10492         },
10493         [ALC262_HP_RP5700] = {
10494                 .mixers = { alc262_hp_rp5700_mixer },
10495                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10496                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10497                 .dac_nids = alc262_dac_nids,
10498                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10499                 .channel_mode = alc262_modes,
10500                 .input_mux = &alc262_hp_rp5700_capture_source,
10501         },
10502         [ALC262_BENQ_ED8] = {
10503                 .mixers = { alc262_base_mixer },
10504                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10505                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10506                 .dac_nids = alc262_dac_nids,
10507                 .hp_nid = 0x03,
10508                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10509                 .channel_mode = alc262_modes,
10510                 .input_mux = &alc262_capture_source,
10511         },
10512         [ALC262_SONY_ASSAMD] = {
10513                 .mixers = { alc262_sony_mixer },
10514                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10515                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10516                 .dac_nids = alc262_dac_nids,
10517                 .hp_nid = 0x02,
10518                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10519                 .channel_mode = alc262_modes,
10520                 .input_mux = &alc262_capture_source,
10521                 .unsol_event = alc262_hippo_unsol_event,
10522                 .init_hook = alc262_hippo_automute,
10523         },
10524         [ALC262_BENQ_T31] = {
10525                 .mixers = { alc262_benq_t31_mixer },
10526                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10527                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10528                 .dac_nids = alc262_dac_nids,
10529                 .hp_nid = 0x03,
10530                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10531                 .channel_mode = alc262_modes,
10532                 .input_mux = &alc262_capture_source,
10533                 .unsol_event = alc262_hippo_unsol_event,
10534                 .init_hook = alc262_hippo_automute,
10535         },
10536         [ALC262_ULTRA] = {
10537                 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
10538                 .init_verbs = { alc262_ultra_verbs },
10539                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10540                 .dac_nids = alc262_dac_nids,
10541                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10542                 .channel_mode = alc262_modes,
10543                 .input_mux = &alc262_ultra_capture_source,
10544                 .adc_nids = alc262_adc_nids, /* ADC0 */
10545                 .capsrc_nids = alc262_capsrc_nids,
10546                 .num_adc_nids = 1, /* single ADC */
10547                 .unsol_event = alc262_ultra_unsol_event,
10548                 .init_hook = alc262_ultra_automute,
10549         },
10550         [ALC262_LENOVO_3000] = {
10551                 .mixers = { alc262_lenovo_3000_mixer },
10552                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10553                                 alc262_lenovo_3000_unsol_verbs },
10554                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10555                 .dac_nids = alc262_dac_nids,
10556                 .hp_nid = 0x03,
10557                 .dig_out_nid = ALC262_DIGOUT_NID,
10558                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10559                 .channel_mode = alc262_modes,
10560                 .input_mux = &alc262_fujitsu_capture_source,
10561                 .unsol_event = alc262_lenovo_3000_unsol_event,
10562         },
10563         [ALC262_NEC] = {
10564                 .mixers = { alc262_nec_mixer },
10565                 .init_verbs = { alc262_nec_verbs },
10566                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10567                 .dac_nids = alc262_dac_nids,
10568                 .hp_nid = 0x03,
10569                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10570                 .channel_mode = alc262_modes,
10571                 .input_mux = &alc262_capture_source,
10572         },
10573         [ALC262_TOSHIBA_S06] = {
10574                 .mixers = { alc262_toshiba_s06_mixer },
10575                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10576                                                         alc262_eapd_verbs },
10577                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10578                 .capsrc_nids = alc262_dmic_capsrc_nids,
10579                 .dac_nids = alc262_dac_nids,
10580                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10581                 .dig_out_nid = ALC262_DIGOUT_NID,
10582                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10583                 .channel_mode = alc262_modes,
10584                 .input_mux = &alc262_dmic_capture_source,
10585                 .unsol_event = alc262_toshiba_s06_unsol_event,
10586                 .init_hook = alc262_toshiba_s06_init_hook,
10587         },
10588         [ALC262_TOSHIBA_RX1] = {
10589                 .mixers = { alc262_toshiba_rx1_mixer },
10590                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10591                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10592                 .dac_nids = alc262_dac_nids,
10593                 .hp_nid = 0x03,
10594                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10595                 .channel_mode = alc262_modes,
10596                 .input_mux = &alc262_capture_source,
10597                 .unsol_event = alc262_hippo_unsol_event,
10598                 .init_hook = alc262_hippo_automute,
10599         },
10600 };
10601
10602 static int patch_alc262(struct hda_codec *codec)
10603 {
10604         struct alc_spec *spec;
10605         int board_config;
10606         int err;
10607
10608         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10609         if (spec == NULL)
10610                 return -ENOMEM;
10611
10612         codec->spec = spec;
10613 #if 0
10614         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
10615          * under-run
10616          */
10617         {
10618         int tmp;
10619         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10620         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
10621         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10622         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
10623         }
10624 #endif
10625
10626         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10627
10628         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
10629                                                   alc262_models,
10630                                                   alc262_cfg_tbl);
10631
10632         if (board_config < 0) {
10633                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
10634                        "trying auto-probe from BIOS...\n");
10635                 board_config = ALC262_AUTO;
10636         }
10637
10638         if (board_config == ALC262_AUTO) {
10639                 /* automatic parse from the BIOS config */
10640                 err = alc262_parse_auto_config(codec);
10641                 if (err < 0) {
10642                         alc_free(codec);
10643                         return err;
10644                 } else if (!err) {
10645                         printk(KERN_INFO
10646                                "hda_codec: Cannot set up configuration "
10647                                "from BIOS.  Using base mode...\n");
10648                         board_config = ALC262_BASIC;
10649                 }
10650         }
10651
10652         if (board_config != ALC262_AUTO)
10653                 setup_preset(spec, &alc262_presets[board_config]);
10654
10655         spec->stream_name_analog = "ALC262 Analog";
10656         spec->stream_analog_playback = &alc262_pcm_analog_playback;
10657         spec->stream_analog_capture = &alc262_pcm_analog_capture;
10658
10659         spec->stream_name_digital = "ALC262 Digital";
10660         spec->stream_digital_playback = &alc262_pcm_digital_playback;
10661         spec->stream_digital_capture = &alc262_pcm_digital_capture;
10662
10663         if (!spec->adc_nids && spec->input_mux) {
10664                 /* check whether NID 0x07 is valid */
10665                 unsigned int wcap = get_wcaps(codec, 0x07);
10666
10667                 /* get type */
10668                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10669                 if (wcap != AC_WID_AUD_IN) {
10670                         spec->adc_nids = alc262_adc_nids_alt;
10671                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
10672                         spec->capsrc_nids = alc262_capsrc_nids_alt;
10673                         spec->mixers[spec->num_mixers] =
10674                                 alc262_capture_alt_mixer;
10675                         spec->num_mixers++;
10676                 } else {
10677                         spec->adc_nids = alc262_adc_nids;
10678                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
10679                         spec->capsrc_nids = alc262_capsrc_nids;
10680                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
10681                         spec->num_mixers++;
10682                 }
10683         }
10684
10685         spec->vmaster_nid = 0x0c;
10686
10687         codec->patch_ops = alc_patch_ops;
10688         if (board_config == ALC262_AUTO)
10689                 spec->init_hook = alc262_auto_init;
10690 #ifdef CONFIG_SND_HDA_POWER_SAVE
10691         if (!spec->loopback.amplist)
10692                 spec->loopback.amplist = alc262_loopbacks;
10693 #endif
10694
10695         return 0;
10696 }
10697
10698 /*
10699  *  ALC268 channel source setting (2 channel)
10700  */
10701 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
10702 #define alc268_modes            alc260_modes
10703
10704 static hda_nid_t alc268_dac_nids[2] = {
10705         /* front, hp */
10706         0x02, 0x03
10707 };
10708
10709 static hda_nid_t alc268_adc_nids[2] = {
10710         /* ADC0-1 */
10711         0x08, 0x07
10712 };
10713
10714 static hda_nid_t alc268_adc_nids_alt[1] = {
10715         /* ADC0 */
10716         0x08
10717 };
10718
10719 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10720
10721 static struct snd_kcontrol_new alc268_base_mixer[] = {
10722         /* output mixer control */
10723         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10724         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10725         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10726         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10727         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10728         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10729         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10730         { }
10731 };
10732
10733 /* bind Beep switches of both NID 0x0f and 0x10 */
10734 static struct hda_bind_ctls alc268_bind_beep_sw = {
10735         .ops = &snd_hda_bind_sw,
10736         .values = {
10737                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10738                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10739                 0
10740         },
10741 };
10742
10743 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10744         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10745         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10746         { }
10747 };
10748
10749 static struct hda_verb alc268_eapd_verbs[] = {
10750         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10751         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10752         { }
10753 };
10754
10755 /* Toshiba specific */
10756 #define alc268_toshiba_automute alc262_hippo_automute
10757
10758 static struct hda_verb alc268_toshiba_verbs[] = {
10759         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10760         { } /* end */
10761 };
10762
10763 static struct hda_input_mux alc268_acer_lc_capture_source = {
10764         .num_items = 2,
10765         .items = {
10766                 { "i-Mic", 0x6 },
10767                 { "E-Mic", 0x0 },
10768         },
10769 };
10770
10771 /* Acer specific */
10772 /* bind volumes of both NID 0x02 and 0x03 */
10773 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10774         .ops = &snd_hda_bind_vol,
10775         .values = {
10776                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10777                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10778                 0
10779         },
10780 };
10781
10782 /* mute/unmute internal speaker according to the hp jack and mute state */
10783 static void alc268_acer_automute(struct hda_codec *codec, int force)
10784 {
10785         struct alc_spec *spec = codec->spec;
10786         unsigned int mute;
10787
10788         if (force || !spec->sense_updated) {
10789                 unsigned int present;
10790                 present = snd_hda_codec_read(codec, 0x14, 0,
10791                                          AC_VERB_GET_PIN_SENSE, 0);
10792                 spec->jack_present = (present & 0x80000000) != 0;
10793                 spec->sense_updated = 1;
10794         }
10795         if (spec->jack_present)
10796                 mute = HDA_AMP_MUTE; /* mute internal speaker */
10797         else /* unmute internal speaker if necessary */
10798                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10799         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10800                                  HDA_AMP_MUTE, mute);
10801 }
10802
10803
10804 /* bind hp and internal speaker mute (with plug check) */
10805 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10806                                      struct snd_ctl_elem_value *ucontrol)
10807 {
10808         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10809         long *valp = ucontrol->value.integer.value;
10810         int change;
10811
10812         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10813                                           HDA_AMP_MUTE,
10814                                           valp[0] ? 0 : HDA_AMP_MUTE);
10815         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10816                                            HDA_AMP_MUTE,
10817                                            valp[1] ? 0 : HDA_AMP_MUTE);
10818         if (change)
10819                 alc268_acer_automute(codec, 0);
10820         return change;
10821 }
10822
10823 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
10824         /* output mixer control */
10825         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10826         {
10827                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10828                 .name = "Master Playback Switch",
10829                 .info = snd_hda_mixer_amp_switch_info,
10830                 .get = snd_hda_mixer_amp_switch_get,
10831                 .put = alc268_acer_master_sw_put,
10832                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10833         },
10834         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
10835         { }
10836 };
10837
10838 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10839         /* output mixer control */
10840         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10841         {
10842                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10843                 .name = "Master Playback Switch",
10844                 .info = snd_hda_mixer_amp_switch_info,
10845                 .get = snd_hda_mixer_amp_switch_get,
10846                 .put = alc268_acer_master_sw_put,
10847                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10848         },
10849         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10850         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10851         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10852         { }
10853 };
10854
10855 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
10856         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10857         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10858         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10859         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10860         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
10861         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
10862         { }
10863 };
10864
10865 static struct hda_verb alc268_acer_verbs[] = {
10866         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10867         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10868         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10869         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10870         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10871         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10872         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10873         { }
10874 };
10875
10876 /* unsolicited event for HP jack sensing */
10877 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10878                                        unsigned int res)
10879 {
10880         if ((res >> 26) != ALC880_HP_EVENT)
10881                 return;
10882         alc268_toshiba_automute(codec);
10883 }
10884
10885 static void alc268_acer_unsol_event(struct hda_codec *codec,
10886                                        unsigned int res)
10887 {
10888         if ((res >> 26) != ALC880_HP_EVENT)
10889                 return;
10890         alc268_acer_automute(codec, 1);
10891 }
10892
10893 static void alc268_acer_init_hook(struct hda_codec *codec)
10894 {
10895         alc268_acer_automute(codec, 1);
10896 }
10897
10898 /* toggle speaker-output according to the hp-jack state */
10899 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
10900 {
10901         unsigned int present;
10902         unsigned char bits;
10903
10904         present = snd_hda_codec_read(codec, 0x15, 0,
10905                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10906         bits = present ? AMP_IN_MUTE(0) : 0;
10907         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
10908                                 AMP_IN_MUTE(0), bits);
10909         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
10910                                 AMP_IN_MUTE(0), bits);
10911 }
10912
10913
10914 static void alc268_acer_mic_automute(struct hda_codec *codec)
10915 {
10916         unsigned int present;
10917
10918         present = snd_hda_codec_read(codec, 0x18, 0,
10919                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10920         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
10921                             present ? 0x0 : 0x6);
10922 }
10923
10924 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
10925                                     unsigned int res)
10926 {
10927         if ((res >> 26) == ALC880_HP_EVENT)
10928                 alc268_aspire_one_speaker_automute(codec);
10929         if ((res >> 26) == ALC880_MIC_EVENT)
10930                 alc268_acer_mic_automute(codec);
10931 }
10932
10933 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
10934 {
10935         alc268_aspire_one_speaker_automute(codec);
10936         alc268_acer_mic_automute(codec);
10937 }
10938
10939 static struct snd_kcontrol_new alc268_dell_mixer[] = {
10940         /* output mixer control */
10941         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10942         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10943         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10945         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10946         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10947         { }
10948 };
10949
10950 static struct hda_verb alc268_dell_verbs[] = {
10951         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10952         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10953         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10954         { }
10955 };
10956
10957 /* mute/unmute internal speaker according to the hp jack and mute state */
10958 static void alc268_dell_automute(struct hda_codec *codec)
10959 {
10960         unsigned int present;
10961         unsigned int mute;
10962
10963         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
10964         if (present & 0x80000000)
10965                 mute = HDA_AMP_MUTE;
10966         else
10967                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
10968         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10969                                  HDA_AMP_MUTE, mute);
10970 }
10971
10972 static void alc268_dell_unsol_event(struct hda_codec *codec,
10973                                     unsigned int res)
10974 {
10975         if ((res >> 26) != ALC880_HP_EVENT)
10976                 return;
10977         alc268_dell_automute(codec);
10978 }
10979
10980 #define alc268_dell_init_hook   alc268_dell_automute
10981
10982 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
10983         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10984         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10985         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10986         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10987         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10988         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
10989         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
10990         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10991         { }
10992 };
10993
10994 static struct hda_verb alc267_quanta_il1_verbs[] = {
10995         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10996         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
10997         { }
10998 };
10999
11000 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11001 {
11002         unsigned int present;
11003
11004         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11005                 & AC_PINSENSE_PRESENCE;
11006         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11007                             present ? 0 : PIN_OUT);
11008 }
11009
11010 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11011 {
11012         unsigned int present;
11013
11014         present = snd_hda_codec_read(codec, 0x18, 0,
11015                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11016         snd_hda_codec_write(codec, 0x23, 0,
11017                             AC_VERB_SET_CONNECT_SEL,
11018                             present ? 0x00 : 0x01);
11019 }
11020
11021 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11022 {
11023         alc267_quanta_il1_hp_automute(codec);
11024         alc267_quanta_il1_mic_automute(codec);
11025 }
11026
11027 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11028                                            unsigned int res)
11029 {
11030         switch (res >> 26) {
11031         case ALC880_HP_EVENT:
11032                 alc267_quanta_il1_hp_automute(codec);
11033                 break;
11034         case ALC880_MIC_EVENT:
11035                 alc267_quanta_il1_mic_automute(codec);
11036                 break;
11037         }
11038 }
11039
11040 /*
11041  * generic initialization of ADC, input mixers and output mixers
11042  */
11043 static struct hda_verb alc268_base_init_verbs[] = {
11044         /* Unmute DAC0-1 and set vol = 0 */
11045         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11046         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11047         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11048         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11049         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11050         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11051
11052         /*
11053          * Set up output mixers (0x0c - 0x0e)
11054          */
11055         /* set vol=0 to output mixers */
11056         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11057         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11058         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11059         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11060
11061         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11062         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11063
11064         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11065         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11066         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11067         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11068         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11069         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11070         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11071         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11072
11073         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11074         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11075         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11076         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11077         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11078         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11079         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11080
11081         /* set PCBEEP vol = 0, mute connections */
11082         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11083         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11084         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11085
11086         /* Unmute Selector 23h,24h and set the default input to mic-in */
11087
11088         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11089         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11090         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11091         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11092
11093         { }
11094 };
11095
11096 /*
11097  * generic initialization of ADC, input mixers and output mixers
11098  */
11099 static struct hda_verb alc268_volume_init_verbs[] = {
11100         /* set output DAC */
11101         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11102         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11103         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11104         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11105
11106         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11107         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11108         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11109         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11110         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11111
11112         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11113         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11114         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11115         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11116         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11117
11118         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11119         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11120         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11121         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11122
11123         /* set PCBEEP vol = 0, mute connections */
11124         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11125         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11126         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11127
11128         { }
11129 };
11130
11131 #define alc268_mux_enum_info alc_mux_enum_info
11132 #define alc268_mux_enum_get alc_mux_enum_get
11133 #define alc268_mux_enum_put alc_mux_enum_put
11134
11135 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11136         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11137         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11138         {
11139                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11140                 /* The multiple "Capture Source" controls confuse alsamixer
11141                  * So call somewhat different..
11142                  */
11143                 /* .name = "Capture Source", */
11144                 .name = "Input Source",
11145                 .count = 1,
11146                 .info = alc268_mux_enum_info,
11147                 .get = alc268_mux_enum_get,
11148                 .put = alc268_mux_enum_put,
11149         },
11150         { } /* end */
11151 };
11152
11153 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11154         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11155         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11156         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11157         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11158         {
11159                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11160                 /* The multiple "Capture Source" controls confuse alsamixer
11161                  * So call somewhat different..
11162                  */
11163                 /* .name = "Capture Source", */
11164                 .name = "Input Source",
11165                 .count = 2,
11166                 .info = alc268_mux_enum_info,
11167                 .get = alc268_mux_enum_get,
11168                 .put = alc268_mux_enum_put,
11169         },
11170         { } /* end */
11171 };
11172
11173 static struct hda_input_mux alc268_capture_source = {
11174         .num_items = 4,
11175         .items = {
11176                 { "Mic", 0x0 },
11177                 { "Front Mic", 0x1 },
11178                 { "Line", 0x2 },
11179                 { "CD", 0x3 },
11180         },
11181 };
11182
11183 static struct hda_input_mux alc268_acer_capture_source = {
11184         .num_items = 3,
11185         .items = {
11186                 { "Mic", 0x0 },
11187                 { "Internal Mic", 0x6 },
11188                 { "Line", 0x2 },
11189         },
11190 };
11191
11192 #ifdef CONFIG_SND_DEBUG
11193 static struct snd_kcontrol_new alc268_test_mixer[] = {
11194         /* Volume widgets */
11195         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11196         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11197         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11198         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11199         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11200         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11201         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11202         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11203         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11204         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11205         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11206         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11207         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11208         /* The below appears problematic on some hardwares */
11209         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11210         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11211         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11212         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11213         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11214
11215         /* Modes for retasking pin widgets */
11216         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11217         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11218         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11219         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11220
11221         /* Controls for GPIO pins, assuming they are configured as outputs */
11222         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11223         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11224         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11225         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11226
11227         /* Switches to allow the digital SPDIF output pin to be enabled.
11228          * The ALC268 does not have an SPDIF input.
11229          */
11230         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11231
11232         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11233          * this output to turn on an external amplifier.
11234          */
11235         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11236         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11237
11238         { } /* end */
11239 };
11240 #endif
11241
11242 /* create input playback/capture controls for the given pin */
11243 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11244                                     const char *ctlname, int idx)
11245 {
11246         char name[32];
11247         int err;
11248
11249         sprintf(name, "%s Playback Volume", ctlname);
11250         if (nid == 0x14) {
11251                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11252                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11253                                                       HDA_OUTPUT));
11254                 if (err < 0)
11255                         return err;
11256         } else if (nid == 0x15) {
11257                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11258                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11259                                                       HDA_OUTPUT));
11260                 if (err < 0)
11261                         return err;
11262         } else
11263                 return -1;
11264         sprintf(name, "%s Playback Switch", ctlname);
11265         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11266                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11267         if (err < 0)
11268                 return err;
11269         return 0;
11270 }
11271
11272 /* add playback controls from the parsed DAC table */
11273 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11274                                              const struct auto_pin_cfg *cfg)
11275 {
11276         hda_nid_t nid;
11277         int err;
11278
11279         spec->multiout.num_dacs = 2;    /* only use one dac */
11280         spec->multiout.dac_nids = spec->private_dac_nids;
11281         spec->multiout.dac_nids[0] = 2;
11282         spec->multiout.dac_nids[1] = 3;
11283
11284         nid = cfg->line_out_pins[0];
11285         if (nid)
11286                 alc268_new_analog_output(spec, nid, "Front", 0);
11287
11288         nid = cfg->speaker_pins[0];
11289         if (nid == 0x1d) {
11290                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11291                                   "Speaker Playback Volume",
11292                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11293                 if (err < 0)
11294                         return err;
11295         }
11296         nid = cfg->hp_pins[0];
11297         if (nid)
11298                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11299
11300         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11301         if (nid == 0x16) {
11302                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11303                                   "Mono Playback Switch",
11304                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11305                 if (err < 0)
11306                         return err;
11307         }
11308         return 0;
11309 }
11310
11311 /* create playback/capture controls for input pins */
11312 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11313                                                 const struct auto_pin_cfg *cfg)
11314 {
11315         struct hda_input_mux *imux = &spec->private_imux;
11316         int i, idx1;
11317
11318         for (i = 0; i < AUTO_PIN_LAST; i++) {
11319                 switch(cfg->input_pins[i]) {
11320                 case 0x18:
11321                         idx1 = 0;       /* Mic 1 */
11322                         break;
11323                 case 0x19:
11324                         idx1 = 1;       /* Mic 2 */
11325                         break;
11326                 case 0x1a:
11327                         idx1 = 2;       /* Line In */
11328                         break;
11329                 case 0x1c:
11330                         idx1 = 3;       /* CD */
11331                         break;
11332                 case 0x12:
11333                 case 0x13:
11334                         idx1 = 6;       /* digital mics */
11335                         break;
11336                 default:
11337                         continue;
11338                 }
11339                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11340                 imux->items[imux->num_items].index = idx1;
11341                 imux->num_items++;
11342         }
11343         return 0;
11344 }
11345
11346 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11347 {
11348         struct alc_spec *spec = codec->spec;
11349         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11350         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11351         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11352         unsigned int    dac_vol1, dac_vol2;
11353
11354         if (speaker_nid) {
11355                 snd_hda_codec_write(codec, speaker_nid, 0,
11356                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11357                 snd_hda_codec_write(codec, 0x0f, 0,
11358                                     AC_VERB_SET_AMP_GAIN_MUTE,
11359                                     AMP_IN_UNMUTE(1));
11360                 snd_hda_codec_write(codec, 0x10, 0,
11361                                     AC_VERB_SET_AMP_GAIN_MUTE,
11362                                     AMP_IN_UNMUTE(1));
11363         } else {
11364                 snd_hda_codec_write(codec, 0x0f, 0,
11365                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11366                 snd_hda_codec_write(codec, 0x10, 0,
11367                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11368         }
11369
11370         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11371         if (line_nid == 0x14)
11372                 dac_vol2 = AMP_OUT_ZERO;
11373         else if (line_nid == 0x15)
11374                 dac_vol1 = AMP_OUT_ZERO;
11375         if (hp_nid == 0x14)
11376                 dac_vol2 = AMP_OUT_ZERO;
11377         else if (hp_nid == 0x15)
11378                 dac_vol1 = AMP_OUT_ZERO;
11379         if (line_nid != 0x16 || hp_nid != 0x16 ||
11380             spec->autocfg.line_out_pins[1] != 0x16 ||
11381             spec->autocfg.line_out_pins[2] != 0x16)
11382                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11383
11384         snd_hda_codec_write(codec, 0x02, 0,
11385                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11386         snd_hda_codec_write(codec, 0x03, 0,
11387                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11388 }
11389
11390 /* pcm configuration: identiacal with ALC880 */
11391 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11392 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11393 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11394 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11395
11396 /*
11397  * BIOS auto configuration
11398  */
11399 static int alc268_parse_auto_config(struct hda_codec *codec)
11400 {
11401         struct alc_spec *spec = codec->spec;
11402         int err;
11403         static hda_nid_t alc268_ignore[] = { 0 };
11404
11405         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11406                                            alc268_ignore);
11407         if (err < 0)
11408                 return err;
11409         if (!spec->autocfg.line_outs)
11410                 return 0; /* can't find valid BIOS pin config */
11411
11412         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11413         if (err < 0)
11414                 return err;
11415         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11416         if (err < 0)
11417                 return err;
11418
11419         spec->multiout.max_channels = 2;
11420
11421         /* digital only support output */
11422         if (spec->autocfg.dig_out_pin)
11423                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11424
11425         if (spec->kctl_alloc)
11426                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11427
11428         if (spec->autocfg.speaker_pins[0] != 0x1d)
11429                 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
11430
11431         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
11432         spec->num_mux_defs = 1;
11433         spec->input_mux = &spec->private_imux;
11434
11435         err = alc_auto_add_mic_boost(codec);
11436         if (err < 0)
11437                 return err;
11438
11439         return 1;
11440 }
11441
11442 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11443 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11444 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11445
11446 /* init callback for auto-configuration model -- overriding the default init */
11447 static void alc268_auto_init(struct hda_codec *codec)
11448 {
11449         struct alc_spec *spec = codec->spec;
11450         alc268_auto_init_multi_out(codec);
11451         alc268_auto_init_hp_out(codec);
11452         alc268_auto_init_mono_speaker_out(codec);
11453         alc268_auto_init_analog_input(codec);
11454         if (spec->unsol_event)
11455                 alc_inithook(codec);
11456 }
11457
11458 /*
11459  * configuration and preset
11460  */
11461 static const char *alc268_models[ALC268_MODEL_LAST] = {
11462         [ALC267_QUANTA_IL1]     = "quanta-il1",
11463         [ALC268_3ST]            = "3stack",
11464         [ALC268_TOSHIBA]        = "toshiba",
11465         [ALC268_ACER]           = "acer",
11466         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
11467         [ALC268_DELL]           = "dell",
11468         [ALC268_ZEPTO]          = "zepto",
11469 #ifdef CONFIG_SND_DEBUG
11470         [ALC268_TEST]           = "test",
11471 #endif
11472         [ALC268_AUTO]           = "auto",
11473 };
11474
11475 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11476         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11477         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11478         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11479         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11480         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11481         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11482                                                 ALC268_ACER_ASPIRE_ONE),
11483         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11484         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11485         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11486         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11487         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11488         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11489         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11490         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11491         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11492         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11493         {}
11494 };
11495
11496 static struct alc_config_preset alc268_presets[] = {
11497         [ALC267_QUANTA_IL1] = {
11498                 .mixers = { alc267_quanta_il1_mixer },
11499                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11500                                 alc267_quanta_il1_verbs },
11501                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11502                 .dac_nids = alc268_dac_nids,
11503                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11504                 .adc_nids = alc268_adc_nids_alt,
11505                 .hp_nid = 0x03,
11506                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11507                 .channel_mode = alc268_modes,
11508                 .input_mux = &alc268_capture_source,
11509                 .unsol_event = alc267_quanta_il1_unsol_event,
11510                 .init_hook = alc267_quanta_il1_automute,
11511         },
11512         [ALC268_3ST] = {
11513                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11514                             alc268_beep_mixer },
11515                 .init_verbs = { alc268_base_init_verbs },
11516                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11517                 .dac_nids = alc268_dac_nids,
11518                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11519                 .adc_nids = alc268_adc_nids_alt,
11520                 .capsrc_nids = alc268_capsrc_nids,
11521                 .hp_nid = 0x03,
11522                 .dig_out_nid = ALC268_DIGOUT_NID,
11523                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11524                 .channel_mode = alc268_modes,
11525                 .input_mux = &alc268_capture_source,
11526         },
11527         [ALC268_TOSHIBA] = {
11528                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11529                             alc268_beep_mixer },
11530                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11531                                 alc268_toshiba_verbs },
11532                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11533                 .dac_nids = alc268_dac_nids,
11534                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11535                 .adc_nids = alc268_adc_nids_alt,
11536                 .capsrc_nids = alc268_capsrc_nids,
11537                 .hp_nid = 0x03,
11538                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11539                 .channel_mode = alc268_modes,
11540                 .input_mux = &alc268_capture_source,
11541                 .unsol_event = alc268_toshiba_unsol_event,
11542                 .init_hook = alc268_toshiba_automute,
11543         },
11544         [ALC268_ACER] = {
11545                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11546                             alc268_beep_mixer },
11547                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11548                                 alc268_acer_verbs },
11549                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11550                 .dac_nids = alc268_dac_nids,
11551                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11552                 .adc_nids = alc268_adc_nids_alt,
11553                 .capsrc_nids = alc268_capsrc_nids,
11554                 .hp_nid = 0x02,
11555                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11556                 .channel_mode = alc268_modes,
11557                 .input_mux = &alc268_acer_capture_source,
11558                 .unsol_event = alc268_acer_unsol_event,
11559                 .init_hook = alc268_acer_init_hook,
11560         },
11561         [ALC268_ACER_ASPIRE_ONE] = {
11562                 .mixers = { alc268_acer_aspire_one_mixer,
11563                                 alc268_capture_alt_mixer },
11564                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11565                                 alc268_acer_aspire_one_verbs },
11566                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11567                 .dac_nids = alc268_dac_nids,
11568                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11569                 .adc_nids = alc268_adc_nids_alt,
11570                 .capsrc_nids = alc268_capsrc_nids,
11571                 .hp_nid = 0x03,
11572                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11573                 .channel_mode = alc268_modes,
11574                 .input_mux = &alc268_acer_lc_capture_source,
11575                 .unsol_event = alc268_acer_lc_unsol_event,
11576                 .init_hook = alc268_acer_lc_init_hook,
11577         },
11578         [ALC268_DELL] = {
11579                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
11580                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11581                                 alc268_dell_verbs },
11582                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11583                 .dac_nids = alc268_dac_nids,
11584                 .hp_nid = 0x02,
11585                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11586                 .channel_mode = alc268_modes,
11587                 .unsol_event = alc268_dell_unsol_event,
11588                 .init_hook = alc268_dell_init_hook,
11589                 .input_mux = &alc268_capture_source,
11590         },
11591         [ALC268_ZEPTO] = {
11592                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11593                             alc268_beep_mixer },
11594                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11595                                 alc268_toshiba_verbs },
11596                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11597                 .dac_nids = alc268_dac_nids,
11598                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11599                 .adc_nids = alc268_adc_nids_alt,
11600                 .capsrc_nids = alc268_capsrc_nids,
11601                 .hp_nid = 0x03,
11602                 .dig_out_nid = ALC268_DIGOUT_NID,
11603                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11604                 .channel_mode = alc268_modes,
11605                 .input_mux = &alc268_capture_source,
11606                 .unsol_event = alc268_toshiba_unsol_event,
11607                 .init_hook = alc268_toshiba_automute
11608         },
11609 #ifdef CONFIG_SND_DEBUG
11610         [ALC268_TEST] = {
11611                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
11612                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11613                                 alc268_volume_init_verbs },
11614                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11615                 .dac_nids = alc268_dac_nids,
11616                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11617                 .adc_nids = alc268_adc_nids_alt,
11618                 .capsrc_nids = alc268_capsrc_nids,
11619                 .hp_nid = 0x03,
11620                 .dig_out_nid = ALC268_DIGOUT_NID,
11621                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11622                 .channel_mode = alc268_modes,
11623                 .input_mux = &alc268_capture_source,
11624         },
11625 #endif
11626 };
11627
11628 static int patch_alc268(struct hda_codec *codec)
11629 {
11630         struct alc_spec *spec;
11631         int board_config;
11632         int err;
11633
11634         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
11635         if (spec == NULL)
11636                 return -ENOMEM;
11637
11638         codec->spec = spec;
11639
11640         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
11641                                                   alc268_models,
11642                                                   alc268_cfg_tbl);
11643
11644         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
11645                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
11646                        "trying auto-probe from BIOS...\n");
11647                 board_config = ALC268_AUTO;
11648         }
11649
11650         if (board_config == ALC268_AUTO) {
11651                 /* automatic parse from the BIOS config */
11652                 err = alc268_parse_auto_config(codec);
11653                 if (err < 0) {
11654                         alc_free(codec);
11655                         return err;
11656                 } else if (!err) {
11657                         printk(KERN_INFO
11658                                "hda_codec: Cannot set up configuration "
11659                                "from BIOS.  Using base mode...\n");
11660                         board_config = ALC268_3ST;
11661                 }
11662         }
11663
11664         if (board_config != ALC268_AUTO)
11665                 setup_preset(spec, &alc268_presets[board_config]);
11666
11667         if (codec->vendor_id == 0x10ec0267) {
11668                 spec->stream_name_analog = "ALC267 Analog";
11669                 spec->stream_name_digital = "ALC267 Digital";
11670         } else {
11671                 spec->stream_name_analog = "ALC268 Analog";
11672                 spec->stream_name_digital = "ALC268 Digital";
11673         }
11674
11675         spec->stream_analog_playback = &alc268_pcm_analog_playback;
11676         spec->stream_analog_capture = &alc268_pcm_analog_capture;
11677         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
11678
11679         spec->stream_digital_playback = &alc268_pcm_digital_playback;
11680
11681         if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
11682                 /* override the amp caps for beep generator */
11683                 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
11684                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
11685                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
11686                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11687                                           (0 << AC_AMPCAP_MUTE_SHIFT));
11688
11689         if (!spec->adc_nids && spec->input_mux) {
11690                 /* check whether NID 0x07 is valid */
11691                 unsigned int wcap = get_wcaps(codec, 0x07);
11692                 int i;
11693
11694                 /* get type */
11695                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11696                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
11697                         spec->adc_nids = alc268_adc_nids_alt;
11698                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
11699                         spec->mixers[spec->num_mixers] =
11700                                         alc268_capture_alt_mixer;
11701                         spec->num_mixers++;
11702                 } else {
11703                         spec->adc_nids = alc268_adc_nids;
11704                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
11705                         spec->mixers[spec->num_mixers] =
11706                                 alc268_capture_mixer;
11707                         spec->num_mixers++;
11708                 }
11709                 spec->capsrc_nids = alc268_capsrc_nids;
11710                 /* set default input source */
11711                 for (i = 0; i < spec->num_adc_nids; i++)
11712                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
11713                                 0, AC_VERB_SET_CONNECT_SEL,
11714                                 spec->input_mux->items[0].index);
11715         }
11716
11717         spec->vmaster_nid = 0x02;
11718
11719         codec->patch_ops = alc_patch_ops;
11720         if (board_config == ALC268_AUTO)
11721                 spec->init_hook = alc268_auto_init;
11722
11723         return 0;
11724 }
11725
11726 /*
11727  *  ALC269 channel source setting (2 channel)
11728  */
11729 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
11730
11731 #define alc269_dac_nids         alc260_dac_nids
11732
11733 static hda_nid_t alc269_adc_nids[1] = {
11734         /* ADC1 */
11735         0x08,
11736 };
11737
11738 static hda_nid_t alc269_capsrc_nids[1] = {
11739         0x23,
11740 };
11741
11742 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
11743  *       not a mux!
11744  */
11745
11746 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
11747         .num_items = 2,
11748         .items = {
11749                 { "i-Mic", 0x5 },
11750                 { "e-Mic", 0x0 },
11751         },
11752 };
11753
11754 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
11755         .num_items = 2,
11756         .items = {
11757                 { "i-Mic", 0x1 },
11758                 { "e-Mic", 0x0 },
11759         },
11760 };
11761
11762 #define alc269_modes            alc260_modes
11763 #define alc269_capture_source   alc880_lg_lw_capture_source
11764
11765 static struct snd_kcontrol_new alc269_base_mixer[] = {
11766         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11767         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11768         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11769         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11770         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11771         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11772         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11773         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11774         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11775         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11776         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11777         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11778         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11779         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11780         { } /* end */
11781 };
11782
11783 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
11784         /* output mixer control */
11785         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11786         {
11787                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11788                 .name = "Master Playback Switch",
11789                 .info = snd_hda_mixer_amp_switch_info,
11790                 .get = snd_hda_mixer_amp_switch_get,
11791                 .put = alc268_acer_master_sw_put,
11792                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11793         },
11794         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11795         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11796         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11797         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11798         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11799         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11800         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
11801         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
11802         { }
11803 };
11804
11805 /* bind volumes of both NID 0x0c and 0x0d */
11806 static struct hda_bind_ctls alc269_epc_bind_vol = {
11807         .ops = &snd_hda_bind_vol,
11808         .values = {
11809                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11810                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11811                 0
11812         },
11813 };
11814
11815 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11816         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11817         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11818         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11819         { } /* end */
11820 };
11821
11822 /* capture mixer elements */
11823 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11824         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11825         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11826         {
11827                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11828                 /* The multiple "Capture Source" controls confuse alsamixer
11829                  * So call somewhat different..
11830                  */
11831                 /* .name = "Capture Source", */
11832                 .name = "Input Source",
11833                 .count = 1,
11834                 .info = alc_mux_enum_info,
11835                 .get = alc_mux_enum_get,
11836                 .put = alc_mux_enum_put,
11837         },
11838         { } /* end */
11839 };
11840
11841 /* capture mixer elements */
11842 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11843         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11844         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11845         { } /* end */
11846 };
11847
11848 /* beep control */
11849 static struct snd_kcontrol_new alc269_beep_mixer[] = {
11850         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11851         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11852         { } /* end */
11853 };
11854
11855 static struct hda_verb alc269_quanta_fl1_verbs[] = {
11856         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11857         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11858         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11859         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11860         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11861         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11862         { }
11863 };
11864
11865 /* toggle speaker-output according to the hp-jack state */
11866 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
11867 {
11868         unsigned int present;
11869         unsigned char bits;
11870
11871         present = snd_hda_codec_read(codec, 0x15, 0,
11872                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11873         bits = present ? AMP_IN_MUTE(0) : 0;
11874         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11875                         AMP_IN_MUTE(0), bits);
11876         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11877                         AMP_IN_MUTE(0), bits);
11878
11879         snd_hda_codec_write(codec, 0x20, 0,
11880                         AC_VERB_SET_COEF_INDEX, 0x0c);
11881         snd_hda_codec_write(codec, 0x20, 0,
11882                         AC_VERB_SET_PROC_COEF, 0x680);
11883
11884         snd_hda_codec_write(codec, 0x20, 0,
11885                         AC_VERB_SET_COEF_INDEX, 0x0c);
11886         snd_hda_codec_write(codec, 0x20, 0,
11887                         AC_VERB_SET_PROC_COEF, 0x480);
11888 }
11889
11890 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
11891 {
11892         unsigned int present;
11893
11894         present = snd_hda_codec_read(codec, 0x18, 0,
11895                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11896         snd_hda_codec_write(codec, 0x23, 0,
11897                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
11898 }
11899
11900 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
11901                                     unsigned int res)
11902 {
11903         if ((res >> 26) == ALC880_HP_EVENT)
11904                 alc269_quanta_fl1_speaker_automute(codec);
11905         if ((res >> 26) == ALC880_MIC_EVENT)
11906                 alc269_quanta_fl1_mic_automute(codec);
11907 }
11908
11909 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
11910 {
11911         alc269_quanta_fl1_speaker_automute(codec);
11912         alc269_quanta_fl1_mic_automute(codec);
11913 }
11914
11915 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
11916         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11917         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
11918         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11919         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
11920         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11921         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11922         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11923         {}
11924 };
11925
11926 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
11927         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11928         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
11929         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11930         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
11931         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11932         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11933         {}
11934 };
11935
11936 /* toggle speaker-output according to the hp-jack state */
11937 static void alc269_speaker_automute(struct hda_codec *codec)
11938 {
11939         unsigned int present;
11940         unsigned char bits;
11941
11942         present = snd_hda_codec_read(codec, 0x15, 0,
11943                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11944         bits = present ? AMP_IN_MUTE(0) : 0;
11945         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11946                                 AMP_IN_MUTE(0), bits);
11947         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11948                                 AMP_IN_MUTE(0), bits);
11949 }
11950
11951 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
11952 {
11953         unsigned int present;
11954
11955         present = snd_hda_codec_read(codec, 0x18, 0,
11956                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11957         snd_hda_codec_write(codec, 0x23, 0,
11958                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
11959 }
11960
11961 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
11962 {
11963         unsigned int present;
11964
11965         present = snd_hda_codec_read(codec, 0x18, 0,
11966                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11967         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11968                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
11969         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11970                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
11971 }
11972
11973 /* unsolicited event for HP jack sensing */
11974 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
11975                                      unsigned int res)
11976 {
11977         if ((res >> 26) == ALC880_HP_EVENT)
11978                 alc269_speaker_automute(codec);
11979
11980         if ((res >> 26) == ALC880_MIC_EVENT)
11981                 alc269_eeepc_dmic_automute(codec);
11982 }
11983
11984 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
11985 {
11986         alc269_speaker_automute(codec);
11987         alc269_eeepc_dmic_automute(codec);
11988 }
11989
11990 /* unsolicited event for HP jack sensing */
11991 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
11992                                      unsigned int res)
11993 {
11994         if ((res >> 26) == ALC880_HP_EVENT)
11995                 alc269_speaker_automute(codec);
11996
11997         if ((res >> 26) == ALC880_MIC_EVENT)
11998                 alc269_eeepc_amic_automute(codec);
11999 }
12000
12001 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12002 {
12003         alc269_speaker_automute(codec);
12004         alc269_eeepc_amic_automute(codec);
12005 }
12006
12007 /*
12008  * generic initialization of ADC, input mixers and output mixers
12009  */
12010 static struct hda_verb alc269_init_verbs[] = {
12011         /*
12012          * Unmute ADC0 and set the default input to mic-in
12013          */
12014         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12015
12016         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12017          * analog-loopback mixer widget
12018          * Note: PASD motherboards uses the Line In 2 as the input for
12019          * front panel mic (mic 2)
12020          */
12021         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12022         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12023         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12024         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12025         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12026         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12027
12028         /*
12029          * Set up output mixers (0x0c - 0x0e)
12030          */
12031         /* set vol=0 to output mixers */
12032         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12033         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12034
12035         /* set up input amps for analog loopback */
12036         /* Amp Indices: DAC = 0, mixer = 1 */
12037         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12038         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12039         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12040         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12041         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12042         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12043
12044         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12045         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12046         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12047         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12048         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12049         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12050         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12051
12052         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12053         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12054         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12055         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12056         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12057         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12058         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12059
12060         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12061         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12062
12063         /* FIXME: use matrix-type input source selection */
12064         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12065         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12066         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12067         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12068         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12069         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12070
12071         /* set EAPD */
12072         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12073         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12074         { }
12075 };
12076
12077 /* add playback controls from the parsed DAC table */
12078 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12079                                              const struct auto_pin_cfg *cfg)
12080 {
12081         hda_nid_t nid;
12082         int err;
12083
12084         spec->multiout.num_dacs = 1;    /* only use one dac */
12085         spec->multiout.dac_nids = spec->private_dac_nids;
12086         spec->multiout.dac_nids[0] = 2;
12087
12088         nid = cfg->line_out_pins[0];
12089         if (nid) {
12090                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12091                                   "Front Playback Volume",
12092                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12093                 if (err < 0)
12094                         return err;
12095                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12096                                   "Front Playback Switch",
12097                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12098                 if (err < 0)
12099                         return err;
12100         }
12101
12102         nid = cfg->speaker_pins[0];
12103         if (nid) {
12104                 if (!cfg->line_out_pins[0]) {
12105                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12106                                           "Speaker Playback Volume",
12107                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12108                                                               HDA_OUTPUT));
12109                         if (err < 0)
12110                                 return err;
12111                 }
12112                 if (nid == 0x16) {
12113                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12114                                           "Speaker Playback Switch",
12115                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12116                                                               HDA_OUTPUT));
12117                         if (err < 0)
12118                                 return err;
12119                 } else {
12120                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12121                                           "Speaker Playback Switch",
12122                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12123                                                               HDA_OUTPUT));
12124                         if (err < 0)
12125                                 return err;
12126                 }
12127         }
12128         nid = cfg->hp_pins[0];
12129         if (nid) {
12130                 /* spec->multiout.hp_nid = 2; */
12131                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12132                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12133                                           "Headphone Playback Volume",
12134                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12135                                                               HDA_OUTPUT));
12136                         if (err < 0)
12137                                 return err;
12138                 }
12139                 if (nid == 0x16) {
12140                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12141                                           "Headphone Playback Switch",
12142                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12143                                                               HDA_OUTPUT));
12144                         if (err < 0)
12145                                 return err;
12146                 } else {
12147                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12148                                           "Headphone Playback Switch",
12149                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12150                                                               HDA_OUTPUT));
12151                         if (err < 0)
12152                                 return err;
12153                 }
12154         }
12155         return 0;
12156 }
12157
12158 #define alc269_auto_create_analog_input_ctls \
12159         alc880_auto_create_analog_input_ctls
12160
12161 #ifdef CONFIG_SND_HDA_POWER_SAVE
12162 #define alc269_loopbacks        alc880_loopbacks
12163 #endif
12164
12165 /* pcm configuration: identiacal with ALC880 */
12166 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12167 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12168 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12169 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12170
12171 /*
12172  * BIOS auto configuration
12173  */
12174 static int alc269_parse_auto_config(struct hda_codec *codec)
12175 {
12176         struct alc_spec *spec = codec->spec;
12177         int i, err;
12178         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12179
12180         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12181                                            alc269_ignore);
12182         if (err < 0)
12183                 return err;
12184
12185         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12186         if (err < 0)
12187                 return err;
12188         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12189         if (err < 0)
12190                 return err;
12191
12192         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12193
12194         if (spec->autocfg.dig_out_pin)
12195                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12196
12197         if (spec->kctl_alloc)
12198                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12199
12200         /* create a beep mixer control if the pin 0x1d isn't assigned */
12201         for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++)
12202                 if (spec->autocfg.input_pins[i] == 0x1d)
12203                         break;
12204         if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
12205                 spec->mixers[spec->num_mixers++] = alc269_beep_mixer;
12206
12207         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
12208         spec->num_mux_defs = 1;
12209         spec->input_mux = &spec->private_imux;
12210         /* set default input source */
12211         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12212                                   0, AC_VERB_SET_CONNECT_SEL,
12213                                   spec->input_mux->items[0].index);
12214
12215         err = alc_auto_add_mic_boost(codec);
12216         if (err < 0)
12217                 return err;
12218
12219         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
12220         spec->num_mixers++;
12221
12222         return 1;
12223 }
12224
12225 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12226 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12227 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12228
12229
12230 /* init callback for auto-configuration model -- overriding the default init */
12231 static void alc269_auto_init(struct hda_codec *codec)
12232 {
12233         struct alc_spec *spec = codec->spec;
12234         alc269_auto_init_multi_out(codec);
12235         alc269_auto_init_hp_out(codec);
12236         alc269_auto_init_analog_input(codec);
12237         if (spec->unsol_event)
12238                 alc_inithook(codec);
12239 }
12240
12241 /*
12242  * configuration and preset
12243  */
12244 static const char *alc269_models[ALC269_MODEL_LAST] = {
12245         [ALC269_BASIC]                  = "basic",
12246         [ALC269_QUANTA_FL1]             = "quanta",
12247         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12248         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901"
12249 };
12250
12251 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12252         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12253         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12254                       ALC269_ASUS_EEEPC_P703),
12255         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12256                       ALC269_ASUS_EEEPC_P901),
12257         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12258                       ALC269_ASUS_EEEPC_P901),
12259         {}
12260 };
12261
12262 static struct alc_config_preset alc269_presets[] = {
12263         [ALC269_BASIC] = {
12264                 .mixers = { alc269_base_mixer, alc269_capture_mixer },
12265                 .init_verbs = { alc269_init_verbs },
12266                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12267                 .dac_nids = alc269_dac_nids,
12268                 .hp_nid = 0x03,
12269                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12270                 .channel_mode = alc269_modes,
12271                 .input_mux = &alc269_capture_source,
12272         },
12273         [ALC269_QUANTA_FL1] = {
12274                 .mixers = { alc269_quanta_fl1_mixer },
12275                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12276                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12277                 .dac_nids = alc269_dac_nids,
12278                 .hp_nid = 0x03,
12279                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12280                 .channel_mode = alc269_modes,
12281                 .input_mux = &alc269_capture_source,
12282                 .unsol_event = alc269_quanta_fl1_unsol_event,
12283                 .init_hook = alc269_quanta_fl1_init_hook,
12284         },
12285         [ALC269_ASUS_EEEPC_P703] = {
12286                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
12287                 .init_verbs = { alc269_init_verbs,
12288                                 alc269_eeepc_amic_init_verbs },
12289                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12290                 .dac_nids = alc269_dac_nids,
12291                 .hp_nid = 0x03,
12292                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12293                 .channel_mode = alc269_modes,
12294                 .input_mux = &alc269_eeepc_amic_capture_source,
12295                 .unsol_event = alc269_eeepc_amic_unsol_event,
12296                 .init_hook = alc269_eeepc_amic_inithook,
12297         },
12298         [ALC269_ASUS_EEEPC_P901] = {
12299                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
12300                 .init_verbs = { alc269_init_verbs,
12301                                 alc269_eeepc_dmic_init_verbs },
12302                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12303                 .dac_nids = alc269_dac_nids,
12304                 .hp_nid = 0x03,
12305                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12306                 .channel_mode = alc269_modes,
12307                 .input_mux = &alc269_eeepc_dmic_capture_source,
12308                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12309                 .init_hook = alc269_eeepc_dmic_inithook,
12310         },
12311 };
12312
12313 static int patch_alc269(struct hda_codec *codec)
12314 {
12315         struct alc_spec *spec;
12316         int board_config;
12317         int err;
12318
12319         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12320         if (spec == NULL)
12321                 return -ENOMEM;
12322
12323         codec->spec = spec;
12324
12325         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12326
12327         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12328                                                   alc269_models,
12329                                                   alc269_cfg_tbl);
12330
12331         if (board_config < 0) {
12332                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12333                        "trying auto-probe from BIOS...\n");
12334                 board_config = ALC269_AUTO;
12335         }
12336
12337         if (board_config == ALC269_AUTO) {
12338                 /* automatic parse from the BIOS config */
12339                 err = alc269_parse_auto_config(codec);
12340                 if (err < 0) {
12341                         alc_free(codec);
12342                         return err;
12343                 } else if (!err) {
12344                         printk(KERN_INFO
12345                                "hda_codec: Cannot set up configuration "
12346                                "from BIOS.  Using base mode...\n");
12347                         board_config = ALC269_BASIC;
12348                 }
12349         }
12350
12351         if (board_config != ALC269_AUTO)
12352                 setup_preset(spec, &alc269_presets[board_config]);
12353
12354         spec->stream_name_analog = "ALC269 Analog";
12355         spec->stream_analog_playback = &alc269_pcm_analog_playback;
12356         spec->stream_analog_capture = &alc269_pcm_analog_capture;
12357
12358         spec->stream_name_digital = "ALC269 Digital";
12359         spec->stream_digital_playback = &alc269_pcm_digital_playback;
12360         spec->stream_digital_capture = &alc269_pcm_digital_capture;
12361
12362         spec->adc_nids = alc269_adc_nids;
12363         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12364         spec->capsrc_nids = alc269_capsrc_nids;
12365
12366         codec->patch_ops = alc_patch_ops;
12367         if (board_config == ALC269_AUTO)
12368                 spec->init_hook = alc269_auto_init;
12369 #ifdef CONFIG_SND_HDA_POWER_SAVE
12370         if (!spec->loopback.amplist)
12371                 spec->loopback.amplist = alc269_loopbacks;
12372 #endif
12373
12374         return 0;
12375 }
12376
12377 /*
12378  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
12379  */
12380
12381 /*
12382  * set the path ways for 2 channel output
12383  * need to set the codec line out and mic 1 pin widgets to inputs
12384  */
12385 static struct hda_verb alc861_threestack_ch2_init[] = {
12386         /* set pin widget 1Ah (line in) for input */
12387         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12388         /* set pin widget 18h (mic1/2) for input, for mic also enable
12389          * the vref
12390          */
12391         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12392
12393         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12394 #if 0
12395         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12396         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12397 #endif
12398         { } /* end */
12399 };
12400 /*
12401  * 6ch mode
12402  * need to set the codec line out and mic 1 pin widgets to outputs
12403  */
12404 static struct hda_verb alc861_threestack_ch6_init[] = {
12405         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12406         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12407         /* set pin widget 18h (mic1) for output (CLFE)*/
12408         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12409
12410         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12411         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12412
12413         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12414 #if 0
12415         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12416         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12417 #endif
12418         { } /* end */
12419 };
12420
12421 static struct hda_channel_mode alc861_threestack_modes[2] = {
12422         { 2, alc861_threestack_ch2_init },
12423         { 6, alc861_threestack_ch6_init },
12424 };
12425 /* Set mic1 as input and unmute the mixer */
12426 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
12427         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12428         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12429         { } /* end */
12430 };
12431 /* Set mic1 as output and mute mixer */
12432 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
12433         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12434         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12435         { } /* end */
12436 };
12437
12438 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
12439         { 2, alc861_uniwill_m31_ch2_init },
12440         { 4, alc861_uniwill_m31_ch4_init },
12441 };
12442
12443 /* Set mic1 and line-in as input and unmute the mixer */
12444 static struct hda_verb alc861_asus_ch2_init[] = {
12445         /* set pin widget 1Ah (line in) for input */
12446         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12447         /* set pin widget 18h (mic1/2) for input, for mic also enable
12448          * the vref
12449          */
12450         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12451
12452         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12453 #if 0
12454         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12455         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12456 #endif
12457         { } /* end */
12458 };
12459 /* Set mic1 nad line-in as output and mute mixer */
12460 static struct hda_verb alc861_asus_ch6_init[] = {
12461         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12462         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12463         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12464         /* set pin widget 18h (mic1) for output (CLFE)*/
12465         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12466         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12467         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12468         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12469
12470         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12471 #if 0
12472         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12473         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12474 #endif
12475         { } /* end */
12476 };
12477
12478 static struct hda_channel_mode alc861_asus_modes[2] = {
12479         { 2, alc861_asus_ch2_init },
12480         { 6, alc861_asus_ch6_init },
12481 };
12482
12483 /* patch-ALC861 */
12484
12485 static struct snd_kcontrol_new alc861_base_mixer[] = {
12486         /* output mixer control */
12487         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12488         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12489         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12490         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12491         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12492
12493         /*Input mixer control */
12494         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12495            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12496         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12497         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12498         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12499         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12500         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12501         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12502         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12503         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12504
12505         /* Capture mixer control */
12506         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12507         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12508         {
12509                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12510                 .name = "Capture Source",
12511                 .count = 1,
12512                 .info = alc_mux_enum_info,
12513                 .get = alc_mux_enum_get,
12514                 .put = alc_mux_enum_put,
12515         },
12516         { } /* end */
12517 };
12518
12519 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
12520         /* output mixer control */
12521         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12522         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12523         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12524         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12525         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12526
12527         /* Input mixer control */
12528         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12529            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12530         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12531         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12532         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12533         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12534         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12535         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12536         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12537         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12538
12539         /* Capture mixer control */
12540         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12541         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12542         {
12543                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12544                 .name = "Capture Source",
12545                 .count = 1,
12546                 .info = alc_mux_enum_info,
12547                 .get = alc_mux_enum_get,
12548                 .put = alc_mux_enum_put,
12549         },
12550         {
12551                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12552                 .name = "Channel Mode",
12553                 .info = alc_ch_mode_info,
12554                 .get = alc_ch_mode_get,
12555                 .put = alc_ch_mode_put,
12556                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
12557         },
12558         { } /* end */
12559 };
12560
12561 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
12562         /* output mixer control */
12563         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12564         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12565         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12566
12567         /*Capture mixer control */
12568         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12569         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12570         {
12571                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12572                 .name = "Capture Source",
12573                 .count = 1,
12574                 .info = alc_mux_enum_info,
12575                 .get = alc_mux_enum_get,
12576                 .put = alc_mux_enum_put,
12577         },
12578
12579         { } /* end */
12580 };
12581
12582 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
12583         /* output mixer control */
12584         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12585         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12586         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12587         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12588         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12589
12590         /* Input mixer control */
12591         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12592            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12593         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12594         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12595         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12596         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12597         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12598         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12599         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12600         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12601
12602         /* Capture mixer control */
12603         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12604         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12605         {
12606                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12607                 .name = "Capture Source",
12608                 .count = 1,
12609                 .info = alc_mux_enum_info,
12610                 .get = alc_mux_enum_get,
12611                 .put = alc_mux_enum_put,
12612         },
12613         {
12614                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12615                 .name = "Channel Mode",
12616                 .info = alc_ch_mode_info,
12617                 .get = alc_ch_mode_get,
12618                 .put = alc_ch_mode_put,
12619                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
12620         },
12621         { } /* end */
12622 };
12623
12624 static struct snd_kcontrol_new alc861_asus_mixer[] = {
12625         /* output mixer control */
12626         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12627         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12628         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12629         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12630         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12631
12632         /* Input mixer control */
12633         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12634         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12635         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12636         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12637         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12638         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12639         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12640         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12641         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12642         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
12643
12644         /* Capture mixer control */
12645         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12646         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12647         {
12648                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12649                 .name = "Capture Source",
12650                 .count = 1,
12651                 .info = alc_mux_enum_info,
12652                 .get = alc_mux_enum_get,
12653                 .put = alc_mux_enum_put,
12654         },
12655         {
12656                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12657                 .name = "Channel Mode",
12658                 .info = alc_ch_mode_info,
12659                 .get = alc_ch_mode_get,
12660                 .put = alc_ch_mode_put,
12661                 .private_value = ARRAY_SIZE(alc861_asus_modes),
12662         },
12663         { }
12664 };
12665
12666 /* additional mixer */
12667 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
12668         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12669         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12670         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
12671         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
12672         { }
12673 };
12674
12675 /*
12676  * generic initialization of ADC, input mixers and output mixers
12677  */
12678 static struct hda_verb alc861_base_init_verbs[] = {
12679         /*
12680          * Unmute ADC0 and set the default input to mic-in
12681          */
12682         /* port-A for surround (rear panel) */
12683         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12684         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
12685         /* port-B for mic-in (rear panel) with vref */
12686         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12687         /* port-C for line-in (rear panel) */
12688         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12689         /* port-D for Front */
12690         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12691         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12692         /* port-E for HP out (front panel) */
12693         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12694         /* route front PCM to HP */
12695         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12696         /* port-F for mic-in (front panel) with vref */
12697         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12698         /* port-G for CLFE (rear panel) */
12699         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12700         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12701         /* port-H for side (rear panel) */
12702         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12703         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
12704         /* CD-in */
12705         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12706         /* route front mic to ADC1*/
12707         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12708         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12709
12710         /* Unmute DAC0~3 & spdif out*/
12711         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12712         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12713         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12714         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12715         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12716
12717         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12718         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12719         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12720         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12721         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12722
12723         /* Unmute Stereo Mixer 15 */
12724         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12725         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12726         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12727         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12728
12729         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12730         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12731         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12732         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12733         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12734         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12735         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12736         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12737         /* hp used DAC 3 (Front) */
12738         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12739         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12740
12741         { }
12742 };
12743
12744 static struct hda_verb alc861_threestack_init_verbs[] = {
12745         /*
12746          * Unmute ADC0 and set the default input to mic-in
12747          */
12748         /* port-A for surround (rear panel) */
12749         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12750         /* port-B for mic-in (rear panel) with vref */
12751         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12752         /* port-C for line-in (rear panel) */
12753         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12754         /* port-D for Front */
12755         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12756         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12757         /* port-E for HP out (front panel) */
12758         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12759         /* route front PCM to HP */
12760         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12761         /* port-F for mic-in (front panel) with vref */
12762         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12763         /* port-G for CLFE (rear panel) */
12764         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12765         /* port-H for side (rear panel) */
12766         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12767         /* CD-in */
12768         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12769         /* route front mic to ADC1*/
12770         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12771         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12772         /* Unmute DAC0~3 & spdif out*/
12773         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12774         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12775         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12776         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12777         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12778
12779         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12780         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12781         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12782         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12783         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12784
12785         /* Unmute Stereo Mixer 15 */
12786         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12787         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12788         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12789         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12790
12791         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12792         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12793         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12794         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12795         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12796         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12797         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12798         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12799         /* hp used DAC 3 (Front) */
12800         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12801         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12802         { }
12803 };
12804
12805 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
12806         /*
12807          * Unmute ADC0 and set the default input to mic-in
12808          */
12809         /* port-A for surround (rear panel) */
12810         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12811         /* port-B for mic-in (rear panel) with vref */
12812         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12813         /* port-C for line-in (rear panel) */
12814         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12815         /* port-D for Front */
12816         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12817         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12818         /* port-E for HP out (front panel) */
12819         /* this has to be set to VREF80 */
12820         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12821         /* route front PCM to HP */
12822         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12823         /* port-F for mic-in (front panel) with vref */
12824         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12825         /* port-G for CLFE (rear panel) */
12826         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12827         /* port-H for side (rear panel) */
12828         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12829         /* CD-in */
12830         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12831         /* route front mic to ADC1*/
12832         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12833         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12834         /* Unmute DAC0~3 & spdif out*/
12835         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12836         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12837         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12838         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12839         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12840
12841         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12842         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12843         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12844         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12845         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12846
12847         /* Unmute Stereo Mixer 15 */
12848         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12849         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12850         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12851         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12852
12853         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12854         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12855         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12856         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12857         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12858         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12859         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12860         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12861         /* hp used DAC 3 (Front) */
12862         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12863         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12864         { }
12865 };
12866
12867 static struct hda_verb alc861_asus_init_verbs[] = {
12868         /*
12869          * Unmute ADC0 and set the default input to mic-in
12870          */
12871         /* port-A for surround (rear panel)
12872          * according to codec#0 this is the HP jack
12873          */
12874         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
12875         /* route front PCM to HP */
12876         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
12877         /* port-B for mic-in (rear panel) with vref */
12878         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12879         /* port-C for line-in (rear panel) */
12880         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12881         /* port-D for Front */
12882         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12883         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12884         /* port-E for HP out (front panel) */
12885         /* this has to be set to VREF80 */
12886         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12887         /* route front PCM to HP */
12888         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12889         /* port-F for mic-in (front panel) with vref */
12890         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12891         /* port-G for CLFE (rear panel) */
12892         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12893         /* port-H for side (rear panel) */
12894         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12895         /* CD-in */
12896         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12897         /* route front mic to ADC1*/
12898         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12899         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12900         /* Unmute DAC0~3 & spdif out*/
12901         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12902         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12903         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12904         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12905         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12906         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12907         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12908         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12909         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12910         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12911
12912         /* Unmute Stereo Mixer 15 */
12913         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12914         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12915         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12916         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12917
12918         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12919         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12920         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12921         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12922         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12923         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12924         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12925         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12926         /* hp used DAC 3 (Front) */
12927         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12928         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12929         { }
12930 };
12931
12932 /* additional init verbs for ASUS laptops */
12933 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
12934         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
12935         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
12936         { }
12937 };
12938
12939 /*
12940  * generic initialization of ADC, input mixers and output mixers
12941  */
12942 static struct hda_verb alc861_auto_init_verbs[] = {
12943         /*
12944          * Unmute ADC0 and set the default input to mic-in
12945          */
12946         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
12947         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12948
12949         /* Unmute DAC0~3 & spdif out*/
12950         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12951         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12952         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12953         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12954         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12955
12956         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12957         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12958         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12959         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12960         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12961
12962         /* Unmute Stereo Mixer 15 */
12963         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12964         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12965         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12966         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
12967
12968         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12969         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12970         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12971         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12972         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12973         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12974         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12975         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12976
12977         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12978         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12979         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12980         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12981         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12982         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12983         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12984         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12985
12986         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
12987
12988         { }
12989 };
12990
12991 static struct hda_verb alc861_toshiba_init_verbs[] = {
12992         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12993
12994         { }
12995 };
12996
12997 /* toggle speaker-output according to the hp-jack state */
12998 static void alc861_toshiba_automute(struct hda_codec *codec)
12999 {
13000         unsigned int present;
13001
13002         present = snd_hda_codec_read(codec, 0x0f, 0,
13003                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13004         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13005                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13006         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13007                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13008 }
13009
13010 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13011                                        unsigned int res)
13012 {
13013         if ((res >> 26) == ALC880_HP_EVENT)
13014                 alc861_toshiba_automute(codec);
13015 }
13016
13017 /* pcm configuration: identiacal with ALC880 */
13018 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13019 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13020 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13021 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13022
13023
13024 #define ALC861_DIGOUT_NID       0x07
13025
13026 static struct hda_channel_mode alc861_8ch_modes[1] = {
13027         { 8, NULL }
13028 };
13029
13030 static hda_nid_t alc861_dac_nids[4] = {
13031         /* front, surround, clfe, side */
13032         0x03, 0x06, 0x05, 0x04
13033 };
13034
13035 static hda_nid_t alc660_dac_nids[3] = {
13036         /* front, clfe, surround */
13037         0x03, 0x05, 0x06
13038 };
13039
13040 static hda_nid_t alc861_adc_nids[1] = {
13041         /* ADC0-2 */
13042         0x08,
13043 };
13044
13045 static struct hda_input_mux alc861_capture_source = {
13046         .num_items = 5,
13047         .items = {
13048                 { "Mic", 0x0 },
13049                 { "Front Mic", 0x3 },
13050                 { "Line", 0x1 },
13051                 { "CD", 0x4 },
13052                 { "Mixer", 0x5 },
13053         },
13054 };
13055
13056 /* fill in the dac_nids table from the parsed pin configuration */
13057 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13058                                      const struct auto_pin_cfg *cfg)
13059 {
13060         int i;
13061         hda_nid_t nid;
13062
13063         spec->multiout.dac_nids = spec->private_dac_nids;
13064         for (i = 0; i < cfg->line_outs; i++) {
13065                 nid = cfg->line_out_pins[i];
13066                 if (nid) {
13067                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13068                                 continue;
13069                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13070                 }
13071         }
13072         spec->multiout.num_dacs = cfg->line_outs;
13073         return 0;
13074 }
13075
13076 /* add playback controls from the parsed DAC table */
13077 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13078                                              const struct auto_pin_cfg *cfg)
13079 {
13080         char name[32];
13081         static const char *chname[4] = {
13082                 "Front", "Surround", NULL /*CLFE*/, "Side"
13083         };
13084         hda_nid_t nid;
13085         int i, idx, err;
13086
13087         for (i = 0; i < cfg->line_outs; i++) {
13088                 nid = spec->multiout.dac_nids[i];
13089                 if (!nid)
13090                         continue;
13091                 if (nid == 0x05) {
13092                         /* Center/LFE */
13093                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13094                                           "Center Playback Switch",
13095                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13096                                                               HDA_OUTPUT));
13097                         if (err < 0)
13098                                 return err;
13099                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13100                                           "LFE Playback Switch",
13101                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13102                                                               HDA_OUTPUT));
13103                         if (err < 0)
13104                                 return err;
13105                 } else {
13106                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13107                              idx++)
13108                                 if (nid == alc861_dac_nids[idx])
13109                                         break;
13110                         sprintf(name, "%s Playback Switch", chname[idx]);
13111                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13112                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13113                                                               HDA_OUTPUT));
13114                         if (err < 0)
13115                                 return err;
13116                 }
13117         }
13118         return 0;
13119 }
13120
13121 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13122 {
13123         int err;
13124         hda_nid_t nid;
13125
13126         if (!pin)
13127                 return 0;
13128
13129         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13130                 nid = 0x03;
13131                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13132                                   "Headphone Playback Switch",
13133                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13134                 if (err < 0)
13135                         return err;
13136                 spec->multiout.hp_nid = nid;
13137         }
13138         return 0;
13139 }
13140
13141 /* create playback/capture controls for input pins */
13142 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13143                                                 const struct auto_pin_cfg *cfg)
13144 {
13145         struct hda_input_mux *imux = &spec->private_imux;
13146         int i, err, idx, idx1;
13147
13148         for (i = 0; i < AUTO_PIN_LAST; i++) {
13149                 switch (cfg->input_pins[i]) {
13150                 case 0x0c:
13151                         idx1 = 1;
13152                         idx = 2;        /* Line In */
13153                         break;
13154                 case 0x0f:
13155                         idx1 = 2;
13156                         idx = 2;        /* Line In */
13157                         break;
13158                 case 0x0d:
13159                         idx1 = 0;
13160                         idx = 1;        /* Mic In */
13161                         break;
13162                 case 0x10:
13163                         idx1 = 3;
13164                         idx = 1;        /* Mic In */
13165                         break;
13166                 case 0x11:
13167                         idx1 = 4;
13168                         idx = 0;        /* CD */
13169                         break;
13170                 default:
13171                         continue;
13172                 }
13173
13174                 err = new_analog_input(spec, cfg->input_pins[i],
13175                                        auto_pin_cfg_labels[i], idx, 0x15);
13176                 if (err < 0)
13177                         return err;
13178
13179                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13180                 imux->items[imux->num_items].index = idx1;
13181                 imux->num_items++;
13182         }
13183         return 0;
13184 }
13185
13186 static struct snd_kcontrol_new alc861_capture_mixer[] = {
13187         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13188         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13189
13190         {
13191                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13192                 /* The multiple "Capture Source" controls confuse alsamixer
13193                  * So call somewhat different..
13194                  */
13195                 /* .name = "Capture Source", */
13196                 .name = "Input Source",
13197                 .count = 1,
13198                 .info = alc_mux_enum_info,
13199                 .get = alc_mux_enum_get,
13200                 .put = alc_mux_enum_put,
13201         },
13202         { } /* end */
13203 };
13204
13205 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13206                                               hda_nid_t nid,
13207                                               int pin_type, int dac_idx)
13208 {
13209         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13210                             pin_type);
13211         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13212                             AMP_OUT_UNMUTE);
13213 }
13214
13215 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13216 {
13217         struct alc_spec *spec = codec->spec;
13218         int i;
13219
13220         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13221         for (i = 0; i < spec->autocfg.line_outs; i++) {
13222                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13223                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13224                 if (nid)
13225                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13226                                                           spec->multiout.dac_nids[i]);
13227         }
13228 }
13229
13230 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13231 {
13232         struct alc_spec *spec = codec->spec;
13233         hda_nid_t pin;
13234
13235         pin = spec->autocfg.hp_pins[0];
13236         if (pin) /* connect to front */
13237                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13238                                                   spec->multiout.dac_nids[0]);
13239         pin = spec->autocfg.speaker_pins[0];
13240         if (pin)
13241                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13242 }
13243
13244 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13245 {
13246         struct alc_spec *spec = codec->spec;
13247         int i;
13248
13249         for (i = 0; i < AUTO_PIN_LAST; i++) {
13250                 hda_nid_t nid = spec->autocfg.input_pins[i];
13251                 if (nid >= 0x0c && nid <= 0x11) {
13252                         snd_hda_codec_write(codec, nid, 0,
13253                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
13254                                             i <= AUTO_PIN_FRONT_MIC ?
13255                                             PIN_VREF80 : PIN_IN);
13256                 }
13257         }
13258 }
13259
13260 /* parse the BIOS configuration and set up the alc_spec */
13261 /* return 1 if successful, 0 if the proper config is not found,
13262  * or a negative error code
13263  */
13264 static int alc861_parse_auto_config(struct hda_codec *codec)
13265 {
13266         struct alc_spec *spec = codec->spec;
13267         int err;
13268         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13269
13270         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13271                                            alc861_ignore);
13272         if (err < 0)
13273                 return err;
13274         if (!spec->autocfg.line_outs)
13275                 return 0; /* can't find valid BIOS pin config */
13276
13277         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13278         if (err < 0)
13279                 return err;
13280         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13281         if (err < 0)
13282                 return err;
13283         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13284         if (err < 0)
13285                 return err;
13286         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13287         if (err < 0)
13288                 return err;
13289
13290         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13291
13292         if (spec->autocfg.dig_out_pin)
13293                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13294
13295         if (spec->kctl_alloc)
13296                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13297
13298         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
13299
13300         spec->num_mux_defs = 1;
13301         spec->input_mux = &spec->private_imux;
13302
13303         spec->adc_nids = alc861_adc_nids;
13304         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13305         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
13306         spec->num_mixers++;
13307
13308         return 1;
13309 }
13310
13311 /* additional initialization for auto-configuration model */
13312 static void alc861_auto_init(struct hda_codec *codec)
13313 {
13314         struct alc_spec *spec = codec->spec;
13315         alc861_auto_init_multi_out(codec);
13316         alc861_auto_init_hp_out(codec);
13317         alc861_auto_init_analog_input(codec);
13318         if (spec->unsol_event)
13319                 alc_inithook(codec);
13320 }
13321
13322 #ifdef CONFIG_SND_HDA_POWER_SAVE
13323 static struct hda_amp_list alc861_loopbacks[] = {
13324         { 0x15, HDA_INPUT, 0 },
13325         { 0x15, HDA_INPUT, 1 },
13326         { 0x15, HDA_INPUT, 2 },
13327         { 0x15, HDA_INPUT, 3 },
13328         { } /* end */
13329 };
13330 #endif
13331
13332
13333 /*
13334  * configuration and preset
13335  */
13336 static const char *alc861_models[ALC861_MODEL_LAST] = {
13337         [ALC861_3ST]            = "3stack",
13338         [ALC660_3ST]            = "3stack-660",
13339         [ALC861_3ST_DIG]        = "3stack-dig",
13340         [ALC861_6ST_DIG]        = "6stack-dig",
13341         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13342         [ALC861_TOSHIBA]        = "toshiba",
13343         [ALC861_ASUS]           = "asus",
13344         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13345         [ALC861_AUTO]           = "auto",
13346 };
13347
13348 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13349         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13350         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13351         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13352         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13353         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13354         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13355         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13356         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13357          *        Any other models that need this preset?
13358          */
13359         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13360         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13361         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13362         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13363         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13364         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13365         /* FIXME: the below seems conflict */
13366         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13367         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13368         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13369         {}
13370 };
13371
13372 static struct alc_config_preset alc861_presets[] = {
13373         [ALC861_3ST] = {
13374                 .mixers = { alc861_3ST_mixer },
13375                 .init_verbs = { alc861_threestack_init_verbs },
13376                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13377                 .dac_nids = alc861_dac_nids,
13378                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13379                 .channel_mode = alc861_threestack_modes,
13380                 .need_dac_fix = 1,
13381                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13382                 .adc_nids = alc861_adc_nids,
13383                 .input_mux = &alc861_capture_source,
13384         },
13385         [ALC861_3ST_DIG] = {
13386                 .mixers = { alc861_base_mixer },
13387                 .init_verbs = { alc861_threestack_init_verbs },
13388                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13389                 .dac_nids = alc861_dac_nids,
13390                 .dig_out_nid = ALC861_DIGOUT_NID,
13391                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13392                 .channel_mode = alc861_threestack_modes,
13393                 .need_dac_fix = 1,
13394                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13395                 .adc_nids = alc861_adc_nids,
13396                 .input_mux = &alc861_capture_source,
13397         },
13398         [ALC861_6ST_DIG] = {
13399                 .mixers = { alc861_base_mixer },
13400                 .init_verbs = { alc861_base_init_verbs },
13401                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13402                 .dac_nids = alc861_dac_nids,
13403                 .dig_out_nid = ALC861_DIGOUT_NID,
13404                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13405                 .channel_mode = alc861_8ch_modes,
13406                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13407                 .adc_nids = alc861_adc_nids,
13408                 .input_mux = &alc861_capture_source,
13409         },
13410         [ALC660_3ST] = {
13411                 .mixers = { alc861_3ST_mixer },
13412                 .init_verbs = { alc861_threestack_init_verbs },
13413                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13414                 .dac_nids = alc660_dac_nids,
13415                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13416                 .channel_mode = alc861_threestack_modes,
13417                 .need_dac_fix = 1,
13418                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13419                 .adc_nids = alc861_adc_nids,
13420                 .input_mux = &alc861_capture_source,
13421         },
13422         [ALC861_UNIWILL_M31] = {
13423                 .mixers = { alc861_uniwill_m31_mixer },
13424                 .init_verbs = { alc861_uniwill_m31_init_verbs },
13425                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13426                 .dac_nids = alc861_dac_nids,
13427                 .dig_out_nid = ALC861_DIGOUT_NID,
13428                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13429                 .channel_mode = alc861_uniwill_m31_modes,
13430                 .need_dac_fix = 1,
13431                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13432                 .adc_nids = alc861_adc_nids,
13433                 .input_mux = &alc861_capture_source,
13434         },
13435         [ALC861_TOSHIBA] = {
13436                 .mixers = { alc861_toshiba_mixer },
13437                 .init_verbs = { alc861_base_init_verbs,
13438                                 alc861_toshiba_init_verbs },
13439                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13440                 .dac_nids = alc861_dac_nids,
13441                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13442                 .channel_mode = alc883_3ST_2ch_modes,
13443                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13444                 .adc_nids = alc861_adc_nids,
13445                 .input_mux = &alc861_capture_source,
13446                 .unsol_event = alc861_toshiba_unsol_event,
13447                 .init_hook = alc861_toshiba_automute,
13448         },
13449         [ALC861_ASUS] = {
13450                 .mixers = { alc861_asus_mixer },
13451                 .init_verbs = { alc861_asus_init_verbs },
13452                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13453                 .dac_nids = alc861_dac_nids,
13454                 .dig_out_nid = ALC861_DIGOUT_NID,
13455                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13456                 .channel_mode = alc861_asus_modes,
13457                 .need_dac_fix = 1,
13458                 .hp_nid = 0x06,
13459                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13460                 .adc_nids = alc861_adc_nids,
13461                 .input_mux = &alc861_capture_source,
13462         },
13463         [ALC861_ASUS_LAPTOP] = {
13464                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13465                 .init_verbs = { alc861_asus_init_verbs,
13466                                 alc861_asus_laptop_init_verbs },
13467                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13468                 .dac_nids = alc861_dac_nids,
13469                 .dig_out_nid = ALC861_DIGOUT_NID,
13470                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13471                 .channel_mode = alc883_3ST_2ch_modes,
13472                 .need_dac_fix = 1,
13473                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13474                 .adc_nids = alc861_adc_nids,
13475                 .input_mux = &alc861_capture_source,
13476         },
13477 };
13478
13479
13480 static int patch_alc861(struct hda_codec *codec)
13481 {
13482         struct alc_spec *spec;
13483         int board_config;
13484         int err;
13485
13486         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13487         if (spec == NULL)
13488                 return -ENOMEM;
13489
13490         codec->spec = spec;
13491
13492         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
13493                                                   alc861_models,
13494                                                   alc861_cfg_tbl);
13495
13496         if (board_config < 0) {
13497                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
13498                        "trying auto-probe from BIOS...\n");
13499                 board_config = ALC861_AUTO;
13500         }
13501
13502         if (board_config == ALC861_AUTO) {
13503                 /* automatic parse from the BIOS config */
13504                 err = alc861_parse_auto_config(codec);
13505                 if (err < 0) {
13506                         alc_free(codec);
13507                         return err;
13508                 } else if (!err) {
13509                         printk(KERN_INFO
13510                                "hda_codec: Cannot set up configuration "
13511                                "from BIOS.  Using base mode...\n");
13512                    board_config = ALC861_3ST_DIG;
13513                 }
13514         }
13515
13516         if (board_config != ALC861_AUTO)
13517                 setup_preset(spec, &alc861_presets[board_config]);
13518
13519         spec->stream_name_analog = "ALC861 Analog";
13520         spec->stream_analog_playback = &alc861_pcm_analog_playback;
13521         spec->stream_analog_capture = &alc861_pcm_analog_capture;
13522
13523         spec->stream_name_digital = "ALC861 Digital";
13524         spec->stream_digital_playback = &alc861_pcm_digital_playback;
13525         spec->stream_digital_capture = &alc861_pcm_digital_capture;
13526
13527         spec->vmaster_nid = 0x03;
13528
13529         codec->patch_ops = alc_patch_ops;
13530         if (board_config == ALC861_AUTO)
13531                 spec->init_hook = alc861_auto_init;
13532 #ifdef CONFIG_SND_HDA_POWER_SAVE
13533         if (!spec->loopback.amplist)
13534                 spec->loopback.amplist = alc861_loopbacks;
13535 #endif
13536
13537         return 0;
13538 }
13539
13540 /*
13541  * ALC861-VD support
13542  *
13543  * Based on ALC882
13544  *
13545  * In addition, an independent DAC
13546  */
13547 #define ALC861VD_DIGOUT_NID     0x06
13548
13549 static hda_nid_t alc861vd_dac_nids[4] = {
13550         /* front, surr, clfe, side surr */
13551         0x02, 0x03, 0x04, 0x05
13552 };
13553
13554 /* dac_nids for ALC660vd are in a different order - according to
13555  * Realtek's driver.
13556  * This should probably tesult in a different mixer for 6stack models
13557  * of ALC660vd codecs, but for now there is only 3stack mixer
13558  * - and it is the same as in 861vd.
13559  * adc_nids in ALC660vd are (is) the same as in 861vd
13560  */
13561 static hda_nid_t alc660vd_dac_nids[3] = {
13562         /* front, rear, clfe, rear_surr */
13563         0x02, 0x04, 0x03
13564 };
13565
13566 static hda_nid_t alc861vd_adc_nids[1] = {
13567         /* ADC0 */
13568         0x09,
13569 };
13570
13571 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
13572
13573 /* input MUX */
13574 /* FIXME: should be a matrix-type input source selection */
13575 static struct hda_input_mux alc861vd_capture_source = {
13576         .num_items = 4,
13577         .items = {
13578                 { "Mic", 0x0 },
13579                 { "Front Mic", 0x1 },
13580                 { "Line", 0x2 },
13581                 { "CD", 0x4 },
13582         },
13583 };
13584
13585 static struct hda_input_mux alc861vd_dallas_capture_source = {
13586         .num_items = 2,
13587         .items = {
13588                 { "Ext Mic", 0x0 },
13589                 { "Int Mic", 0x1 },
13590         },
13591 };
13592
13593 static struct hda_input_mux alc861vd_hp_capture_source = {
13594         .num_items = 2,
13595         .items = {
13596                 { "Front Mic", 0x0 },
13597                 { "ATAPI Mic", 0x1 },
13598         },
13599 };
13600
13601 #define alc861vd_mux_enum_info alc_mux_enum_info
13602 #define alc861vd_mux_enum_get alc_mux_enum_get
13603 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
13604 #define alc861vd_mux_enum_put alc882_mux_enum_put
13605
13606 /*
13607  * 2ch mode
13608  */
13609 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
13610         { 2, NULL }
13611 };
13612
13613 /*
13614  * 6ch mode
13615  */
13616 static struct hda_verb alc861vd_6stack_ch6_init[] = {
13617         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13618         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13619         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13620         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13621         { } /* end */
13622 };
13623
13624 /*
13625  * 8ch mode
13626  */
13627 static struct hda_verb alc861vd_6stack_ch8_init[] = {
13628         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13629         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13630         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13631         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13632         { } /* end */
13633 };
13634
13635 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
13636         { 6, alc861vd_6stack_ch6_init },
13637         { 8, alc861vd_6stack_ch8_init },
13638 };
13639
13640 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
13641         {
13642                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13643                 .name = "Channel Mode",
13644                 .info = alc_ch_mode_info,
13645                 .get = alc_ch_mode_get,
13646                 .put = alc_ch_mode_put,
13647         },
13648         { } /* end */
13649 };
13650
13651 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
13652         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13653         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13654
13655         {
13656                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13657                 /* The multiple "Capture Source" controls confuse alsamixer
13658                  * So call somewhat different..
13659                  */
13660                 /* .name = "Capture Source", */
13661                 .name = "Input Source",
13662                 .count = 1,
13663                 .info = alc861vd_mux_enum_info,
13664                 .get = alc861vd_mux_enum_get,
13665                 .put = alc861vd_mux_enum_put,
13666         },
13667         { } /* end */
13668 };
13669
13670 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13671  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13672  */
13673 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
13674         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13675         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13676
13677         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13678         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
13679
13680         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
13681                                 HDA_OUTPUT),
13682         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
13683                                 HDA_OUTPUT),
13684         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13685         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
13686
13687         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
13688         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
13689
13690         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13691
13692         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13693         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13694         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13695
13696         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13697         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13698         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13699
13700         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13701         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13702
13703         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13704         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13705
13706         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13707         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13708
13709         { } /* end */
13710 };
13711
13712 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
13713         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13714         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13715
13716         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13717
13718         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13719         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13720         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13721
13722         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13723         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13724         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13725
13726         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13727         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13728
13729         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13730         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13731
13732         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13733         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13734
13735         { } /* end */
13736 };
13737
13738 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
13739         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13740         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
13741         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13742
13743         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13744
13745         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13747         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13748
13749         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13750         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13751         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13752
13753         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13754         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13755
13756         { } /* end */
13757 };
13758
13759 /* Pin assignment: Speaker=0x14, HP = 0x15,
13760  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
13761  */
13762 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
13763         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13764         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
13765         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13766         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13767         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13768         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13769         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13770         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13771         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13772         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13773         HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
13774         HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
13775         { } /* end */
13776 };
13777
13778 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
13779  *                 Front Mic=0x18, ATAPI Mic = 0x19,
13780  */
13781 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
13782         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13783         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13784         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13785         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13786         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13787         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13788         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13789         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13790
13791         { } /* end */
13792 };
13793
13794 /*
13795  * generic initialization of ADC, input mixers and output mixers
13796  */
13797 static struct hda_verb alc861vd_volume_init_verbs[] = {
13798         /*
13799          * Unmute ADC0 and set the default input to mic-in
13800          */
13801         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13802         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13803
13804         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
13805          * the analog-loopback mixer widget
13806          */
13807         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13808         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13809         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13810         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13811         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13812         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13813
13814         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
13815         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13816         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13817         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13818         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13819
13820         /*
13821          * Set up output mixers (0x02 - 0x05)
13822          */
13823         /* set vol=0 to output mixers */
13824         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13825         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13826         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13827         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13828
13829         /* set up input amps for analog loopback */
13830         /* Amp Indices: DAC = 0, mixer = 1 */
13831         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13832         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13833         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13834         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13835         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13836         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13837         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13838         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13839
13840         { }
13841 };
13842
13843 /*
13844  * 3-stack pin configuration:
13845  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
13846  */
13847 static struct hda_verb alc861vd_3stack_init_verbs[] = {
13848         /*
13849          * Set pin mode and muting
13850          */
13851         /* set front pin widgets 0x14 for output */
13852         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13853         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13854         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13855
13856         /* Mic (rear) pin: input vref at 80% */
13857         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13858         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13859         /* Front Mic pin: input vref at 80% */
13860         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13861         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13862         /* Line In pin: input */
13863         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13864         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13865         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13866         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13867         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13868         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13869         /* CD pin widget for input */
13870         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13871
13872         { }
13873 };
13874
13875 /*
13876  * 6-stack pin configuration:
13877  */
13878 static struct hda_verb alc861vd_6stack_init_verbs[] = {
13879         /*
13880          * Set pin mode and muting
13881          */
13882         /* set front pin widgets 0x14 for output */
13883         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13884         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13885         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13886
13887         /* Rear Pin: output 1 (0x0d) */
13888         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13889         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13890         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13891         /* CLFE Pin: output 2 (0x0e) */
13892         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13893         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13894         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
13895         /* Side Pin: output 3 (0x0f) */
13896         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13897         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13898         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
13899
13900         /* Mic (rear) pin: input vref at 80% */
13901         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13902         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13903         /* Front Mic pin: input vref at 80% */
13904         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13905         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13906         /* Line In pin: input */
13907         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13908         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13909         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13910         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13911         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13912         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13913         /* CD pin widget for input */
13914         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13915
13916         { }
13917 };
13918
13919 static struct hda_verb alc861vd_eapd_verbs[] = {
13920         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13921         { }
13922 };
13923
13924 static struct hda_verb alc660vd_eapd_verbs[] = {
13925         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13926         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13927         { }
13928 };
13929
13930 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
13931         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13932         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13933         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
13934         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13935         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13936         {}
13937 };
13938
13939 /* toggle speaker-output according to the hp-jack state */
13940 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
13941 {
13942         unsigned int present;
13943         unsigned char bits;
13944
13945         present = snd_hda_codec_read(codec, 0x1b, 0,
13946                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13947         bits = present ? HDA_AMP_MUTE : 0;
13948         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13949                                  HDA_AMP_MUTE, bits);
13950 }
13951
13952 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
13953 {
13954         unsigned int present;
13955         unsigned char bits;
13956
13957         present = snd_hda_codec_read(codec, 0x18, 0,
13958                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13959         bits = present ? HDA_AMP_MUTE : 0;
13960         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
13961                                  HDA_AMP_MUTE, bits);
13962 }
13963
13964 static void alc861vd_lenovo_automute(struct hda_codec *codec)
13965 {
13966         alc861vd_lenovo_hp_automute(codec);
13967         alc861vd_lenovo_mic_automute(codec);
13968 }
13969
13970 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
13971                                         unsigned int res)
13972 {
13973         switch (res >> 26) {
13974         case ALC880_HP_EVENT:
13975                 alc861vd_lenovo_hp_automute(codec);
13976                 break;
13977         case ALC880_MIC_EVENT:
13978                 alc861vd_lenovo_mic_automute(codec);
13979                 break;
13980         }
13981 }
13982
13983 static struct hda_verb alc861vd_dallas_verbs[] = {
13984         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13985         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13986         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13987         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13988
13989         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13990         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13991         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13992         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13993         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13994         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13995         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13996         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13997
13998         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13999         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14000         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14001         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14002         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14003         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14004         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14005         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14006
14007         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14008         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14009         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14010         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14011         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14012         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14013         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14014         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14015
14016         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14017         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14018         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14019         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14020
14021         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14022         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14023         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14024
14025         { } /* end */
14026 };
14027
14028 /* toggle speaker-output according to the hp-jack state */
14029 static void alc861vd_dallas_automute(struct hda_codec *codec)
14030 {
14031         unsigned int present;
14032
14033         present = snd_hda_codec_read(codec, 0x15, 0,
14034                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14035         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14036                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14037 }
14038
14039 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14040 {
14041         if ((res >> 26) == ALC880_HP_EVENT)
14042                 alc861vd_dallas_automute(codec);
14043 }
14044
14045 #ifdef CONFIG_SND_HDA_POWER_SAVE
14046 #define alc861vd_loopbacks      alc880_loopbacks
14047 #endif
14048
14049 /* pcm configuration: identiacal with ALC880 */
14050 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14051 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14052 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14053 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14054
14055 /*
14056  * configuration and preset
14057  */
14058 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14059         [ALC660VD_3ST]          = "3stack-660",
14060         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14061         [ALC861VD_3ST]          = "3stack",
14062         [ALC861VD_3ST_DIG]      = "3stack-digout",
14063         [ALC861VD_6ST_DIG]      = "6stack-digout",
14064         [ALC861VD_LENOVO]       = "lenovo",
14065         [ALC861VD_DALLAS]       = "dallas",
14066         [ALC861VD_HP]           = "hp",
14067         [ALC861VD_AUTO]         = "auto",
14068 };
14069
14070 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14071         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14072         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14073         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14074         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14075         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
14076         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14077         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14078         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14079         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14080         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14081         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14082         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14083         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14084         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
14085         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
14086         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
14087         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14088         {}
14089 };
14090
14091 static struct alc_config_preset alc861vd_presets[] = {
14092         [ALC660VD_3ST] = {
14093                 .mixers = { alc861vd_3st_mixer },
14094                 .init_verbs = { alc861vd_volume_init_verbs,
14095                                  alc861vd_3stack_init_verbs },
14096                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14097                 .dac_nids = alc660vd_dac_nids,
14098                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14099                 .channel_mode = alc861vd_3stack_2ch_modes,
14100                 .input_mux = &alc861vd_capture_source,
14101         },
14102         [ALC660VD_3ST_DIG] = {
14103                 .mixers = { alc861vd_3st_mixer },
14104                 .init_verbs = { alc861vd_volume_init_verbs,
14105                                  alc861vd_3stack_init_verbs },
14106                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14107                 .dac_nids = alc660vd_dac_nids,
14108                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14109                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14110                 .channel_mode = alc861vd_3stack_2ch_modes,
14111                 .input_mux = &alc861vd_capture_source,
14112         },
14113         [ALC861VD_3ST] = {
14114                 .mixers = { alc861vd_3st_mixer },
14115                 .init_verbs = { alc861vd_volume_init_verbs,
14116                                  alc861vd_3stack_init_verbs },
14117                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14118                 .dac_nids = alc861vd_dac_nids,
14119                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14120                 .channel_mode = alc861vd_3stack_2ch_modes,
14121                 .input_mux = &alc861vd_capture_source,
14122         },
14123         [ALC861VD_3ST_DIG] = {
14124                 .mixers = { alc861vd_3st_mixer },
14125                 .init_verbs = { alc861vd_volume_init_verbs,
14126                                  alc861vd_3stack_init_verbs },
14127                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14128                 .dac_nids = alc861vd_dac_nids,
14129                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14130                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14131                 .channel_mode = alc861vd_3stack_2ch_modes,
14132                 .input_mux = &alc861vd_capture_source,
14133         },
14134         [ALC861VD_6ST_DIG] = {
14135                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14136                 .init_verbs = { alc861vd_volume_init_verbs,
14137                                 alc861vd_6stack_init_verbs },
14138                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14139                 .dac_nids = alc861vd_dac_nids,
14140                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14141                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14142                 .channel_mode = alc861vd_6stack_modes,
14143                 .input_mux = &alc861vd_capture_source,
14144         },
14145         [ALC861VD_LENOVO] = {
14146                 .mixers = { alc861vd_lenovo_mixer },
14147                 .init_verbs = { alc861vd_volume_init_verbs,
14148                                 alc861vd_3stack_init_verbs,
14149                                 alc861vd_eapd_verbs,
14150                                 alc861vd_lenovo_unsol_verbs },
14151                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14152                 .dac_nids = alc660vd_dac_nids,
14153                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14154                 .channel_mode = alc861vd_3stack_2ch_modes,
14155                 .input_mux = &alc861vd_capture_source,
14156                 .unsol_event = alc861vd_lenovo_unsol_event,
14157                 .init_hook = alc861vd_lenovo_automute,
14158         },
14159         [ALC861VD_DALLAS] = {
14160                 .mixers = { alc861vd_dallas_mixer },
14161                 .init_verbs = { alc861vd_dallas_verbs },
14162                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14163                 .dac_nids = alc861vd_dac_nids,
14164                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14165                 .channel_mode = alc861vd_3stack_2ch_modes,
14166                 .input_mux = &alc861vd_dallas_capture_source,
14167                 .unsol_event = alc861vd_dallas_unsol_event,
14168                 .init_hook = alc861vd_dallas_automute,
14169         },
14170         [ALC861VD_HP] = {
14171                 .mixers = { alc861vd_hp_mixer },
14172                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14173                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14174                 .dac_nids = alc861vd_dac_nids,
14175                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14176                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14177                 .channel_mode = alc861vd_3stack_2ch_modes,
14178                 .input_mux = &alc861vd_hp_capture_source,
14179                 .unsol_event = alc861vd_dallas_unsol_event,
14180                 .init_hook = alc861vd_dallas_automute,
14181         },
14182 };
14183
14184 /*
14185  * BIOS auto configuration
14186  */
14187 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14188                                 hda_nid_t nid, int pin_type, int dac_idx)
14189 {
14190         alc_set_pin_output(codec, nid, pin_type);
14191 }
14192
14193 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14194 {
14195         struct alc_spec *spec = codec->spec;
14196         int i;
14197
14198         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14199         for (i = 0; i <= HDA_SIDE; i++) {
14200                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14201                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14202                 if (nid)
14203                         alc861vd_auto_set_output_and_unmute(codec, nid,
14204                                                             pin_type, i);
14205         }
14206 }
14207
14208
14209 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14210 {
14211         struct alc_spec *spec = codec->spec;
14212         hda_nid_t pin;
14213
14214         pin = spec->autocfg.hp_pins[0];
14215         if (pin) /* connect to front and  use dac 0 */
14216                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14217         pin = spec->autocfg.speaker_pins[0];
14218         if (pin)
14219                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14220 }
14221
14222 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14223 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14224
14225 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14226 {
14227         struct alc_spec *spec = codec->spec;
14228         int i;
14229
14230         for (i = 0; i < AUTO_PIN_LAST; i++) {
14231                 hda_nid_t nid = spec->autocfg.input_pins[i];
14232                 if (alc861vd_is_input_pin(nid)) {
14233                         snd_hda_codec_write(codec, nid, 0,
14234                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
14235                                         i <= AUTO_PIN_FRONT_MIC ?
14236                                                         PIN_VREF80 : PIN_IN);
14237                         if (nid != ALC861VD_PIN_CD_NID)
14238                                 snd_hda_codec_write(codec, nid, 0,
14239                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14240                                                 AMP_OUT_MUTE);
14241                 }
14242         }
14243 }
14244
14245 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14246
14247 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14248 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14249
14250 /* add playback controls from the parsed DAC table */
14251 /* Based on ALC880 version. But ALC861VD has separate,
14252  * different NIDs for mute/unmute switch and volume control */
14253 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14254                                              const struct auto_pin_cfg *cfg)
14255 {
14256         char name[32];
14257         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14258         hda_nid_t nid_v, nid_s;
14259         int i, err;
14260
14261         for (i = 0; i < cfg->line_outs; i++) {
14262                 if (!spec->multiout.dac_nids[i])
14263                         continue;
14264                 nid_v = alc861vd_idx_to_mixer_vol(
14265                                 alc880_dac_to_idx(
14266                                         spec->multiout.dac_nids[i]));
14267                 nid_s = alc861vd_idx_to_mixer_switch(
14268                                 alc880_dac_to_idx(
14269                                         spec->multiout.dac_nids[i]));
14270
14271                 if (i == 2) {
14272                         /* Center/LFE */
14273                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14274                                           "Center Playback Volume",
14275                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14276                                                               HDA_OUTPUT));
14277                         if (err < 0)
14278                                 return err;
14279                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14280                                           "LFE Playback Volume",
14281                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14282                                                               HDA_OUTPUT));
14283                         if (err < 0)
14284                                 return err;
14285                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14286                                           "Center Playback Switch",
14287                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14288                                                               HDA_INPUT));
14289                         if (err < 0)
14290                                 return err;
14291                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14292                                           "LFE Playback Switch",
14293                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14294                                                               HDA_INPUT));
14295                         if (err < 0)
14296                                 return err;
14297                 } else {
14298                         sprintf(name, "%s Playback Volume", chname[i]);
14299                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14300                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14301                                                               HDA_OUTPUT));
14302                         if (err < 0)
14303                                 return err;
14304                         sprintf(name, "%s Playback Switch", chname[i]);
14305                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14306                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14307                                                               HDA_INPUT));
14308                         if (err < 0)
14309                                 return err;
14310                 }
14311         }
14312         return 0;
14313 }
14314
14315 /* add playback controls for speaker and HP outputs */
14316 /* Based on ALC880 version. But ALC861VD has separate,
14317  * different NIDs for mute/unmute switch and volume control */
14318 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14319                                         hda_nid_t pin, const char *pfx)
14320 {
14321         hda_nid_t nid_v, nid_s;
14322         int err;
14323         char name[32];
14324
14325         if (!pin)
14326                 return 0;
14327
14328         if (alc880_is_fixed_pin(pin)) {
14329                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14330                 /* specify the DAC as the extra output */
14331                 if (!spec->multiout.hp_nid)
14332                         spec->multiout.hp_nid = nid_v;
14333                 else
14334                         spec->multiout.extra_out_nid[0] = nid_v;
14335                 /* control HP volume/switch on the output mixer amp */
14336                 nid_v = alc861vd_idx_to_mixer_vol(
14337                                 alc880_fixed_pin_idx(pin));
14338                 nid_s = alc861vd_idx_to_mixer_switch(
14339                                 alc880_fixed_pin_idx(pin));
14340
14341                 sprintf(name, "%s Playback Volume", pfx);
14342                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14343                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14344                 if (err < 0)
14345                         return err;
14346                 sprintf(name, "%s Playback Switch", pfx);
14347                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14348                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14349                 if (err < 0)
14350                         return err;
14351         } else if (alc880_is_multi_pin(pin)) {
14352                 /* set manual connection */
14353                 /* we have only a switch on HP-out PIN */
14354                 sprintf(name, "%s Playback Switch", pfx);
14355                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14356                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14357                 if (err < 0)
14358                         return err;
14359         }
14360         return 0;
14361 }
14362
14363 /* parse the BIOS configuration and set up the alc_spec
14364  * return 1 if successful, 0 if the proper config is not found,
14365  * or a negative error code
14366  * Based on ALC880 version - had to change it to override
14367  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14368 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14369 {
14370         struct alc_spec *spec = codec->spec;
14371         int err;
14372         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14373
14374         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14375                                            alc861vd_ignore);
14376         if (err < 0)
14377                 return err;
14378         if (!spec->autocfg.line_outs)
14379                 return 0; /* can't find valid BIOS pin config */
14380
14381         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14382         if (err < 0)
14383                 return err;
14384         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14385         if (err < 0)
14386                 return err;
14387         err = alc861vd_auto_create_extra_out(spec,
14388                                              spec->autocfg.speaker_pins[0],
14389                                              "Speaker");
14390         if (err < 0)
14391                 return err;
14392         err = alc861vd_auto_create_extra_out(spec,
14393                                              spec->autocfg.hp_pins[0],
14394                                              "Headphone");
14395         if (err < 0)
14396                 return err;
14397         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14398         if (err < 0)
14399                 return err;
14400
14401         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14402
14403         if (spec->autocfg.dig_out_pin)
14404                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14405
14406         if (spec->kctl_alloc)
14407                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14408
14409         spec->init_verbs[spec->num_init_verbs++]
14410                 = alc861vd_volume_init_verbs;
14411
14412         spec->num_mux_defs = 1;
14413         spec->input_mux = &spec->private_imux;
14414
14415         err = alc_auto_add_mic_boost(codec);
14416         if (err < 0)
14417                 return err;
14418
14419         return 1;
14420 }
14421
14422 /* additional initialization for auto-configuration model */
14423 static void alc861vd_auto_init(struct hda_codec *codec)
14424 {
14425         struct alc_spec *spec = codec->spec;
14426         alc861vd_auto_init_multi_out(codec);
14427         alc861vd_auto_init_hp_out(codec);
14428         alc861vd_auto_init_analog_input(codec);
14429         alc861vd_auto_init_input_src(codec);
14430         if (spec->unsol_event)
14431                 alc_inithook(codec);
14432 }
14433
14434 static int patch_alc861vd(struct hda_codec *codec)
14435 {
14436         struct alc_spec *spec;
14437         int err, board_config;
14438
14439         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14440         if (spec == NULL)
14441                 return -ENOMEM;
14442
14443         codec->spec = spec;
14444
14445         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14446                                                   alc861vd_models,
14447                                                   alc861vd_cfg_tbl);
14448
14449         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14450                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
14451                         "ALC861VD, trying auto-probe from BIOS...\n");
14452                 board_config = ALC861VD_AUTO;
14453         }
14454
14455         if (board_config == ALC861VD_AUTO) {
14456                 /* automatic parse from the BIOS config */
14457                 err = alc861vd_parse_auto_config(codec);
14458                 if (err < 0) {
14459                         alc_free(codec);
14460                         return err;
14461                 } else if (!err) {
14462                         printk(KERN_INFO
14463                                "hda_codec: Cannot set up configuration "
14464                                "from BIOS.  Using base mode...\n");
14465                         board_config = ALC861VD_3ST;
14466                 }
14467         }
14468
14469         if (board_config != ALC861VD_AUTO)
14470                 setup_preset(spec, &alc861vd_presets[board_config]);
14471
14472         if (codec->vendor_id == 0x10ec0660) {
14473                 spec->stream_name_analog = "ALC660-VD Analog";
14474                 spec->stream_name_digital = "ALC660-VD Digital";
14475                 /* always turn on EAPD */
14476                 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
14477         } else {
14478                 spec->stream_name_analog = "ALC861VD Analog";
14479                 spec->stream_name_digital = "ALC861VD Digital";
14480         }
14481
14482         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14483         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14484
14485         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14486         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14487
14488         spec->adc_nids = alc861vd_adc_nids;
14489         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14490         spec->capsrc_nids = alc861vd_capsrc_nids;
14491
14492         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
14493         spec->num_mixers++;
14494
14495         spec->vmaster_nid = 0x02;
14496
14497         codec->patch_ops = alc_patch_ops;
14498
14499         if (board_config == ALC861VD_AUTO)
14500                 spec->init_hook = alc861vd_auto_init;
14501 #ifdef CONFIG_SND_HDA_POWER_SAVE
14502         if (!spec->loopback.amplist)
14503                 spec->loopback.amplist = alc861vd_loopbacks;
14504 #endif
14505
14506         return 0;
14507 }
14508
14509 /*
14510  * ALC662 support
14511  *
14512  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
14513  * configuration.  Each pin widget can choose any input DACs and a mixer.
14514  * Each ADC is connected from a mixer of all inputs.  This makes possible
14515  * 6-channel independent captures.
14516  *
14517  * In addition, an independent DAC for the multi-playback (not used in this
14518  * driver yet).
14519  */
14520 #define ALC662_DIGOUT_NID       0x06
14521 #define ALC662_DIGIN_NID        0x0a
14522
14523 static hda_nid_t alc662_dac_nids[4] = {
14524         /* front, rear, clfe, rear_surr */
14525         0x02, 0x03, 0x04
14526 };
14527
14528 static hda_nid_t alc662_adc_nids[1] = {
14529         /* ADC1-2 */
14530         0x09,
14531 };
14532
14533 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
14534
14535 /* input MUX */
14536 /* FIXME: should be a matrix-type input source selection */
14537 static struct hda_input_mux alc662_capture_source = {
14538         .num_items = 4,
14539         .items = {
14540                 { "Mic", 0x0 },
14541                 { "Front Mic", 0x1 },
14542                 { "Line", 0x2 },
14543                 { "CD", 0x4 },
14544         },
14545 };
14546
14547 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
14548         .num_items = 2,
14549         .items = {
14550                 { "Mic", 0x1 },
14551                 { "Line", 0x2 },
14552         },
14553 };
14554
14555 static struct hda_input_mux alc662_eeepc_capture_source = {
14556         .num_items = 2,
14557         .items = {
14558                 { "i-Mic", 0x1 },
14559                 { "e-Mic", 0x0 },
14560         },
14561 };
14562
14563 static struct hda_input_mux alc663_capture_source = {
14564         .num_items = 3,
14565         .items = {
14566                 { "Mic", 0x0 },
14567                 { "Front Mic", 0x1 },
14568                 { "Line", 0x2 },
14569         },
14570 };
14571
14572 static struct hda_input_mux alc663_m51va_capture_source = {
14573         .num_items = 2,
14574         .items = {
14575                 { "Ext-Mic", 0x0 },
14576                 { "D-Mic", 0x9 },
14577         },
14578 };
14579
14580 #define alc662_mux_enum_info alc_mux_enum_info
14581 #define alc662_mux_enum_get alc_mux_enum_get
14582 #define alc662_mux_enum_put alc882_mux_enum_put
14583
14584 /*
14585  * 2ch mode
14586  */
14587 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
14588         { 2, NULL }
14589 };
14590
14591 /*
14592  * 2ch mode
14593  */
14594 static struct hda_verb alc662_3ST_ch2_init[] = {
14595         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
14596         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14597         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
14598         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14599         { } /* end */
14600 };
14601
14602 /*
14603  * 6ch mode
14604  */
14605 static struct hda_verb alc662_3ST_ch6_init[] = {
14606         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14607         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14608         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
14609         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14610         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14611         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
14612         { } /* end */
14613 };
14614
14615 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
14616         { 2, alc662_3ST_ch2_init },
14617         { 6, alc662_3ST_ch6_init },
14618 };
14619
14620 /*
14621  * 2ch mode
14622  */
14623 static struct hda_verb alc662_sixstack_ch6_init[] = {
14624         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14625         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14626         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14627         { } /* end */
14628 };
14629
14630 /*
14631  * 6ch mode
14632  */
14633 static struct hda_verb alc662_sixstack_ch8_init[] = {
14634         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14635         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14636         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14637         { } /* end */
14638 };
14639
14640 static struct hda_channel_mode alc662_5stack_modes[2] = {
14641         { 2, alc662_sixstack_ch6_init },
14642         { 6, alc662_sixstack_ch8_init },
14643 };
14644
14645 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14646  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14647  */
14648
14649 static struct snd_kcontrol_new alc662_base_mixer[] = {
14650         /* output mixer control */
14651         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
14652         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14653         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
14654         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14655         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14656         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14657         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14658         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14659         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14660
14661         /*Input mixer control */
14662         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
14663         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
14664         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
14665         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
14666         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
14667         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
14668         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
14669         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
14670         { } /* end */
14671 };
14672
14673 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
14674         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14675         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14676         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14677         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14678         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14679         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14680         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14681         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14682         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14683         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14684         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14685         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14686         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14687         { } /* end */
14688 };
14689
14690 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
14691         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14692         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14693         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14694         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14695         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14696         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14697         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14698         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14699         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14700         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14701         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14702         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14703         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14704         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14705         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14706         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14707         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14708         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14709         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14710         { } /* end */
14711 };
14712
14713 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
14714         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14715         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
14716         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14717         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
14718         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14719         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14720         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14721         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14722         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14723         { } /* end */
14724 };
14725
14726 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
14727         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14728
14729         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14730         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14731
14732         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
14733         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14734         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14735
14736         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
14737         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14738         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14739         { } /* end */
14740 };
14741
14742 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
14743         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14744         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14745         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14746         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
14747         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14748         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14749         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
14750         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
14751         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14752         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
14753         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14754         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14755         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14756         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14757         { } /* end */
14758 };
14759
14760 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
14761         .ops = &snd_hda_bind_vol,
14762         .values = {
14763                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14764                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
14765                 0
14766         },
14767 };
14768
14769 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
14770         .ops = &snd_hda_bind_sw,
14771         .values = {
14772                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14773                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14774                 0
14775         },
14776 };
14777
14778 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
14779         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14780         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
14781         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14782         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14783         { } /* end */
14784 };
14785
14786 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
14787         .ops = &snd_hda_bind_sw,
14788         .values = {
14789                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14790                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14791                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14792                 0
14793         },
14794 };
14795
14796 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
14797         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14798         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
14799         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14800         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14801         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14802         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14803
14804         { } /* end */
14805 };
14806
14807 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
14808         .ops = &snd_hda_bind_sw,
14809         .values = {
14810                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14811                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14812                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
14813                 0
14814         },
14815 };
14816
14817 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
14818         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14819         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
14820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14822         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14823         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14824         { } /* end */
14825 };
14826
14827 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
14828         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14829         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14830         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14831         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14832         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14833         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14834         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14835         { } /* end */
14836 };
14837
14838 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
14839         .ops = &snd_hda_bind_vol,
14840         .values = {
14841                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14842                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
14843                 0
14844         },
14845 };
14846
14847 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
14848         .ops = &snd_hda_bind_sw,
14849         .values = {
14850                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14851                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
14852                 0
14853         },
14854 };
14855
14856 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
14857         HDA_BIND_VOL("Master Playback Volume",
14858                                 &alc663_asus_two_bind_master_vol),
14859         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14860         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14861         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14862         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14863         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14864         { } /* end */
14865 };
14866
14867 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
14868         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14869         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14870         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14871         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14872         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14873         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14874         { } /* end */
14875 };
14876
14877 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
14878         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14879         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14880         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14881         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14882         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14883
14884         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14885         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14886         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14887         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14888         { } /* end */
14889 };
14890
14891 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
14892         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14893         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14894         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14895
14896         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14897         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14898         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14899         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14902         { } /* end */
14903 };
14904
14905 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
14906         {
14907                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14908                 .name = "Channel Mode",
14909                 .info = alc_ch_mode_info,
14910                 .get = alc_ch_mode_get,
14911                 .put = alc_ch_mode_put,
14912         },
14913         { } /* end */
14914 };
14915
14916 static struct hda_verb alc662_init_verbs[] = {
14917         /* ADC: mute amp left and right */
14918         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14919         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14920         /* Front mixer: unmute input/output amp left and right (volume = 0) */
14921
14922         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14923         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14924         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14925         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14926         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14927
14928         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14929         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14930         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14931         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14932         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14933         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14934
14935         /* Front Pin: output 0 (0x0c) */
14936         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14937         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14938
14939         /* Rear Pin: output 1 (0x0d) */
14940         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14941         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14942
14943         /* CLFE Pin: output 2 (0x0e) */
14944         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14945         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14946
14947         /* Mic (rear) pin: input vref at 80% */
14948         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14949         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14950         /* Front Mic pin: input vref at 80% */
14951         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14952         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14953         /* Line In pin: input */
14954         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14955         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14956         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14957         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14958         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14959         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14960         /* CD pin widget for input */
14961         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14962
14963         /* FIXME: use matrix-type input source selection */
14964         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
14965         /* Input mixer */
14966         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14967         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14968         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14969         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14970
14971         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14972         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14973         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14974         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14975
14976         /* always trun on EAPD */
14977         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14978         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14979
14980         { }
14981 };
14982
14983 static struct hda_verb alc662_sue_init_verbs[] = {
14984         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
14985         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
14986         {}
14987 };
14988
14989 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
14990         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14991         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14992         {}
14993 };
14994
14995 /* Set Unsolicited Event*/
14996 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
14997         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14998         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14999         {}
15000 };
15001
15002 /*
15003  * generic initialization of ADC, input mixers and output mixers
15004  */
15005 static struct hda_verb alc662_auto_init_verbs[] = {
15006         /*
15007          * Unmute ADC and set the default input to mic-in
15008          */
15009         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15010         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15011
15012         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15013          * mixer widget
15014          * Note: PASD motherboards uses the Line In 2 as the input for front
15015          * panel mic (mic 2)
15016          */
15017         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15018         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15019         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15020         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15021         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15022         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15023
15024         /*
15025          * Set up output mixers (0x0c - 0x0f)
15026          */
15027         /* set vol=0 to output mixers */
15028         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15029         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15030         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15031
15032         /* set up input amps for analog loopback */
15033         /* Amp Indices: DAC = 0, mixer = 1 */
15034         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15035         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15036         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15037         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15038         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15039         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15040
15041
15042         /* FIXME: use matrix-type input source selection */
15043         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15044         /* Input mixer */
15045         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15046         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15047         { }
15048 };
15049
15050 /* additional verbs for ALC663 */
15051 static struct hda_verb alc663_auto_init_verbs[] = {
15052         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15053         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15054         { }
15055 };
15056
15057 static struct hda_verb alc663_m51va_init_verbs[] = {
15058         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15059         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15060         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15061         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15062         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15063         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15064         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15065         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15066         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15067         {}
15068 };
15069
15070 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15071         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15072         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15073         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15074         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15075         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15076         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15077         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15078         {}
15079 };
15080
15081 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15082         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15083         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15084         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15085         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15086         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15087         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15088         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15089         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15090         {}
15091 };
15092
15093 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15094         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15095         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15096         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15097         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15098         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15099         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15100         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15101         {}
15102 };
15103
15104 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15105         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15106         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15107         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15108         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15109         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15110         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15111         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15112         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15113         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15114         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15115         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15116         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15117         {}
15118 };
15119
15120 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15121         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15122         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15123         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15124         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15125         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15126         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15127         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15128         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15129         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15130         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15131         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15132         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15133         {}
15134 };
15135
15136 static struct hda_verb alc663_g71v_init_verbs[] = {
15137         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15138         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15139         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15140
15141         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15142         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15143         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15144
15145         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15146         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15147         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15148         {}
15149 };
15150
15151 static struct hda_verb alc663_g50v_init_verbs[] = {
15152         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15153         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15154         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15155
15156         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15157         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15158         {}
15159 };
15160
15161 static struct hda_verb alc662_ecs_init_verbs[] = {
15162         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15163         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15164         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15165         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15166         {}
15167 };
15168
15169 /* capture mixer elements */
15170 static struct snd_kcontrol_new alc662_capture_mixer[] = {
15171         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15172         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15173         {
15174                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15175                 /* The multiple "Capture Source" controls confuse alsamixer
15176                  * So call somewhat different..
15177                  */
15178                 /* .name = "Capture Source", */
15179                 .name = "Input Source",
15180                 .count = 1,
15181                 .info = alc662_mux_enum_info,
15182                 .get = alc662_mux_enum_get,
15183                 .put = alc662_mux_enum_put,
15184         },
15185         { } /* end */
15186 };
15187
15188 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15189         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15190         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15191         { } /* end */
15192 };
15193
15194 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15195 {
15196         unsigned int present;
15197         unsigned char bits;
15198
15199         present = snd_hda_codec_read(codec, 0x14, 0,
15200                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15201         bits = present ? HDA_AMP_MUTE : 0;
15202         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15203                                  HDA_AMP_MUTE, bits);
15204 }
15205
15206 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15207 {
15208         unsigned int present;
15209         unsigned char bits;
15210
15211         present = snd_hda_codec_read(codec, 0x1b, 0,
15212                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15213         bits = present ? HDA_AMP_MUTE : 0;
15214         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15215                                  HDA_AMP_MUTE, bits);
15216         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15217                                  HDA_AMP_MUTE, bits);
15218 }
15219
15220 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15221                                            unsigned int res)
15222 {
15223         if ((res >> 26) == ALC880_HP_EVENT)
15224                 alc662_lenovo_101e_all_automute(codec);
15225         if ((res >> 26) == ALC880_FRONT_EVENT)
15226                 alc662_lenovo_101e_ispeaker_automute(codec);
15227 }
15228
15229 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15230 {
15231         unsigned int present;
15232
15233         present = snd_hda_codec_read(codec, 0x18, 0,
15234                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15235         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15236                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15237         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15238                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15239         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15240                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15241         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15242                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15243 }
15244
15245 /* unsolicited event for HP jack sensing */
15246 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15247                                      unsigned int res)
15248 {
15249         if ((res >> 26) == ALC880_HP_EVENT)
15250                 alc262_hippo1_automute( codec );
15251
15252         if ((res >> 26) == ALC880_MIC_EVENT)
15253                 alc662_eeepc_mic_automute(codec);
15254 }
15255
15256 static void alc662_eeepc_inithook(struct hda_codec *codec)
15257 {
15258         alc262_hippo1_automute( codec );
15259         alc662_eeepc_mic_automute(codec);
15260 }
15261
15262 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15263 {
15264         unsigned int mute;
15265         unsigned int present;
15266
15267         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15268         present = snd_hda_codec_read(codec, 0x14, 0,
15269                                      AC_VERB_GET_PIN_SENSE, 0);
15270         present = (present & 0x80000000) != 0;
15271         if (present) {
15272                 /* mute internal speaker */
15273                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15274                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15275         } else {
15276                 /* unmute internal speaker if necessary */
15277                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15278                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15279                                         HDA_AMP_MUTE, mute);
15280         }
15281 }
15282
15283 /* unsolicited event for HP jack sensing */
15284 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15285                                           unsigned int res)
15286 {
15287         if ((res >> 26) == ALC880_HP_EVENT)
15288                 alc662_eeepc_ep20_automute(codec);
15289 }
15290
15291 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15292 {
15293         alc662_eeepc_ep20_automute(codec);
15294 }
15295
15296 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15297 {
15298         unsigned int present;
15299         unsigned char bits;
15300
15301         present = snd_hda_codec_read(codec, 0x21, 0,
15302                         AC_VERB_GET_PIN_SENSE, 0)
15303                         & AC_PINSENSE_PRESENCE;
15304         bits = present ? HDA_AMP_MUTE : 0;
15305         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15306                                 AMP_IN_MUTE(0), bits);
15307         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15308                                 AMP_IN_MUTE(0), bits);
15309 }
15310
15311 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15312 {
15313         unsigned int present;
15314         unsigned char bits;
15315
15316         present = snd_hda_codec_read(codec, 0x21, 0,
15317                         AC_VERB_GET_PIN_SENSE, 0)
15318                         & AC_PINSENSE_PRESENCE;
15319         bits = present ? HDA_AMP_MUTE : 0;
15320         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15321                                 AMP_IN_MUTE(0), bits);
15322         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15323                                 AMP_IN_MUTE(0), bits);
15324         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15325                                 AMP_IN_MUTE(0), bits);
15326         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15327                                 AMP_IN_MUTE(0), bits);
15328 }
15329
15330 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15331 {
15332         unsigned int present;
15333         unsigned char bits;
15334
15335         present = snd_hda_codec_read(codec, 0x15, 0,
15336                         AC_VERB_GET_PIN_SENSE, 0)
15337                         & AC_PINSENSE_PRESENCE;
15338         bits = present ? HDA_AMP_MUTE : 0;
15339         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15340                                 AMP_IN_MUTE(0), bits);
15341         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15342                                 AMP_IN_MUTE(0), bits);
15343         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15344                                 AMP_IN_MUTE(0), bits);
15345         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15346                                 AMP_IN_MUTE(0), bits);
15347 }
15348
15349 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15350 {
15351         unsigned int present;
15352         unsigned char bits;
15353
15354         present = snd_hda_codec_read(codec, 0x1b, 0,
15355                         AC_VERB_GET_PIN_SENSE, 0)
15356                         & AC_PINSENSE_PRESENCE;
15357         bits = present ? 0 : PIN_OUT;
15358         snd_hda_codec_write(codec, 0x14, 0,
15359                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15360 }
15361
15362 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15363 {
15364         unsigned int present1, present2;
15365
15366         present1 = snd_hda_codec_read(codec, 0x21, 0,
15367                         AC_VERB_GET_PIN_SENSE, 0)
15368                         & AC_PINSENSE_PRESENCE;
15369         present2 = snd_hda_codec_read(codec, 0x15, 0,
15370                         AC_VERB_GET_PIN_SENSE, 0)
15371                         & AC_PINSENSE_PRESENCE;
15372
15373         if (present1 || present2) {
15374                 snd_hda_codec_write_cache(codec, 0x14, 0,
15375                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15376         } else {
15377                 snd_hda_codec_write_cache(codec, 0x14, 0,
15378                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15379         }
15380 }
15381
15382 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15383 {
15384         unsigned int present1, present2;
15385
15386         present1 = snd_hda_codec_read(codec, 0x1b, 0,
15387                                 AC_VERB_GET_PIN_SENSE, 0)
15388                                 & AC_PINSENSE_PRESENCE;
15389         present2 = snd_hda_codec_read(codec, 0x15, 0,
15390                                 AC_VERB_GET_PIN_SENSE, 0)
15391                                 & AC_PINSENSE_PRESENCE;
15392
15393         if (present1 || present2) {
15394                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15395                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15396                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15397                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15398         } else {
15399                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15400                                 AMP_IN_MUTE(0), 0);
15401                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15402                                 AMP_IN_MUTE(0), 0);
15403         }
15404 }
15405
15406 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15407 {
15408         unsigned int present;
15409
15410         present = snd_hda_codec_read(codec, 0x18, 0,
15411                         AC_VERB_GET_PIN_SENSE, 0)
15412                         & AC_PINSENSE_PRESENCE;
15413         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15414                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15415         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15416                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15417         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15418                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15419         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15420                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15421 }
15422
15423 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15424                                            unsigned int res)
15425 {
15426         switch (res >> 26) {
15427         case ALC880_HP_EVENT:
15428                 alc663_m51va_speaker_automute(codec);
15429                 break;
15430         case ALC880_MIC_EVENT:
15431                 alc663_m51va_mic_automute(codec);
15432                 break;
15433         }
15434 }
15435
15436 static void alc663_m51va_inithook(struct hda_codec *codec)
15437 {
15438         alc663_m51va_speaker_automute(codec);
15439         alc663_m51va_mic_automute(codec);
15440 }
15441
15442 /* ***************** Mode1 ******************************/
15443 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15444                                            unsigned int res)
15445 {
15446         switch (res >> 26) {
15447         case ALC880_HP_EVENT:
15448                 alc663_m51va_speaker_automute(codec);
15449                 break;
15450         case ALC880_MIC_EVENT:
15451                 alc662_eeepc_mic_automute(codec);
15452                 break;
15453         }
15454 }
15455
15456 static void alc663_mode1_inithook(struct hda_codec *codec)
15457 {
15458         alc663_m51va_speaker_automute(codec);
15459         alc662_eeepc_mic_automute(codec);
15460 }
15461 /* ***************** Mode2 ******************************/
15462 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15463                                            unsigned int res)
15464 {
15465         switch (res >> 26) {
15466         case ALC880_HP_EVENT:
15467                 alc662_f5z_speaker_automute(codec);
15468                 break;
15469         case ALC880_MIC_EVENT:
15470                 alc662_eeepc_mic_automute(codec);
15471                 break;
15472         }
15473 }
15474
15475 static void alc662_mode2_inithook(struct hda_codec *codec)
15476 {
15477         alc662_f5z_speaker_automute(codec);
15478         alc662_eeepc_mic_automute(codec);
15479 }
15480 /* ***************** Mode3 ******************************/
15481 static void alc663_mode3_unsol_event(struct hda_codec *codec,
15482                                            unsigned int res)
15483 {
15484         switch (res >> 26) {
15485         case ALC880_HP_EVENT:
15486                 alc663_two_hp_m1_speaker_automute(codec);
15487                 break;
15488         case ALC880_MIC_EVENT:
15489                 alc662_eeepc_mic_automute(codec);
15490                 break;
15491         }
15492 }
15493
15494 static void alc663_mode3_inithook(struct hda_codec *codec)
15495 {
15496         alc663_two_hp_m1_speaker_automute(codec);
15497         alc662_eeepc_mic_automute(codec);
15498 }
15499 /* ***************** Mode4 ******************************/
15500 static void alc663_mode4_unsol_event(struct hda_codec *codec,
15501                                            unsigned int res)
15502 {
15503         switch (res >> 26) {
15504         case ALC880_HP_EVENT:
15505                 alc663_21jd_two_speaker_automute(codec);
15506                 break;
15507         case ALC880_MIC_EVENT:
15508                 alc662_eeepc_mic_automute(codec);
15509                 break;
15510         }
15511 }
15512
15513 static void alc663_mode4_inithook(struct hda_codec *codec)
15514 {
15515         alc663_21jd_two_speaker_automute(codec);
15516         alc662_eeepc_mic_automute(codec);
15517 }
15518 /* ***************** Mode5 ******************************/
15519 static void alc663_mode5_unsol_event(struct hda_codec *codec,
15520                                            unsigned int res)
15521 {
15522         switch (res >> 26) {
15523         case ALC880_HP_EVENT:
15524                 alc663_15jd_two_speaker_automute(codec);
15525                 break;
15526         case ALC880_MIC_EVENT:
15527                 alc662_eeepc_mic_automute(codec);
15528                 break;
15529         }
15530 }
15531
15532 static void alc663_mode5_inithook(struct hda_codec *codec)
15533 {
15534         alc663_15jd_two_speaker_automute(codec);
15535         alc662_eeepc_mic_automute(codec);
15536 }
15537 /* ***************** Mode6 ******************************/
15538 static void alc663_mode6_unsol_event(struct hda_codec *codec,
15539                                            unsigned int res)
15540 {
15541         switch (res >> 26) {
15542         case ALC880_HP_EVENT:
15543                 alc663_two_hp_m2_speaker_automute(codec);
15544                 break;
15545         case ALC880_MIC_EVENT:
15546                 alc662_eeepc_mic_automute(codec);
15547                 break;
15548         }
15549 }
15550
15551 static void alc663_mode6_inithook(struct hda_codec *codec)
15552 {
15553         alc663_two_hp_m2_speaker_automute(codec);
15554         alc662_eeepc_mic_automute(codec);
15555 }
15556
15557 static void alc663_g71v_hp_automute(struct hda_codec *codec)
15558 {
15559         unsigned int present;
15560         unsigned char bits;
15561
15562         present = snd_hda_codec_read(codec, 0x21, 0,
15563                                      AC_VERB_GET_PIN_SENSE, 0)
15564                 & AC_PINSENSE_PRESENCE;
15565         bits = present ? HDA_AMP_MUTE : 0;
15566         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15567                                  HDA_AMP_MUTE, bits);
15568         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15569                                  HDA_AMP_MUTE, bits);
15570 }
15571
15572 static void alc663_g71v_front_automute(struct hda_codec *codec)
15573 {
15574         unsigned int present;
15575         unsigned char bits;
15576
15577         present = snd_hda_codec_read(codec, 0x15, 0,
15578                                      AC_VERB_GET_PIN_SENSE, 0)
15579                 & AC_PINSENSE_PRESENCE;
15580         bits = present ? HDA_AMP_MUTE : 0;
15581         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15582                                  HDA_AMP_MUTE, bits);
15583 }
15584
15585 static void alc663_g71v_unsol_event(struct hda_codec *codec,
15586                                            unsigned int res)
15587 {
15588         switch (res >> 26) {
15589         case ALC880_HP_EVENT:
15590                 alc663_g71v_hp_automute(codec);
15591                 break;
15592         case ALC880_FRONT_EVENT:
15593                 alc663_g71v_front_automute(codec);
15594                 break;
15595         case ALC880_MIC_EVENT:
15596                 alc662_eeepc_mic_automute(codec);
15597                 break;
15598         }
15599 }
15600
15601 static void alc663_g71v_inithook(struct hda_codec *codec)
15602 {
15603         alc663_g71v_front_automute(codec);
15604         alc663_g71v_hp_automute(codec);
15605         alc662_eeepc_mic_automute(codec);
15606 }
15607
15608 static void alc663_g50v_unsol_event(struct hda_codec *codec,
15609                                            unsigned int res)
15610 {
15611         switch (res >> 26) {
15612         case ALC880_HP_EVENT:
15613                 alc663_m51va_speaker_automute(codec);
15614                 break;
15615         case ALC880_MIC_EVENT:
15616                 alc662_eeepc_mic_automute(codec);
15617                 break;
15618         }
15619 }
15620
15621 static void alc663_g50v_inithook(struct hda_codec *codec)
15622 {
15623         alc663_m51va_speaker_automute(codec);
15624         alc662_eeepc_mic_automute(codec);
15625 }
15626
15627 /* bind hp and internal speaker mute (with plug check) */
15628 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
15629                                      struct snd_ctl_elem_value *ucontrol)
15630 {
15631         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
15632         long *valp = ucontrol->value.integer.value;
15633         int change;
15634
15635         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
15636                                           HDA_AMP_MUTE,
15637                                           valp[0] ? 0 : HDA_AMP_MUTE);
15638         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
15639                                            HDA_AMP_MUTE,
15640                                            valp[1] ? 0 : HDA_AMP_MUTE);
15641         if (change)
15642                 alc262_hippo1_automute(codec);
15643         return change;
15644 }
15645
15646 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
15647         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15648         {
15649                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15650                 .name = "Master Playback Switch",
15651                 .info = snd_hda_mixer_amp_switch_info,
15652                 .get = snd_hda_mixer_amp_switch_get,
15653                 .put = alc662_ecs_master_sw_put,
15654                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15655         },
15656
15657         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
15658         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
15659         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
15660
15661         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15662         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15663         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15664         { } /* end */
15665 };
15666
15667 #ifdef CONFIG_SND_HDA_POWER_SAVE
15668 #define alc662_loopbacks        alc880_loopbacks
15669 #endif
15670
15671
15672 /* pcm configuration: identiacal with ALC880 */
15673 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
15674 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
15675 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
15676 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
15677
15678 /*
15679  * configuration and preset
15680  */
15681 static const char *alc662_models[ALC662_MODEL_LAST] = {
15682         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
15683         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
15684         [ALC662_3ST_6ch]        = "3stack-6ch",
15685         [ALC662_5ST_DIG]        = "6stack-dig",
15686         [ALC662_LENOVO_101E]    = "lenovo-101e",
15687         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
15688         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
15689         [ALC662_ECS] = "ecs",
15690         [ALC663_ASUS_M51VA] = "m51va",
15691         [ALC663_ASUS_G71V] = "g71v",
15692         [ALC663_ASUS_H13] = "h13",
15693         [ALC663_ASUS_G50V] = "g50v",
15694         [ALC663_ASUS_MODE1] = "asus-mode1",
15695         [ALC662_ASUS_MODE2] = "asus-mode2",
15696         [ALC663_ASUS_MODE3] = "asus-mode3",
15697         [ALC663_ASUS_MODE4] = "asus-mode4",
15698         [ALC663_ASUS_MODE5] = "asus-mode5",
15699         [ALC663_ASUS_MODE6] = "asus-mode6",
15700         [ALC662_AUTO]           = "auto",
15701 };
15702
15703 static struct snd_pci_quirk alc662_cfg_tbl[] = {
15704         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
15705         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS M51VA", ALC663_ASUS_G50V),
15706         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
15707         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
15708         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
15709         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
15710         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),
15711         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
15712         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
15713         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
15714         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),
15715         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
15716         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
15717         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
15718         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
15719         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
15720         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
15721         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
15722         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
15723         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
15724         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
15725         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
15726         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
15727         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
15728         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
15729         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
15730         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
15731         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
15732         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
15733         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
15734         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
15735         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
15736         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
15737         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
15738         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
15739         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
15740         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
15741                       ALC662_3ST_6ch_DIG),
15742         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
15743         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
15744         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
15745         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
15746                       ALC662_3ST_6ch_DIG),
15747         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
15748         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
15749                                         ALC662_3ST_6ch_DIG),
15750         SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
15751         SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
15752         SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
15753         {}
15754 };
15755
15756 static struct alc_config_preset alc662_presets[] = {
15757         [ALC662_3ST_2ch_DIG] = {
15758                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
15759                 .init_verbs = { alc662_init_verbs },
15760                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15761                 .dac_nids = alc662_dac_nids,
15762                 .dig_out_nid = ALC662_DIGOUT_NID,
15763                 .dig_in_nid = ALC662_DIGIN_NID,
15764                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15765                 .channel_mode = alc662_3ST_2ch_modes,
15766                 .input_mux = &alc662_capture_source,
15767         },
15768         [ALC662_3ST_6ch_DIG] = {
15769                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15770                             alc662_capture_mixer },
15771                 .init_verbs = { alc662_init_verbs },
15772                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15773                 .dac_nids = alc662_dac_nids,
15774                 .dig_out_nid = ALC662_DIGOUT_NID,
15775                 .dig_in_nid = ALC662_DIGIN_NID,
15776                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15777                 .channel_mode = alc662_3ST_6ch_modes,
15778                 .need_dac_fix = 1,
15779                 .input_mux = &alc662_capture_source,
15780         },
15781         [ALC662_3ST_6ch] = {
15782                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15783                             alc662_capture_mixer },
15784                 .init_verbs = { alc662_init_verbs },
15785                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15786                 .dac_nids = alc662_dac_nids,
15787                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15788                 .channel_mode = alc662_3ST_6ch_modes,
15789                 .need_dac_fix = 1,
15790                 .input_mux = &alc662_capture_source,
15791         },
15792         [ALC662_5ST_DIG] = {
15793                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
15794                             alc662_capture_mixer },
15795                 .init_verbs = { alc662_init_verbs },
15796                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15797                 .dac_nids = alc662_dac_nids,
15798                 .dig_out_nid = ALC662_DIGOUT_NID,
15799                 .dig_in_nid = ALC662_DIGIN_NID,
15800                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
15801                 .channel_mode = alc662_5stack_modes,
15802                 .input_mux = &alc662_capture_source,
15803         },
15804         [ALC662_LENOVO_101E] = {
15805                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
15806                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
15807                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15808                 .dac_nids = alc662_dac_nids,
15809                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15810                 .channel_mode = alc662_3ST_2ch_modes,
15811                 .input_mux = &alc662_lenovo_101e_capture_source,
15812                 .unsol_event = alc662_lenovo_101e_unsol_event,
15813                 .init_hook = alc662_lenovo_101e_all_automute,
15814         },
15815         [ALC662_ASUS_EEEPC_P701] = {
15816                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
15817                 .init_verbs = { alc662_init_verbs,
15818                                 alc662_eeepc_sue_init_verbs },
15819                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15820                 .dac_nids = alc662_dac_nids,
15821                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15822                 .channel_mode = alc662_3ST_2ch_modes,
15823                 .input_mux = &alc662_eeepc_capture_source,
15824                 .unsol_event = alc662_eeepc_unsol_event,
15825                 .init_hook = alc662_eeepc_inithook,
15826         },
15827         [ALC662_ASUS_EEEPC_EP20] = {
15828                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
15829                             alc662_chmode_mixer },
15830                 .init_verbs = { alc662_init_verbs,
15831                                 alc662_eeepc_ep20_sue_init_verbs },
15832                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15833                 .dac_nids = alc662_dac_nids,
15834                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15835                 .channel_mode = alc662_3ST_6ch_modes,
15836                 .input_mux = &alc662_lenovo_101e_capture_source,
15837                 .unsol_event = alc662_eeepc_ep20_unsol_event,
15838                 .init_hook = alc662_eeepc_ep20_inithook,
15839         },
15840         [ALC662_ECS] = {
15841                 .mixers = { alc662_ecs_mixer, alc662_capture_mixer },
15842                 .init_verbs = { alc662_init_verbs,
15843                                 alc662_ecs_init_verbs },
15844                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15845                 .dac_nids = alc662_dac_nids,
15846                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15847                 .channel_mode = alc662_3ST_2ch_modes,
15848                 .input_mux = &alc662_eeepc_capture_source,
15849                 .unsol_event = alc662_eeepc_unsol_event,
15850                 .init_hook = alc662_eeepc_inithook,
15851         },
15852         [ALC663_ASUS_M51VA] = {
15853                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15854                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15855                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15856                 .dac_nids = alc662_dac_nids,
15857                 .dig_out_nid = ALC662_DIGOUT_NID,
15858                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15859                 .channel_mode = alc662_3ST_2ch_modes,
15860                 .input_mux = &alc663_m51va_capture_source,
15861                 .unsol_event = alc663_m51va_unsol_event,
15862                 .init_hook = alc663_m51va_inithook,
15863         },
15864         [ALC663_ASUS_G71V] = {
15865                 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
15866                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
15867                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15868                 .dac_nids = alc662_dac_nids,
15869                 .dig_out_nid = ALC662_DIGOUT_NID,
15870                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15871                 .channel_mode = alc662_3ST_2ch_modes,
15872                 .input_mux = &alc662_eeepc_capture_source,
15873                 .unsol_event = alc663_g71v_unsol_event,
15874                 .init_hook = alc663_g71v_inithook,
15875         },
15876         [ALC663_ASUS_H13] = {
15877                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15878                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15879                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15880                 .dac_nids = alc662_dac_nids,
15881                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15882                 .channel_mode = alc662_3ST_2ch_modes,
15883                 .input_mux = &alc663_m51va_capture_source,
15884                 .unsol_event = alc663_m51va_unsol_event,
15885                 .init_hook = alc663_m51va_inithook,
15886         },
15887         [ALC663_ASUS_G50V] = {
15888                 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
15889                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
15890                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15891                 .dac_nids = alc662_dac_nids,
15892                 .dig_out_nid = ALC662_DIGOUT_NID,
15893                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15894                 .channel_mode = alc662_3ST_6ch_modes,
15895                 .input_mux = &alc663_capture_source,
15896                 .unsol_event = alc663_g50v_unsol_event,
15897                 .init_hook = alc663_g50v_inithook,
15898         },
15899         [ALC663_ASUS_MODE1] = {
15900                 .mixers = { alc663_m51va_mixer, alc662_auto_capture_mixer },
15901                 .init_verbs = { alc662_init_verbs,
15902                                 alc663_21jd_amic_init_verbs },
15903                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15904                 .hp_nid = 0x03,
15905                 .dac_nids = alc662_dac_nids,
15906                 .dig_out_nid = ALC662_DIGOUT_NID,
15907                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15908                 .channel_mode = alc662_3ST_2ch_modes,
15909                 .input_mux = &alc662_eeepc_capture_source,
15910                 .unsol_event = alc663_mode1_unsol_event,
15911                 .init_hook = alc663_mode1_inithook,
15912         },
15913         [ALC662_ASUS_MODE2] = {
15914                 .mixers = { alc662_1bjd_mixer, alc662_auto_capture_mixer },
15915                 .init_verbs = { alc662_init_verbs,
15916                                 alc662_1bjd_amic_init_verbs },
15917                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15918                 .dac_nids = alc662_dac_nids,
15919                 .dig_out_nid = ALC662_DIGOUT_NID,
15920                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15921                 .channel_mode = alc662_3ST_2ch_modes,
15922                 .input_mux = &alc662_eeepc_capture_source,
15923                 .unsol_event = alc662_mode2_unsol_event,
15924                 .init_hook = alc662_mode2_inithook,
15925         },
15926         [ALC663_ASUS_MODE3] = {
15927                 .mixers = { alc663_two_hp_m1_mixer, alc662_auto_capture_mixer },
15928                 .init_verbs = { alc662_init_verbs,
15929                                 alc663_two_hp_amic_m1_init_verbs },
15930                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15931                 .hp_nid = 0x03,
15932                 .dac_nids = alc662_dac_nids,
15933                 .dig_out_nid = ALC662_DIGOUT_NID,
15934                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15935                 .channel_mode = alc662_3ST_2ch_modes,
15936                 .input_mux = &alc662_eeepc_capture_source,
15937                 .unsol_event = alc663_mode3_unsol_event,
15938                 .init_hook = alc663_mode3_inithook,
15939         },
15940         [ALC663_ASUS_MODE4] = {
15941                 .mixers = { alc663_asus_21jd_clfe_mixer,
15942                                 alc662_auto_capture_mixer},
15943                 .init_verbs = { alc662_init_verbs,
15944                                 alc663_21jd_amic_init_verbs},
15945                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15946                 .hp_nid = 0x03,
15947                 .dac_nids = alc662_dac_nids,
15948                 .dig_out_nid = ALC662_DIGOUT_NID,
15949                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15950                 .channel_mode = alc662_3ST_2ch_modes,
15951                 .input_mux = &alc662_eeepc_capture_source,
15952                 .unsol_event = alc663_mode4_unsol_event,
15953                 .init_hook = alc663_mode4_inithook,
15954         },
15955         [ALC663_ASUS_MODE5] = {
15956                 .mixers = { alc663_asus_15jd_clfe_mixer,
15957                                 alc662_auto_capture_mixer },
15958                 .init_verbs = { alc662_init_verbs,
15959                                 alc663_15jd_amic_init_verbs },
15960                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15961                 .hp_nid = 0x03,
15962                 .dac_nids = alc662_dac_nids,
15963                 .dig_out_nid = ALC662_DIGOUT_NID,
15964                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15965                 .channel_mode = alc662_3ST_2ch_modes,
15966                 .input_mux = &alc662_eeepc_capture_source,
15967                 .unsol_event = alc663_mode5_unsol_event,
15968                 .init_hook = alc663_mode5_inithook,
15969         },
15970         [ALC663_ASUS_MODE6] = {
15971                 .mixers = { alc663_two_hp_m2_mixer, alc662_auto_capture_mixer },
15972                 .init_verbs = { alc662_init_verbs,
15973                                 alc663_two_hp_amic_m2_init_verbs },
15974                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15975                 .hp_nid = 0x03,
15976                 .dac_nids = alc662_dac_nids,
15977                 .dig_out_nid = ALC662_DIGOUT_NID,
15978                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15979                 .channel_mode = alc662_3ST_2ch_modes,
15980                 .input_mux = &alc662_eeepc_capture_source,
15981                 .unsol_event = alc663_mode6_unsol_event,
15982                 .init_hook = alc663_mode6_inithook,
15983         },
15984 };
15985
15986
15987 /*
15988  * BIOS auto configuration
15989  */
15990
15991 /* add playback controls from the parsed DAC table */
15992 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
15993                                              const struct auto_pin_cfg *cfg)
15994 {
15995         char name[32];
15996         static const char *chname[4] = {
15997                 "Front", "Surround", NULL /*CLFE*/, "Side"
15998         };
15999         hda_nid_t nid;
16000         int i, err;
16001
16002         for (i = 0; i < cfg->line_outs; i++) {
16003                 if (!spec->multiout.dac_nids[i])
16004                         continue;
16005                 nid = alc880_idx_to_dac(i);
16006                 if (i == 2) {
16007                         /* Center/LFE */
16008                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16009                                           "Center Playback Volume",
16010                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16011                                                               HDA_OUTPUT));
16012                         if (err < 0)
16013                                 return err;
16014                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16015                                           "LFE Playback Volume",
16016                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16017                                                               HDA_OUTPUT));
16018                         if (err < 0)
16019                                 return err;
16020                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16021                                           "Center Playback Switch",
16022                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16023                                                               HDA_INPUT));
16024                         if (err < 0)
16025                                 return err;
16026                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16027                                           "LFE Playback Switch",
16028                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16029                                                               HDA_INPUT));
16030                         if (err < 0)
16031                                 return err;
16032                 } else {
16033                         sprintf(name, "%s Playback Volume", chname[i]);
16034                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16035                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16036                                                               HDA_OUTPUT));
16037                         if (err < 0)
16038                                 return err;
16039                         sprintf(name, "%s Playback Switch", chname[i]);
16040                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16041                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16042                                                     3, 0, HDA_INPUT));
16043                         if (err < 0)
16044                                 return err;
16045                 }
16046         }
16047         return 0;
16048 }
16049
16050 /* add playback controls for speaker and HP outputs */
16051 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16052                                         const char *pfx)
16053 {
16054         hda_nid_t nid;
16055         int err;
16056         char name[32];
16057
16058         if (!pin)
16059                 return 0;
16060
16061         if (pin == 0x17) {
16062                 /* ALC663 has a mono output pin on 0x17 */
16063                 sprintf(name, "%s Playback Switch", pfx);
16064                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16065                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16066                 return err;
16067         }
16068
16069         if (alc880_is_fixed_pin(pin)) {
16070                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16071                 /* printk("DAC nid=%x\n",nid); */
16072                 /* specify the DAC as the extra output */
16073                 if (!spec->multiout.hp_nid)
16074                         spec->multiout.hp_nid = nid;
16075                 else
16076                         spec->multiout.extra_out_nid[0] = nid;
16077                 /* control HP volume/switch on the output mixer amp */
16078                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16079                 sprintf(name, "%s Playback Volume", pfx);
16080                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16081                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16082                 if (err < 0)
16083                         return err;
16084                 sprintf(name, "%s Playback Switch", pfx);
16085                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16086                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16087                 if (err < 0)
16088                         return err;
16089         } else if (alc880_is_multi_pin(pin)) {
16090                 /* set manual connection */
16091                 /* we have only a switch on HP-out PIN */
16092                 sprintf(name, "%s Playback Switch", pfx);
16093                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16094                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16095                 if (err < 0)
16096                         return err;
16097         }
16098         return 0;
16099 }
16100
16101 /* create playback/capture controls for input pins */
16102 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16103                                                 const struct auto_pin_cfg *cfg)
16104 {
16105         struct hda_input_mux *imux = &spec->private_imux;
16106         int i, err, idx;
16107
16108         for (i = 0; i < AUTO_PIN_LAST; i++) {
16109                 if (alc880_is_input_pin(cfg->input_pins[i])) {
16110                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
16111                         err = new_analog_input(spec, cfg->input_pins[i],
16112                                                auto_pin_cfg_labels[i],
16113                                                idx, 0x0b);
16114                         if (err < 0)
16115                                 return err;
16116                         imux->items[imux->num_items].label =
16117                                 auto_pin_cfg_labels[i];
16118                         imux->items[imux->num_items].index =
16119                                 alc880_input_pin_idx(cfg->input_pins[i]);
16120                         imux->num_items++;
16121                 }
16122         }
16123         return 0;
16124 }
16125
16126 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16127                                               hda_nid_t nid, int pin_type,
16128                                               int dac_idx)
16129 {
16130         alc_set_pin_output(codec, nid, pin_type);
16131         /* need the manual connection? */
16132         if (alc880_is_multi_pin(nid)) {
16133                 struct alc_spec *spec = codec->spec;
16134                 int idx = alc880_multi_pin_idx(nid);
16135                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16136                                     AC_VERB_SET_CONNECT_SEL,
16137                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16138         }
16139 }
16140
16141 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16142 {
16143         struct alc_spec *spec = codec->spec;
16144         int i;
16145
16146         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16147         for (i = 0; i <= HDA_SIDE; i++) {
16148                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16149                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16150                 if (nid)
16151                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16152                                                           i);
16153         }
16154 }
16155
16156 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16157 {
16158         struct alc_spec *spec = codec->spec;
16159         hda_nid_t pin;
16160
16161         pin = spec->autocfg.hp_pins[0];
16162         if (pin) /* connect to front */
16163                 /* use dac 0 */
16164                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16165         pin = spec->autocfg.speaker_pins[0];
16166         if (pin)
16167                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16168 }
16169
16170 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
16171 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16172
16173 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16174 {
16175         struct alc_spec *spec = codec->spec;
16176         int i;
16177
16178         for (i = 0; i < AUTO_PIN_LAST; i++) {
16179                 hda_nid_t nid = spec->autocfg.input_pins[i];
16180                 if (alc662_is_input_pin(nid)) {
16181                         snd_hda_codec_write(codec, nid, 0,
16182                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
16183                                             (i <= AUTO_PIN_FRONT_MIC ?
16184                                              PIN_VREF80 : PIN_IN));
16185                         if (nid != ALC662_PIN_CD_NID)
16186                                 snd_hda_codec_write(codec, nid, 0,
16187                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16188                                                     AMP_OUT_MUTE);
16189                 }
16190         }
16191 }
16192
16193 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16194
16195 static int alc662_parse_auto_config(struct hda_codec *codec)
16196 {
16197         struct alc_spec *spec = codec->spec;
16198         int err;
16199         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16200
16201         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16202                                            alc662_ignore);
16203         if (err < 0)
16204                 return err;
16205         if (!spec->autocfg.line_outs)
16206                 return 0; /* can't find valid BIOS pin config */
16207
16208         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16209         if (err < 0)
16210                 return err;
16211         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16212         if (err < 0)
16213                 return err;
16214         err = alc662_auto_create_extra_out(spec,
16215                                            spec->autocfg.speaker_pins[0],
16216                                            "Speaker");
16217         if (err < 0)
16218                 return err;
16219         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16220                                            "Headphone");
16221         if (err < 0)
16222                 return err;
16223         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16224         if (err < 0)
16225                 return err;
16226
16227         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16228
16229         if (spec->autocfg.dig_out_pin)
16230                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16231
16232         if (spec->kctl_alloc)
16233                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
16234
16235         spec->num_mux_defs = 1;
16236         spec->input_mux = &spec->private_imux;
16237
16238         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
16239         if (codec->vendor_id == 0x10ec0663)
16240                 spec->init_verbs[spec->num_init_verbs++] =
16241                         alc663_auto_init_verbs;
16242
16243         err = alc_auto_add_mic_boost(codec);
16244         if (err < 0)
16245                 return err;
16246
16247         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
16248         spec->num_mixers++;
16249         return 1;
16250 }
16251
16252 /* additional initialization for auto-configuration model */
16253 static void alc662_auto_init(struct hda_codec *codec)
16254 {
16255         struct alc_spec *spec = codec->spec;
16256         alc662_auto_init_multi_out(codec);
16257         alc662_auto_init_hp_out(codec);
16258         alc662_auto_init_analog_input(codec);
16259         alc662_auto_init_input_src(codec);
16260         if (spec->unsol_event)
16261                 alc_inithook(codec);
16262 }
16263
16264 static int patch_alc662(struct hda_codec *codec)
16265 {
16266         struct alc_spec *spec;
16267         int err, board_config;
16268
16269         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16270         if (!spec)
16271                 return -ENOMEM;
16272
16273         codec->spec = spec;
16274
16275         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16276
16277         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16278                                                   alc662_models,
16279                                                   alc662_cfg_tbl);
16280         if (board_config < 0) {
16281                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16282                        "trying auto-probe from BIOS...\n");
16283                 board_config = ALC662_AUTO;
16284         }
16285
16286         if (board_config == ALC662_AUTO) {
16287                 /* automatic parse from the BIOS config */
16288                 err = alc662_parse_auto_config(codec);
16289                 if (err < 0) {
16290                         alc_free(codec);
16291                         return err;
16292                 } else if (!err) {
16293                         printk(KERN_INFO
16294                                "hda_codec: Cannot set up configuration "
16295                                "from BIOS.  Using base mode...\n");
16296                         board_config = ALC662_3ST_2ch_DIG;
16297                 }
16298         }
16299
16300         if (board_config != ALC662_AUTO)
16301                 setup_preset(spec, &alc662_presets[board_config]);
16302
16303         if (codec->vendor_id == 0x10ec0663) {
16304                 spec->stream_name_analog = "ALC663 Analog";
16305                 spec->stream_name_digital = "ALC663 Digital";
16306         } else {
16307                 spec->stream_name_analog = "ALC662 Analog";
16308                 spec->stream_name_digital = "ALC662 Digital";
16309         }
16310
16311         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16312         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16313
16314         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16315         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16316
16317         spec->adc_nids = alc662_adc_nids;
16318         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16319         spec->capsrc_nids = alc662_capsrc_nids;
16320
16321         spec->vmaster_nid = 0x02;
16322
16323         codec->patch_ops = alc_patch_ops;
16324         if (board_config == ALC662_AUTO)
16325                 spec->init_hook = alc662_auto_init;
16326 #ifdef CONFIG_SND_HDA_POWER_SAVE
16327         if (!spec->loopback.amplist)
16328                 spec->loopback.amplist = alc662_loopbacks;
16329 #endif
16330
16331         return 0;
16332 }
16333
16334 /*
16335  * patch entries
16336  */
16337 struct hda_codec_preset snd_hda_preset_realtek[] = {
16338         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16339         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16340         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16341         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16342         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16343         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16344           .patch = patch_alc861 },
16345         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16346         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16347         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16348         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16349           .patch = patch_alc883 },
16350         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16351           .patch = patch_alc662 },
16352         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16353         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16354         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16355         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16356         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16357           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16358         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16359           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16360         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16361         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16362         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16363         {} /* terminator */
16364 };