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                 if (codec->revision_id == 0x100101) {
8841                         spec->stream_name_analog = "ALC1200 Analog";
8842                         spec->stream_name_digital = "ALC1200 Digital";
8843                 } else {
8844                         spec->stream_name_analog = "ALC888 Analog";
8845                         spec->stream_name_digital = "ALC888 Digital";
8846                 }
8847                 break;
8848         case 0x10ec0889:
8849                 spec->stream_name_analog = "ALC889 Analog";
8850                 spec->stream_name_digital = "ALC889 Digital";
8851                 break;
8852         default:
8853                 spec->stream_name_analog = "ALC883 Analog";
8854                 spec->stream_name_digital = "ALC883 Digital";
8855                 break;
8856         }
8857
8858         spec->stream_analog_playback = &alc883_pcm_analog_playback;
8859         spec->stream_analog_capture = &alc883_pcm_analog_capture;
8860         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8861
8862         spec->stream_digital_playback = &alc883_pcm_digital_playback;
8863         spec->stream_digital_capture = &alc883_pcm_digital_capture;
8864
8865         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8866         spec->adc_nids = alc883_adc_nids;
8867         spec->capsrc_nids = alc883_capsrc_nids;
8868
8869         spec->vmaster_nid = 0x0c;
8870
8871         codec->patch_ops = alc_patch_ops;
8872         if (board_config == ALC883_AUTO)
8873                 spec->init_hook = alc883_auto_init;
8874
8875 #ifdef CONFIG_SND_HDA_POWER_SAVE
8876         if (!spec->loopback.amplist)
8877                 spec->loopback.amplist = alc883_loopbacks;
8878 #endif
8879
8880         return 0;
8881 }
8882
8883 /*
8884  * ALC262 support
8885  */
8886
8887 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
8888 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
8889
8890 #define alc262_dac_nids         alc260_dac_nids
8891 #define alc262_adc_nids         alc882_adc_nids
8892 #define alc262_adc_nids_alt     alc882_adc_nids_alt
8893 #define alc262_capsrc_nids      alc882_capsrc_nids
8894 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
8895
8896 #define alc262_modes            alc260_modes
8897 #define alc262_capture_source   alc882_capture_source
8898
8899 static hda_nid_t alc262_dmic_adc_nids[1] = {
8900         /* ADC0 */
8901         0x09
8902 };
8903
8904 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
8905
8906 static struct snd_kcontrol_new alc262_base_mixer[] = {
8907         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8908         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8909         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8910         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8911         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8912         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8913         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8914         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8915         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8916         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8917         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8918         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8919         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8920            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8921         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
8922         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8923         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8924         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
8925         { } /* end */
8926 };
8927
8928 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
8929         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8930         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8931         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8932         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8933         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8934         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8935         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8936         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8937         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8938         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8939         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
8940         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8941         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
8942            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
8943         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
8944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8945         { } /* end */
8946 };
8947
8948 /* update HP, line and mono-out pins according to the master switch */
8949 static void alc262_hp_master_update(struct hda_codec *codec)
8950 {
8951         struct alc_spec *spec = codec->spec;
8952         int val = spec->master_sw;
8953
8954         /* HP & line-out */
8955         snd_hda_codec_write_cache(codec, 0x1b, 0,
8956                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8957                                   val ? PIN_HP : 0);
8958         snd_hda_codec_write_cache(codec, 0x15, 0,
8959                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8960                                   val ? PIN_HP : 0);
8961         /* mono (speaker) depending on the HP jack sense */
8962         val = val && !spec->jack_present;
8963         snd_hda_codec_write_cache(codec, 0x16, 0,
8964                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
8965                                   val ? PIN_OUT : 0);
8966 }
8967
8968 static void alc262_hp_bpc_automute(struct hda_codec *codec)
8969 {
8970         struct alc_spec *spec = codec->spec;
8971         unsigned int presence;
8972         presence = snd_hda_codec_read(codec, 0x1b, 0,
8973                                       AC_VERB_GET_PIN_SENSE, 0);
8974         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8975         alc262_hp_master_update(codec);
8976 }
8977
8978 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
8979 {
8980         if ((res >> 26) != ALC880_HP_EVENT)
8981                 return;
8982         alc262_hp_bpc_automute(codec);
8983 }
8984
8985 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
8986 {
8987         struct alc_spec *spec = codec->spec;
8988         unsigned int presence;
8989         presence = snd_hda_codec_read(codec, 0x15, 0,
8990                                       AC_VERB_GET_PIN_SENSE, 0);
8991         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
8992         alc262_hp_master_update(codec);
8993 }
8994
8995 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
8996                                            unsigned int res)
8997 {
8998         if ((res >> 26) != ALC880_HP_EVENT)
8999                 return;
9000         alc262_hp_wildwest_automute(codec);
9001 }
9002
9003 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9004                                    struct snd_ctl_elem_value *ucontrol)
9005 {
9006         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9007         struct alc_spec *spec = codec->spec;
9008         *ucontrol->value.integer.value = spec->master_sw;
9009         return 0;
9010 }
9011
9012 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9013                                    struct snd_ctl_elem_value *ucontrol)
9014 {
9015         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9016         struct alc_spec *spec = codec->spec;
9017         int val = !!*ucontrol->value.integer.value;
9018
9019         if (val == spec->master_sw)
9020                 return 0;
9021         spec->master_sw = val;
9022         alc262_hp_master_update(codec);
9023         return 1;
9024 }
9025
9026 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9027         {
9028                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9029                 .name = "Master Playback Switch",
9030                 .info = snd_ctl_boolean_mono_info,
9031                 .get = alc262_hp_master_sw_get,
9032                 .put = alc262_hp_master_sw_put,
9033         },
9034         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9035         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9036         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9037         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9038                               HDA_OUTPUT),
9039         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9040                             HDA_OUTPUT),
9041         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9042         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9043         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9044         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9045         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9046         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9047         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9048         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9049         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9050         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9051         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9052         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9053         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9054         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9055         { } /* end */
9056 };
9057
9058 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9059         {
9060                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9061                 .name = "Master Playback Switch",
9062                 .info = snd_ctl_boolean_mono_info,
9063                 .get = alc262_hp_master_sw_get,
9064                 .put = alc262_hp_master_sw_put,
9065         },
9066         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9067         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9068         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9069         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9070         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9071                               HDA_OUTPUT),
9072         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9073                             HDA_OUTPUT),
9074         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9075         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9076         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9077         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9078         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9079         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9080         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9081         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9082         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9083         { } /* end */
9084 };
9085
9086 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9087         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9088         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9089         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9090         { } /* end */
9091 };
9092
9093 /* mute/unmute internal speaker according to the hp jack and mute state */
9094 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9095 {
9096         struct alc_spec *spec = codec->spec;
9097
9098         if (force || !spec->sense_updated) {
9099                 unsigned int present;
9100                 present = snd_hda_codec_read(codec, 0x15, 0,
9101                                              AC_VERB_GET_PIN_SENSE, 0);
9102                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9103                 spec->sense_updated = 1;
9104         }
9105         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9106                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9107 }
9108
9109 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9110                                         unsigned int res)
9111 {
9112         if ((res >> 26) != ALC880_HP_EVENT)
9113                 return;
9114         alc262_hp_t5735_automute(codec, 1);
9115 }
9116
9117 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9118 {
9119         alc262_hp_t5735_automute(codec, 1);
9120 }
9121
9122 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9123         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9124         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9125         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9126         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9127         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9128         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9129         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9130         { } /* end */
9131 };
9132
9133 static struct hda_verb alc262_hp_t5735_verbs[] = {
9134         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9135         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9136
9137         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9138         { }
9139 };
9140
9141 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9142         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9143         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9144         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9145         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9146         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9147         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9148         { } /* end */
9149 };
9150
9151 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9152         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9153         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9154         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9155         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9156         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9157         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9158         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9159         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9160         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9161         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9162         {}
9163 };
9164
9165 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9166         .num_items = 1,
9167         .items = {
9168                 { "Line", 0x1 },
9169         },
9170 };
9171
9172 /* bind hp and internal speaker mute (with plug check) */
9173 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9174                                      struct snd_ctl_elem_value *ucontrol)
9175 {
9176         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9177         long *valp = ucontrol->value.integer.value;
9178         int change;
9179
9180         /* change hp mute */
9181         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9182                                           HDA_AMP_MUTE,
9183                                           valp[0] ? 0 : HDA_AMP_MUTE);
9184         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9185                                            HDA_AMP_MUTE,
9186                                            valp[1] ? 0 : HDA_AMP_MUTE);
9187         if (change) {
9188                 /* change speaker according to HP jack state */
9189                 struct alc_spec *spec = codec->spec;
9190                 unsigned int mute;
9191                 if (spec->jack_present)
9192                         mute = HDA_AMP_MUTE;
9193                 else
9194                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9195                                                       HDA_OUTPUT, 0);
9196                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9197                                          HDA_AMP_MUTE, mute);
9198         }
9199         return change;
9200 }
9201
9202 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9203         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9204         {
9205                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9206                 .name = "Master Playback Switch",
9207                 .info = snd_hda_mixer_amp_switch_info,
9208                 .get = snd_hda_mixer_amp_switch_get,
9209                 .put = alc262_sony_master_sw_put,
9210                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9211         },
9212         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9213         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9214         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9215         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9216         { } /* end */
9217 };
9218
9219 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9220         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9221         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9222         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9223         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9224         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9225         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9226         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9227         { } /* end */
9228 };
9229
9230 #define alc262_capture_mixer            alc882_capture_mixer
9231 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9232
9233 /*
9234  * generic initialization of ADC, input mixers and output mixers
9235  */
9236 static struct hda_verb alc262_init_verbs[] = {
9237         /*
9238          * Unmute ADC0-2 and set the default input to mic-in
9239          */
9240         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9241         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9242         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9243         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9244         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9245         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9246
9247         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9248          * mixer widget
9249          * Note: PASD motherboards uses the Line In 2 as the input for
9250          * front panel mic (mic 2)
9251          */
9252         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9253         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9254         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9255         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9256         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9257         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9258
9259         /*
9260          * Set up output mixers (0x0c - 0x0e)
9261          */
9262         /* set vol=0 to output mixers */
9263         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9264         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9265         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9266         /* set up input amps for analog loopback */
9267         /* Amp Indices: DAC = 0, mixer = 1 */
9268         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9269         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9270         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9271         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9272         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9273         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9274
9275         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9276         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9277         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9278         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9279         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9280         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9281
9282         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9283         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9284         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9285         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9286         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9287
9288         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9289         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9290
9291         /* FIXME: use matrix-type input source selection */
9292         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9293         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9294         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9295         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9296         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9297         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9298         /* Input mixer2 */
9299         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9300         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9301         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9302         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9303         /* Input mixer3 */
9304         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9305         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9306         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9307         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9308
9309         { }
9310 };
9311
9312 static struct hda_verb alc262_eapd_verbs[] = {
9313         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9314         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9315         { }
9316 };
9317
9318 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9319         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9320         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9321         {}
9322 };
9323
9324 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9325         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9326         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9327         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9328
9329         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9330         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9331         {}
9332 };
9333
9334 static struct hda_verb alc262_sony_unsol_verbs[] = {
9335         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9336         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9337         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9338
9339         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9340         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9341         {}
9342 };
9343
9344 static struct hda_input_mux alc262_dmic_capture_source = {
9345         .num_items = 2,
9346         .items = {
9347                 { "Int DMic", 0x9 },
9348                 { "Mic", 0x0 },
9349         },
9350 };
9351
9352 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9353         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9354         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9355         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9356         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9357         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9358         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9359         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9360         {
9361                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9362                 /* The multiple "Capture Source" controls confuse alsamixer
9363                  * So call somewhat different..
9364                  */
9365                 /* .name = "Capture Source", */
9366                 .name = "Input Source",
9367                 .count = 1,
9368                 .info = alc_mux_enum_info,
9369                 .get = alc_mux_enum_get,
9370                 .put = alc_mux_enum_put,
9371         },
9372         { } /* end */
9373 };
9374
9375 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9376         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9377         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9378         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9379         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9380         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9381         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9382         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9383         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9384         {}
9385 };
9386
9387 static void alc262_dmic_automute(struct hda_codec *codec)
9388 {
9389         unsigned int present;
9390
9391         present = snd_hda_codec_read(codec, 0x18, 0,
9392                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9393         snd_hda_codec_write(codec, 0x22, 0,
9394                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9395 }
9396
9397 /* toggle speaker-output according to the hp-jack state */
9398 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9399 {
9400         unsigned int present;
9401         unsigned char bits;
9402
9403         present = snd_hda_codec_read(codec, 0x15, 0,
9404                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9405         bits = present ? 0 : PIN_OUT;
9406         snd_hda_codec_write(codec, 0x14, 0,
9407                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9408 }
9409
9410
9411
9412 /* unsolicited event for HP jack sensing */
9413 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9414                                        unsigned int res)
9415 {
9416         if ((res >> 26) == ALC880_HP_EVENT)
9417                 alc262_toshiba_s06_speaker_automute(codec);
9418         if ((res >> 26) == ALC880_MIC_EVENT)
9419                 alc262_dmic_automute(codec);
9420
9421 }
9422
9423 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9424 {
9425         alc262_toshiba_s06_speaker_automute(codec);
9426         alc262_dmic_automute(codec);
9427 }
9428
9429 /* mute/unmute internal speaker according to the hp jack and mute state */
9430 static void alc262_hippo_automute(struct hda_codec *codec)
9431 {
9432         struct alc_spec *spec = codec->spec;
9433         unsigned int mute;
9434         unsigned int present;
9435
9436         /* need to execute and sync at first */
9437         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9438         present = snd_hda_codec_read(codec, 0x15, 0,
9439                                      AC_VERB_GET_PIN_SENSE, 0);
9440         spec->jack_present = (present & 0x80000000) != 0;
9441         if (spec->jack_present) {
9442                 /* mute internal speaker */
9443                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9444                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9445         } else {
9446                 /* unmute internal speaker if necessary */
9447                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9448                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9449                                          HDA_AMP_MUTE, mute);
9450         }
9451 }
9452
9453 /* unsolicited event for HP jack sensing */
9454 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9455                                        unsigned int res)
9456 {
9457         if ((res >> 26) != ALC880_HP_EVENT)
9458                 return;
9459         alc262_hippo_automute(codec);
9460 }
9461
9462 static void alc262_hippo1_automute(struct hda_codec *codec)
9463 {
9464         unsigned int mute;
9465         unsigned int present;
9466
9467         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9468         present = snd_hda_codec_read(codec, 0x1b, 0,
9469                                      AC_VERB_GET_PIN_SENSE, 0);
9470         present = (present & 0x80000000) != 0;
9471         if (present) {
9472                 /* mute internal speaker */
9473                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9474                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9475         } else {
9476                 /* unmute internal speaker if necessary */
9477                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9478                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9479                                          HDA_AMP_MUTE, mute);
9480         }
9481 }
9482
9483 /* unsolicited event for HP jack sensing */
9484 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9485                                        unsigned int res)
9486 {
9487         if ((res >> 26) != ALC880_HP_EVENT)
9488                 return;
9489         alc262_hippo1_automute(codec);
9490 }
9491
9492 /*
9493  * nec model
9494  *  0x15 = headphone
9495  *  0x16 = internal speaker
9496  *  0x18 = external mic
9497  */
9498
9499 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9500         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9501         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9502
9503         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9504         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9505         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9506
9507         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9508         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9509         { } /* end */
9510 };
9511
9512 static struct hda_verb alc262_nec_verbs[] = {
9513         /* Unmute Speaker */
9514         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9515
9516         /* Headphone */
9517         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9518         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9519
9520         /* External mic to headphone */
9521         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9522         /* External mic to speaker */
9523         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9524         {}
9525 };
9526
9527 /*
9528  * fujitsu model
9529  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
9530  *  0x1b = port replicator headphone out
9531  */
9532
9533 #define ALC_HP_EVENT    0x37
9534
9535 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9536         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9537         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9538         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9539         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9540         {}
9541 };
9542
9543 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9544         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9545         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9546         {}
9547 };
9548
9549 static struct hda_input_mux alc262_fujitsu_capture_source = {
9550         .num_items = 3,
9551         .items = {
9552                 { "Mic", 0x0 },
9553                 { "Int Mic", 0x1 },
9554                 { "CD", 0x4 },
9555         },
9556 };
9557
9558 static struct hda_input_mux alc262_HP_capture_source = {
9559         .num_items = 5,
9560         .items = {
9561                 { "Mic", 0x0 },
9562                 { "Front Mic", 0x1 },
9563                 { "Line", 0x2 },
9564                 { "CD", 0x4 },
9565                 { "AUX IN", 0x6 },
9566         },
9567 };
9568
9569 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9570         .num_items = 4,
9571         .items = {
9572                 { "Mic", 0x0 },
9573                 { "Front Mic", 0x2 },
9574                 { "Line", 0x1 },
9575                 { "CD", 0x4 },
9576         },
9577 };
9578
9579 /* mute/unmute internal speaker according to the hp jacks and mute state */
9580 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9581 {
9582         struct alc_spec *spec = codec->spec;
9583         unsigned int mute;
9584
9585         if (force || !spec->sense_updated) {
9586                 unsigned int present;
9587                 /* need to execute and sync at first */
9588                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9589                 /* check laptop HP jack */
9590                 present = snd_hda_codec_read(codec, 0x14, 0,
9591                                              AC_VERB_GET_PIN_SENSE, 0);
9592                 /* need to execute and sync at first */
9593                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9594                 /* check docking HP jack */
9595                 present |= snd_hda_codec_read(codec, 0x1b, 0,
9596                                               AC_VERB_GET_PIN_SENSE, 0);
9597                 if (present & AC_PINSENSE_PRESENCE)
9598                         spec->jack_present = 1;
9599                 else
9600                         spec->jack_present = 0;
9601                 spec->sense_updated = 1;
9602         }
9603         /* unmute internal speaker only if both HPs are unplugged and
9604          * master switch is on
9605          */
9606         if (spec->jack_present)
9607                 mute = HDA_AMP_MUTE;
9608         else
9609                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9610         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9611                                  HDA_AMP_MUTE, mute);
9612 }
9613
9614 /* unsolicited event for HP jack sensing */
9615 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9616                                        unsigned int res)
9617 {
9618         if ((res >> 26) != ALC_HP_EVENT)
9619                 return;
9620         alc262_fujitsu_automute(codec, 1);
9621 }
9622
9623 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9624 {
9625         alc262_fujitsu_automute(codec, 1);
9626 }
9627
9628 /* bind volumes of both NID 0x0c and 0x0d */
9629 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9630         .ops = &snd_hda_bind_vol,
9631         .values = {
9632                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9633                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9634                 0
9635         },
9636 };
9637
9638 /* mute/unmute internal speaker according to the hp jack and mute state */
9639 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9640 {
9641         struct alc_spec *spec = codec->spec;
9642         unsigned int mute;
9643
9644         if (force || !spec->sense_updated) {
9645                 unsigned int present_int_hp;
9646                 /* need to execute and sync at first */
9647                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9648                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9649                                         AC_VERB_GET_PIN_SENSE, 0);
9650                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9651                 spec->sense_updated = 1;
9652         }
9653         if (spec->jack_present) {
9654                 /* mute internal speaker */
9655                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9656                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9657                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9658                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9659         } else {
9660                 /* unmute internal speaker if necessary */
9661                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9662                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9663                                          HDA_AMP_MUTE, mute);
9664                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9665                                          HDA_AMP_MUTE, mute);
9666         }
9667 }
9668
9669 /* unsolicited event for HP jack sensing */
9670 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9671                                        unsigned int res)
9672 {
9673         if ((res >> 26) != ALC_HP_EVENT)
9674                 return;
9675         alc262_lenovo_3000_automute(codec, 1);
9676 }
9677
9678 /* bind hp and internal speaker mute (with plug check) */
9679 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9680                                          struct snd_ctl_elem_value *ucontrol)
9681 {
9682         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9683         long *valp = ucontrol->value.integer.value;
9684         int change;
9685
9686         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9687                                                  HDA_AMP_MUTE,
9688                                                  valp ? 0 : HDA_AMP_MUTE);
9689         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9690                                                  HDA_AMP_MUTE,
9691                                                  valp ? 0 : HDA_AMP_MUTE);
9692
9693         if (change)
9694                 alc262_fujitsu_automute(codec, 0);
9695         return change;
9696 }
9697
9698 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9699         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9700         {
9701                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9702                 .name = "Master Playback Switch",
9703                 .info = snd_hda_mixer_amp_switch_info,
9704                 .get = snd_hda_mixer_amp_switch_get,
9705                 .put = alc262_fujitsu_master_sw_put,
9706                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9707         },
9708         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9709         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9710         HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9711         HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9712         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9713         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9714         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9715         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9716         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9717         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9718         { } /* end */
9719 };
9720
9721 /* bind hp and internal speaker mute (with plug check) */
9722 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9723                                          struct snd_ctl_elem_value *ucontrol)
9724 {
9725         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9726         long *valp = ucontrol->value.integer.value;
9727         int change;
9728
9729         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9730                                                  HDA_AMP_MUTE,
9731                                                  valp ? 0 : HDA_AMP_MUTE);
9732
9733         if (change)
9734                 alc262_lenovo_3000_automute(codec, 0);
9735         return change;
9736 }
9737
9738 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9739         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9740         {
9741                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9742                 .name = "Master Playback Switch",
9743                 .info = snd_hda_mixer_amp_switch_info,
9744                 .get = snd_hda_mixer_amp_switch_get,
9745                 .put = alc262_lenovo_3000_master_sw_put,
9746                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9747         },
9748         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9749         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9750         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9751         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9752         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9753         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9754         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9755         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9756         { } /* end */
9757 };
9758
9759 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
9760         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9761         {
9762                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9763                 .name = "Master Playback Switch",
9764                 .info = snd_hda_mixer_amp_switch_info,
9765                 .get = snd_hda_mixer_amp_switch_get,
9766                 .put = alc262_sony_master_sw_put,
9767                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9768         },
9769         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9770         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9771         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9772         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9773         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9774         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9775         { } /* end */
9776 };
9777
9778 /* additional init verbs for Benq laptops */
9779 static struct hda_verb alc262_EAPD_verbs[] = {
9780         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9781         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
9782         {}
9783 };
9784
9785 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9786         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9787         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9788
9789         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9790         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
9791         {}
9792 };
9793
9794 /* Samsung Q1 Ultra Vista model setup */
9795 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9796         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9797         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9798         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9799         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9800         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9801         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9802         { } /* end */
9803 };
9804
9805 static struct hda_verb alc262_ultra_verbs[] = {
9806         /* output mixer */
9807         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9808         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9809         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9810         /* speaker */
9811         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9812         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9813         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9814         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9815         /* HP */
9816         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9817         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9818         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9819         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9820         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9821         /* internal mic */
9822         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9823         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9824         /* ADC, choose mic */
9825         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9826         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9827         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9828         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9829         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9830         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9831         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9832         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9833         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9834         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9835         {}
9836 };
9837
9838 /* mute/unmute internal speaker according to the hp jack and mute state */
9839 static void alc262_ultra_automute(struct hda_codec *codec)
9840 {
9841         struct alc_spec *spec = codec->spec;
9842         unsigned int mute;
9843
9844         mute = 0;
9845         /* auto-mute only when HP is used as HP */
9846         if (!spec->cur_mux[0]) {
9847                 unsigned int present;
9848                 /* need to execute and sync at first */
9849                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9850                 present = snd_hda_codec_read(codec, 0x15, 0,
9851                                              AC_VERB_GET_PIN_SENSE, 0);
9852                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9853                 if (spec->jack_present)
9854                         mute = HDA_AMP_MUTE;
9855         }
9856         /* mute/unmute internal speaker */
9857         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9858                                  HDA_AMP_MUTE, mute);
9859         /* mute/unmute HP */
9860         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9861                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9862 }
9863
9864 /* unsolicited event for HP jack sensing */
9865 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9866                                        unsigned int res)
9867 {
9868         if ((res >> 26) != ALC880_HP_EVENT)
9869                 return;
9870         alc262_ultra_automute(codec);
9871 }
9872
9873 static struct hda_input_mux alc262_ultra_capture_source = {
9874         .num_items = 2,
9875         .items = {
9876                 { "Mic", 0x1 },
9877                 { "Headphone", 0x7 },
9878         },
9879 };
9880
9881 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9882                                      struct snd_ctl_elem_value *ucontrol)
9883 {
9884         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9885         struct alc_spec *spec = codec->spec;
9886         int ret;
9887
9888         ret = alc882_mux_enum_put(kcontrol, ucontrol);
9889         if (!ret)
9890                 return 0;
9891         /* reprogram the HP pin as mic or HP according to the input source */
9892         snd_hda_codec_write_cache(codec, 0x15, 0,
9893                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9894                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9895         alc262_ultra_automute(codec); /* mute/unmute HP */
9896         return ret;
9897 }
9898
9899 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9900         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9901         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9902         {
9903                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9904                 .name = "Capture Source",
9905                 .info = alc882_mux_enum_info,
9906                 .get = alc882_mux_enum_get,
9907                 .put = alc262_ultra_mux_enum_put,
9908         },
9909         { } /* end */
9910 };
9911
9912 /* add playback controls from the parsed DAC table */
9913 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9914                                              const struct auto_pin_cfg *cfg)
9915 {
9916         hda_nid_t nid;
9917         int err;
9918
9919         spec->multiout.num_dacs = 1;    /* only use one dac */
9920         spec->multiout.dac_nids = spec->private_dac_nids;
9921         spec->multiout.dac_nids[0] = 2;
9922
9923         nid = cfg->line_out_pins[0];
9924         if (nid) {
9925                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9926                                   "Front Playback Volume",
9927                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
9928                 if (err < 0)
9929                         return err;
9930                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9931                                   "Front Playback Switch",
9932                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
9933                 if (err < 0)
9934                         return err;
9935         }
9936
9937         nid = cfg->speaker_pins[0];
9938         if (nid) {
9939                 if (nid == 0x16) {
9940                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9941                                           "Speaker Playback Volume",
9942                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9943                                                               HDA_OUTPUT));
9944                         if (err < 0)
9945                                 return err;
9946                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9947                                           "Speaker Playback Switch",
9948                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9949                                                               HDA_OUTPUT));
9950                         if (err < 0)
9951                                 return err;
9952                 } else {
9953                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9954                                           "Speaker Playback Switch",
9955                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9956                                                               HDA_OUTPUT));
9957                         if (err < 0)
9958                                 return err;
9959                 }
9960         }
9961         nid = cfg->hp_pins[0];
9962         if (nid) {
9963                 /* spec->multiout.hp_nid = 2; */
9964                 if (nid == 0x16) {
9965                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
9966                                           "Headphone Playback Volume",
9967                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
9968                                                               HDA_OUTPUT));
9969                         if (err < 0)
9970                                 return err;
9971                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9972                                           "Headphone Playback Switch",
9973                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
9974                                                               HDA_OUTPUT));
9975                         if (err < 0)
9976                                 return err;
9977                 } else {
9978                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
9979                                           "Headphone Playback Switch",
9980                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
9981                                                               HDA_OUTPUT));
9982                         if (err < 0)
9983                                 return err;
9984                 }
9985         }
9986         return 0;
9987 }
9988
9989 /* identical with ALC880 */
9990 #define alc262_auto_create_analog_input_ctls \
9991         alc880_auto_create_analog_input_ctls
9992
9993 /*
9994  * generic initialization of ADC, input mixers and output mixers
9995  */
9996 static struct hda_verb alc262_volume_init_verbs[] = {
9997         /*
9998          * Unmute ADC0-2 and set the default input to mic-in
9999          */
10000         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10001         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10002         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10003         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10004         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10005         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10006
10007         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10008          * mixer widget
10009          * Note: PASD motherboards uses the Line In 2 as the input for
10010          * front panel mic (mic 2)
10011          */
10012         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10013         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10014         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10015         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10016         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10017         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10018
10019         /*
10020          * Set up output mixers (0x0c - 0x0f)
10021          */
10022         /* set vol=0 to output mixers */
10023         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10024         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10025         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10026
10027         /* set up input amps for analog loopback */
10028         /* Amp Indices: DAC = 0, mixer = 1 */
10029         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10030         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10031         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10032         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10033         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10034         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10035
10036         /* FIXME: use matrix-type input source selection */
10037         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10038         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10039         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10040         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10041         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10042         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10043         /* Input mixer2 */
10044         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10045         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10046         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10047         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10048         /* Input mixer3 */
10049         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10050         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10051         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10052         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10053
10054         { }
10055 };
10056
10057 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10058         /*
10059          * Unmute ADC0-2 and set the default input to mic-in
10060          */
10061         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10062         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10063         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10064         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10065         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10066         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10067
10068         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10069          * mixer widget
10070          * Note: PASD motherboards uses the Line In 2 as the input for
10071          * front panel mic (mic 2)
10072          */
10073         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10074         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10075         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10076         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10077         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10078         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10079         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10080         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10081
10082         /*
10083          * Set up output mixers (0x0c - 0x0e)
10084          */
10085         /* set vol=0 to output mixers */
10086         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10087         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10088         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10089
10090         /* set up input amps for analog loopback */
10091         /* Amp Indices: DAC = 0, mixer = 1 */
10092         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10093         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10094         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10095         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10096         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10097         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10098
10099         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10100         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10101         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10102
10103         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10104         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10105
10106         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10107         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10108
10109         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10110         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10111         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10112         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10113         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10114
10115         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10116         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10117         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10118         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10119         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10120         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10121
10122
10123         /* FIXME: use matrix-type input source selection */
10124         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10125         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10126         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10127         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10128         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10129         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10130         /* Input mixer2 */
10131         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10132         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10133         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10134         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10135         /* Input mixer3 */
10136         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10137         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10138         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10139         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10140
10141         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10142
10143         { }
10144 };
10145
10146 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10147         /*
10148          * Unmute ADC0-2 and set the default input to mic-in
10149          */
10150         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10151         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10152         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10153         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10154         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10155         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10156
10157         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10158          * mixer widget
10159          * Note: PASD motherboards uses the Line In 2 as the input for front
10160          * panel mic (mic 2)
10161          */
10162         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10163         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10164         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10165         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10166         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10167         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10168         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10169         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10170         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10171         /*
10172          * Set up output mixers (0x0c - 0x0e)
10173          */
10174         /* set vol=0 to output mixers */
10175         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10176         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10177         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10178
10179         /* set up input amps for analog loopback */
10180         /* Amp Indices: DAC = 0, mixer = 1 */
10181         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10182         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10183         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10184         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10185         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10186         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10187
10188
10189         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10190         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10191         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10192         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10193         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10194         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10195         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10196
10197         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10198         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10199
10200         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10201         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10202
10203         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10204         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10205         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10206         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10207         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10208         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10209
10210         /* FIXME: use matrix-type input source selection */
10211         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10212         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10213         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10214         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10215         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10216         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10217         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10218         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10219         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10220         /* Input mixer2 */
10221         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10222         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10223         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10224         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10225         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10226         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10227         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10228         /* Input mixer3 */
10229         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10230         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10231         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10232         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10233         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10234         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10235         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10236
10237         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10238
10239         { }
10240 };
10241
10242 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10243
10244         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10245         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10246         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10247
10248         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10249         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10250         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10251         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10252
10253         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10254         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10255         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10256         {}
10257 };
10258
10259
10260 #ifdef CONFIG_SND_HDA_POWER_SAVE
10261 #define alc262_loopbacks        alc880_loopbacks
10262 #endif
10263
10264 /* pcm configuration: identiacal with ALC880 */
10265 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10266 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10267 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10268 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10269
10270 /*
10271  * BIOS auto configuration
10272  */
10273 static int alc262_parse_auto_config(struct hda_codec *codec)
10274 {
10275         struct alc_spec *spec = codec->spec;
10276         int err;
10277         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10278
10279         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10280                                            alc262_ignore);
10281         if (err < 0)
10282                 return err;
10283         if (!spec->autocfg.line_outs)
10284                 return 0; /* can't find valid BIOS pin config */
10285         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10286         if (err < 0)
10287                 return err;
10288         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10289         if (err < 0)
10290                 return err;
10291
10292         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10293
10294         if (spec->autocfg.dig_out_pin)
10295                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10296         if (spec->autocfg.dig_in_pin)
10297                 spec->dig_in_nid = ALC262_DIGIN_NID;
10298
10299         if (spec->kctl_alloc)
10300                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10301
10302         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
10303         spec->num_mux_defs = 1;
10304         spec->input_mux = &spec->private_imux;
10305
10306         err = alc_auto_add_mic_boost(codec);
10307         if (err < 0)
10308                 return err;
10309
10310         return 1;
10311 }
10312
10313 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10314 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10315 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10316 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10317
10318
10319 /* init callback for auto-configuration model -- overriding the default init */
10320 static void alc262_auto_init(struct hda_codec *codec)
10321 {
10322         struct alc_spec *spec = codec->spec;
10323         alc262_auto_init_multi_out(codec);
10324         alc262_auto_init_hp_out(codec);
10325         alc262_auto_init_analog_input(codec);
10326         alc262_auto_init_input_src(codec);
10327         if (spec->unsol_event)
10328                 alc_inithook(codec);
10329 }
10330
10331 /*
10332  * configuration and preset
10333  */
10334 static const char *alc262_models[ALC262_MODEL_LAST] = {
10335         [ALC262_BASIC]          = "basic",
10336         [ALC262_HIPPO]          = "hippo",
10337         [ALC262_HIPPO_1]        = "hippo_1",
10338         [ALC262_FUJITSU]        = "fujitsu",
10339         [ALC262_HP_BPC]         = "hp-bpc",
10340         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10341         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10342         [ALC262_HP_RP5700]      = "hp-rp5700",
10343         [ALC262_BENQ_ED8]       = "benq",
10344         [ALC262_BENQ_T31]       = "benq-t31",
10345         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10346         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10347         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10348         [ALC262_ULTRA]          = "ultra",
10349         [ALC262_LENOVO_3000]    = "lenovo-3000",
10350         [ALC262_NEC]            = "nec",
10351         [ALC262_AUTO]           = "auto",
10352 };
10353
10354 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10355         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10356         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10357         SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
10358         SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
10359         SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
10360         SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
10361         SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
10362         SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
10363         SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
10364         SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
10365         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10366         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10367         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10368         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10369         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10370         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10371         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10372         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10373         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10374         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10375         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10376         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10377                       ALC262_HP_TC_T5735),
10378         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10379         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10380         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10381         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10382         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10383         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10384         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10385                       ALC262_TOSHIBA_RX1),
10386         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10387         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10388         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10389         SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
10390         SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
10391         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10392         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10393         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10394         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10395         {}
10396 };
10397
10398 static struct alc_config_preset alc262_presets[] = {
10399         [ALC262_BASIC] = {
10400                 .mixers = { alc262_base_mixer },
10401                 .init_verbs = { alc262_init_verbs },
10402                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10403                 .dac_nids = alc262_dac_nids,
10404                 .hp_nid = 0x03,
10405                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10406                 .channel_mode = alc262_modes,
10407                 .input_mux = &alc262_capture_source,
10408         },
10409         [ALC262_HIPPO] = {
10410                 .mixers = { alc262_base_mixer },
10411                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10412                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10413                 .dac_nids = alc262_dac_nids,
10414                 .hp_nid = 0x03,
10415                 .dig_out_nid = ALC262_DIGOUT_NID,
10416                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10417                 .channel_mode = alc262_modes,
10418                 .input_mux = &alc262_capture_source,
10419                 .unsol_event = alc262_hippo_unsol_event,
10420                 .init_hook = alc262_hippo_automute,
10421         },
10422         [ALC262_HIPPO_1] = {
10423                 .mixers = { alc262_hippo1_mixer },
10424                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10425                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10426                 .dac_nids = alc262_dac_nids,
10427                 .hp_nid = 0x02,
10428                 .dig_out_nid = ALC262_DIGOUT_NID,
10429                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10430                 .channel_mode = alc262_modes,
10431                 .input_mux = &alc262_capture_source,
10432                 .unsol_event = alc262_hippo1_unsol_event,
10433                 .init_hook = alc262_hippo1_automute,
10434         },
10435         [ALC262_FUJITSU] = {
10436                 .mixers = { alc262_fujitsu_mixer },
10437                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10438                                 alc262_fujitsu_unsol_verbs },
10439                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10440                 .dac_nids = alc262_dac_nids,
10441                 .hp_nid = 0x03,
10442                 .dig_out_nid = ALC262_DIGOUT_NID,
10443                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10444                 .channel_mode = alc262_modes,
10445                 .input_mux = &alc262_fujitsu_capture_source,
10446                 .unsol_event = alc262_fujitsu_unsol_event,
10447                 .init_hook = alc262_fujitsu_init_hook,
10448         },
10449         [ALC262_HP_BPC] = {
10450                 .mixers = { alc262_HP_BPC_mixer },
10451                 .init_verbs = { alc262_HP_BPC_init_verbs },
10452                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10453                 .dac_nids = alc262_dac_nids,
10454                 .hp_nid = 0x03,
10455                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10456                 .channel_mode = alc262_modes,
10457                 .input_mux = &alc262_HP_capture_source,
10458                 .unsol_event = alc262_hp_bpc_unsol_event,
10459                 .init_hook = alc262_hp_bpc_automute,
10460         },
10461         [ALC262_HP_BPC_D7000_WF] = {
10462                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10463                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10464                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10465                 .dac_nids = alc262_dac_nids,
10466                 .hp_nid = 0x03,
10467                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10468                 .channel_mode = alc262_modes,
10469                 .input_mux = &alc262_HP_D7000_capture_source,
10470                 .unsol_event = alc262_hp_wildwest_unsol_event,
10471                 .init_hook = alc262_hp_wildwest_automute,
10472         },
10473         [ALC262_HP_BPC_D7000_WL] = {
10474                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10475                             alc262_HP_BPC_WildWest_option_mixer },
10476                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10477                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10478                 .dac_nids = alc262_dac_nids,
10479                 .hp_nid = 0x03,
10480                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10481                 .channel_mode = alc262_modes,
10482                 .input_mux = &alc262_HP_D7000_capture_source,
10483                 .unsol_event = alc262_hp_wildwest_unsol_event,
10484                 .init_hook = alc262_hp_wildwest_automute,
10485         },
10486         [ALC262_HP_TC_T5735] = {
10487                 .mixers = { alc262_hp_t5735_mixer },
10488                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10489                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10490                 .dac_nids = alc262_dac_nids,
10491                 .hp_nid = 0x03,
10492                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10493                 .channel_mode = alc262_modes,
10494                 .input_mux = &alc262_capture_source,
10495                 .unsol_event = alc262_hp_t5735_unsol_event,
10496                 .init_hook = alc262_hp_t5735_init_hook,
10497         },
10498         [ALC262_HP_RP5700] = {
10499                 .mixers = { alc262_hp_rp5700_mixer },
10500                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10501                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10502                 .dac_nids = alc262_dac_nids,
10503                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10504                 .channel_mode = alc262_modes,
10505                 .input_mux = &alc262_hp_rp5700_capture_source,
10506         },
10507         [ALC262_BENQ_ED8] = {
10508                 .mixers = { alc262_base_mixer },
10509                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10510                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10511                 .dac_nids = alc262_dac_nids,
10512                 .hp_nid = 0x03,
10513                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10514                 .channel_mode = alc262_modes,
10515                 .input_mux = &alc262_capture_source,
10516         },
10517         [ALC262_SONY_ASSAMD] = {
10518                 .mixers = { alc262_sony_mixer },
10519                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10520                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10521                 .dac_nids = alc262_dac_nids,
10522                 .hp_nid = 0x02,
10523                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10524                 .channel_mode = alc262_modes,
10525                 .input_mux = &alc262_capture_source,
10526                 .unsol_event = alc262_hippo_unsol_event,
10527                 .init_hook = alc262_hippo_automute,
10528         },
10529         [ALC262_BENQ_T31] = {
10530                 .mixers = { alc262_benq_t31_mixer },
10531                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10532                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10533                 .dac_nids = alc262_dac_nids,
10534                 .hp_nid = 0x03,
10535                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10536                 .channel_mode = alc262_modes,
10537                 .input_mux = &alc262_capture_source,
10538                 .unsol_event = alc262_hippo_unsol_event,
10539                 .init_hook = alc262_hippo_automute,
10540         },
10541         [ALC262_ULTRA] = {
10542                 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
10543                 .init_verbs = { alc262_ultra_verbs },
10544                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10545                 .dac_nids = alc262_dac_nids,
10546                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10547                 .channel_mode = alc262_modes,
10548                 .input_mux = &alc262_ultra_capture_source,
10549                 .adc_nids = alc262_adc_nids, /* ADC0 */
10550                 .capsrc_nids = alc262_capsrc_nids,
10551                 .num_adc_nids = 1, /* single ADC */
10552                 .unsol_event = alc262_ultra_unsol_event,
10553                 .init_hook = alc262_ultra_automute,
10554         },
10555         [ALC262_LENOVO_3000] = {
10556                 .mixers = { alc262_lenovo_3000_mixer },
10557                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10558                                 alc262_lenovo_3000_unsol_verbs },
10559                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10560                 .dac_nids = alc262_dac_nids,
10561                 .hp_nid = 0x03,
10562                 .dig_out_nid = ALC262_DIGOUT_NID,
10563                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10564                 .channel_mode = alc262_modes,
10565                 .input_mux = &alc262_fujitsu_capture_source,
10566                 .unsol_event = alc262_lenovo_3000_unsol_event,
10567         },
10568         [ALC262_NEC] = {
10569                 .mixers = { alc262_nec_mixer },
10570                 .init_verbs = { alc262_nec_verbs },
10571                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10572                 .dac_nids = alc262_dac_nids,
10573                 .hp_nid = 0x03,
10574                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10575                 .channel_mode = alc262_modes,
10576                 .input_mux = &alc262_capture_source,
10577         },
10578         [ALC262_TOSHIBA_S06] = {
10579                 .mixers = { alc262_toshiba_s06_mixer },
10580                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10581                                                         alc262_eapd_verbs },
10582                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10583                 .capsrc_nids = alc262_dmic_capsrc_nids,
10584                 .dac_nids = alc262_dac_nids,
10585                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10586                 .dig_out_nid = ALC262_DIGOUT_NID,
10587                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10588                 .channel_mode = alc262_modes,
10589                 .input_mux = &alc262_dmic_capture_source,
10590                 .unsol_event = alc262_toshiba_s06_unsol_event,
10591                 .init_hook = alc262_toshiba_s06_init_hook,
10592         },
10593         [ALC262_TOSHIBA_RX1] = {
10594                 .mixers = { alc262_toshiba_rx1_mixer },
10595                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10596                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10597                 .dac_nids = alc262_dac_nids,
10598                 .hp_nid = 0x03,
10599                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10600                 .channel_mode = alc262_modes,
10601                 .input_mux = &alc262_capture_source,
10602                 .unsol_event = alc262_hippo_unsol_event,
10603                 .init_hook = alc262_hippo_automute,
10604         },
10605 };
10606
10607 static int patch_alc262(struct hda_codec *codec)
10608 {
10609         struct alc_spec *spec;
10610         int board_config;
10611         int err;
10612
10613         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10614         if (spec == NULL)
10615                 return -ENOMEM;
10616
10617         codec->spec = spec;
10618 #if 0
10619         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
10620          * under-run
10621          */
10622         {
10623         int tmp;
10624         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10625         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
10626         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10627         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
10628         }
10629 #endif
10630
10631         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10632
10633         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
10634                                                   alc262_models,
10635                                                   alc262_cfg_tbl);
10636
10637         if (board_config < 0) {
10638                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
10639                        "trying auto-probe from BIOS...\n");
10640                 board_config = ALC262_AUTO;
10641         }
10642
10643         if (board_config == ALC262_AUTO) {
10644                 /* automatic parse from the BIOS config */
10645                 err = alc262_parse_auto_config(codec);
10646                 if (err < 0) {
10647                         alc_free(codec);
10648                         return err;
10649                 } else if (!err) {
10650                         printk(KERN_INFO
10651                                "hda_codec: Cannot set up configuration "
10652                                "from BIOS.  Using base mode...\n");
10653                         board_config = ALC262_BASIC;
10654                 }
10655         }
10656
10657         if (board_config != ALC262_AUTO)
10658                 setup_preset(spec, &alc262_presets[board_config]);
10659
10660         spec->stream_name_analog = "ALC262 Analog";
10661         spec->stream_analog_playback = &alc262_pcm_analog_playback;
10662         spec->stream_analog_capture = &alc262_pcm_analog_capture;
10663
10664         spec->stream_name_digital = "ALC262 Digital";
10665         spec->stream_digital_playback = &alc262_pcm_digital_playback;
10666         spec->stream_digital_capture = &alc262_pcm_digital_capture;
10667
10668         if (!spec->adc_nids && spec->input_mux) {
10669                 /* check whether NID 0x07 is valid */
10670                 unsigned int wcap = get_wcaps(codec, 0x07);
10671
10672                 /* get type */
10673                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10674                 if (wcap != AC_WID_AUD_IN) {
10675                         spec->adc_nids = alc262_adc_nids_alt;
10676                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
10677                         spec->capsrc_nids = alc262_capsrc_nids_alt;
10678                         spec->mixers[spec->num_mixers] =
10679                                 alc262_capture_alt_mixer;
10680                         spec->num_mixers++;
10681                 } else {
10682                         spec->adc_nids = alc262_adc_nids;
10683                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
10684                         spec->capsrc_nids = alc262_capsrc_nids;
10685                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
10686                         spec->num_mixers++;
10687                 }
10688         }
10689
10690         spec->vmaster_nid = 0x0c;
10691
10692         codec->patch_ops = alc_patch_ops;
10693         if (board_config == ALC262_AUTO)
10694                 spec->init_hook = alc262_auto_init;
10695 #ifdef CONFIG_SND_HDA_POWER_SAVE
10696         if (!spec->loopback.amplist)
10697                 spec->loopback.amplist = alc262_loopbacks;
10698 #endif
10699
10700         return 0;
10701 }
10702
10703 /*
10704  *  ALC268 channel source setting (2 channel)
10705  */
10706 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
10707 #define alc268_modes            alc260_modes
10708
10709 static hda_nid_t alc268_dac_nids[2] = {
10710         /* front, hp */
10711         0x02, 0x03
10712 };
10713
10714 static hda_nid_t alc268_adc_nids[2] = {
10715         /* ADC0-1 */
10716         0x08, 0x07
10717 };
10718
10719 static hda_nid_t alc268_adc_nids_alt[1] = {
10720         /* ADC0 */
10721         0x08
10722 };
10723
10724 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10725
10726 static struct snd_kcontrol_new alc268_base_mixer[] = {
10727         /* output mixer control */
10728         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10729         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10730         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10731         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10732         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10733         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10734         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10735         { }
10736 };
10737
10738 /* bind Beep switches of both NID 0x0f and 0x10 */
10739 static struct hda_bind_ctls alc268_bind_beep_sw = {
10740         .ops = &snd_hda_bind_sw,
10741         .values = {
10742                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10743                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10744                 0
10745         },
10746 };
10747
10748 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10749         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10750         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10751         { }
10752 };
10753
10754 static struct hda_verb alc268_eapd_verbs[] = {
10755         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10756         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10757         { }
10758 };
10759
10760 /* Toshiba specific */
10761 #define alc268_toshiba_automute alc262_hippo_automute
10762
10763 static struct hda_verb alc268_toshiba_verbs[] = {
10764         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10765         { } /* end */
10766 };
10767
10768 static struct hda_input_mux alc268_acer_lc_capture_source = {
10769         .num_items = 2,
10770         .items = {
10771                 { "i-Mic", 0x6 },
10772                 { "E-Mic", 0x0 },
10773         },
10774 };
10775
10776 /* Acer specific */
10777 /* bind volumes of both NID 0x02 and 0x03 */
10778 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10779         .ops = &snd_hda_bind_vol,
10780         .values = {
10781                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10782                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10783                 0
10784         },
10785 };
10786
10787 /* mute/unmute internal speaker according to the hp jack and mute state */
10788 static void alc268_acer_automute(struct hda_codec *codec, int force)
10789 {
10790         struct alc_spec *spec = codec->spec;
10791         unsigned int mute;
10792
10793         if (force || !spec->sense_updated) {
10794                 unsigned int present;
10795                 present = snd_hda_codec_read(codec, 0x14, 0,
10796                                          AC_VERB_GET_PIN_SENSE, 0);
10797                 spec->jack_present = (present & 0x80000000) != 0;
10798                 spec->sense_updated = 1;
10799         }
10800         if (spec->jack_present)
10801                 mute = HDA_AMP_MUTE; /* mute internal speaker */
10802         else /* unmute internal speaker if necessary */
10803                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10804         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10805                                  HDA_AMP_MUTE, mute);
10806 }
10807
10808
10809 /* bind hp and internal speaker mute (with plug check) */
10810 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10811                                      struct snd_ctl_elem_value *ucontrol)
10812 {
10813         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10814         long *valp = ucontrol->value.integer.value;
10815         int change;
10816
10817         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10818                                           HDA_AMP_MUTE,
10819                                           valp[0] ? 0 : HDA_AMP_MUTE);
10820         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10821                                            HDA_AMP_MUTE,
10822                                            valp[1] ? 0 : HDA_AMP_MUTE);
10823         if (change)
10824                 alc268_acer_automute(codec, 0);
10825         return change;
10826 }
10827
10828 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
10829         /* output mixer control */
10830         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10831         {
10832                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10833                 .name = "Master Playback Switch",
10834                 .info = snd_hda_mixer_amp_switch_info,
10835                 .get = snd_hda_mixer_amp_switch_get,
10836                 .put = alc268_acer_master_sw_put,
10837                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10838         },
10839         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
10840         { }
10841 };
10842
10843 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10844         /* output mixer control */
10845         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10846         {
10847                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10848                 .name = "Master Playback Switch",
10849                 .info = snd_hda_mixer_amp_switch_info,
10850                 .get = snd_hda_mixer_amp_switch_get,
10851                 .put = alc268_acer_master_sw_put,
10852                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10853         },
10854         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10855         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10856         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10857         { }
10858 };
10859
10860 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
10861         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10862         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10863         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10864         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10865         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
10866         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
10867         { }
10868 };
10869
10870 static struct hda_verb alc268_acer_verbs[] = {
10871         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10872         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10873         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10874         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10875         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10876         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10877         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10878         { }
10879 };
10880
10881 /* unsolicited event for HP jack sensing */
10882 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10883                                        unsigned int res)
10884 {
10885         if ((res >> 26) != ALC880_HP_EVENT)
10886                 return;
10887         alc268_toshiba_automute(codec);
10888 }
10889
10890 static void alc268_acer_unsol_event(struct hda_codec *codec,
10891                                        unsigned int res)
10892 {
10893         if ((res >> 26) != ALC880_HP_EVENT)
10894                 return;
10895         alc268_acer_automute(codec, 1);
10896 }
10897
10898 static void alc268_acer_init_hook(struct hda_codec *codec)
10899 {
10900         alc268_acer_automute(codec, 1);
10901 }
10902
10903 /* toggle speaker-output according to the hp-jack state */
10904 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
10905 {
10906         unsigned int present;
10907         unsigned char bits;
10908
10909         present = snd_hda_codec_read(codec, 0x15, 0,
10910                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10911         bits = present ? AMP_IN_MUTE(0) : 0;
10912         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
10913                                 AMP_IN_MUTE(0), bits);
10914         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
10915                                 AMP_IN_MUTE(0), bits);
10916 }
10917
10918
10919 static void alc268_acer_mic_automute(struct hda_codec *codec)
10920 {
10921         unsigned int present;
10922
10923         present = snd_hda_codec_read(codec, 0x18, 0,
10924                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10925         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
10926                             present ? 0x0 : 0x6);
10927 }
10928
10929 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
10930                                     unsigned int res)
10931 {
10932         if ((res >> 26) == ALC880_HP_EVENT)
10933                 alc268_aspire_one_speaker_automute(codec);
10934         if ((res >> 26) == ALC880_MIC_EVENT)
10935                 alc268_acer_mic_automute(codec);
10936 }
10937
10938 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
10939 {
10940         alc268_aspire_one_speaker_automute(codec);
10941         alc268_acer_mic_automute(codec);
10942 }
10943
10944 static struct snd_kcontrol_new alc268_dell_mixer[] = {
10945         /* output mixer control */
10946         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
10947         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10948         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
10949         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10950         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10951         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10952         { }
10953 };
10954
10955 static struct hda_verb alc268_dell_verbs[] = {
10956         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10957         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10958         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10959         { }
10960 };
10961
10962 /* mute/unmute internal speaker according to the hp jack and mute state */
10963 static void alc268_dell_automute(struct hda_codec *codec)
10964 {
10965         unsigned int present;
10966         unsigned int mute;
10967
10968         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
10969         if (present & 0x80000000)
10970                 mute = HDA_AMP_MUTE;
10971         else
10972                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
10973         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10974                                  HDA_AMP_MUTE, mute);
10975 }
10976
10977 static void alc268_dell_unsol_event(struct hda_codec *codec,
10978                                     unsigned int res)
10979 {
10980         if ((res >> 26) != ALC880_HP_EVENT)
10981                 return;
10982         alc268_dell_automute(codec);
10983 }
10984
10985 #define alc268_dell_init_hook   alc268_dell_automute
10986
10987 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
10988         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10989         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10990         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10991         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10992         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
10993         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
10994         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
10995         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10996         { }
10997 };
10998
10999 static struct hda_verb alc267_quanta_il1_verbs[] = {
11000         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11001         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11002         { }
11003 };
11004
11005 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11006 {
11007         unsigned int present;
11008
11009         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11010                 & AC_PINSENSE_PRESENCE;
11011         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11012                             present ? 0 : PIN_OUT);
11013 }
11014
11015 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11016 {
11017         unsigned int present;
11018
11019         present = snd_hda_codec_read(codec, 0x18, 0,
11020                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11021         snd_hda_codec_write(codec, 0x23, 0,
11022                             AC_VERB_SET_CONNECT_SEL,
11023                             present ? 0x00 : 0x01);
11024 }
11025
11026 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11027 {
11028         alc267_quanta_il1_hp_automute(codec);
11029         alc267_quanta_il1_mic_automute(codec);
11030 }
11031
11032 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11033                                            unsigned int res)
11034 {
11035         switch (res >> 26) {
11036         case ALC880_HP_EVENT:
11037                 alc267_quanta_il1_hp_automute(codec);
11038                 break;
11039         case ALC880_MIC_EVENT:
11040                 alc267_quanta_il1_mic_automute(codec);
11041                 break;
11042         }
11043 }
11044
11045 /*
11046  * generic initialization of ADC, input mixers and output mixers
11047  */
11048 static struct hda_verb alc268_base_init_verbs[] = {
11049         /* Unmute DAC0-1 and set vol = 0 */
11050         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11051         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11052         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11053         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11054         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11055         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11056
11057         /*
11058          * Set up output mixers (0x0c - 0x0e)
11059          */
11060         /* set vol=0 to output mixers */
11061         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11062         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11063         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11064         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11065
11066         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11067         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11068
11069         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11070         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11071         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11072         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11073         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11074         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11075         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11076         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11077
11078         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11079         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11080         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11081         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11082         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11083         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11084         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11085
11086         /* set PCBEEP vol = 0, mute connections */
11087         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11088         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11089         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11090
11091         /* Unmute Selector 23h,24h and set the default input to mic-in */
11092
11093         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11094         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11095         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11096         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11097
11098         { }
11099 };
11100
11101 /*
11102  * generic initialization of ADC, input mixers and output mixers
11103  */
11104 static struct hda_verb alc268_volume_init_verbs[] = {
11105         /* set output DAC */
11106         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11107         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11108         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11109         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11110
11111         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11112         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11113         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11114         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11115         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11116
11117         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11118         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11119         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11120         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11121         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11122
11123         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11124         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11125         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11126         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11127
11128         /* set PCBEEP vol = 0, mute connections */
11129         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11130         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11131         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11132
11133         { }
11134 };
11135
11136 #define alc268_mux_enum_info alc_mux_enum_info
11137 #define alc268_mux_enum_get alc_mux_enum_get
11138 #define alc268_mux_enum_put alc_mux_enum_put
11139
11140 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11141         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11142         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11143         {
11144                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11145                 /* The multiple "Capture Source" controls confuse alsamixer
11146                  * So call somewhat different..
11147                  */
11148                 /* .name = "Capture Source", */
11149                 .name = "Input Source",
11150                 .count = 1,
11151                 .info = alc268_mux_enum_info,
11152                 .get = alc268_mux_enum_get,
11153                 .put = alc268_mux_enum_put,
11154         },
11155         { } /* end */
11156 };
11157
11158 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11159         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11160         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11161         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11162         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11163         {
11164                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11165                 /* The multiple "Capture Source" controls confuse alsamixer
11166                  * So call somewhat different..
11167                  */
11168                 /* .name = "Capture Source", */
11169                 .name = "Input Source",
11170                 .count = 2,
11171                 .info = alc268_mux_enum_info,
11172                 .get = alc268_mux_enum_get,
11173                 .put = alc268_mux_enum_put,
11174         },
11175         { } /* end */
11176 };
11177
11178 static struct hda_input_mux alc268_capture_source = {
11179         .num_items = 4,
11180         .items = {
11181                 { "Mic", 0x0 },
11182                 { "Front Mic", 0x1 },
11183                 { "Line", 0x2 },
11184                 { "CD", 0x3 },
11185         },
11186 };
11187
11188 static struct hda_input_mux alc268_acer_capture_source = {
11189         .num_items = 3,
11190         .items = {
11191                 { "Mic", 0x0 },
11192                 { "Internal Mic", 0x6 },
11193                 { "Line", 0x2 },
11194         },
11195 };
11196
11197 #ifdef CONFIG_SND_DEBUG
11198 static struct snd_kcontrol_new alc268_test_mixer[] = {
11199         /* Volume widgets */
11200         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11201         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11202         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11203         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11204         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11205         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11206         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11207         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11208         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11209         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11210         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11211         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11212         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11213         /* The below appears problematic on some hardwares */
11214         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11215         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11216         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11217         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11218         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11219
11220         /* Modes for retasking pin widgets */
11221         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11222         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11223         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11224         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11225
11226         /* Controls for GPIO pins, assuming they are configured as outputs */
11227         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11228         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11229         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11230         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11231
11232         /* Switches to allow the digital SPDIF output pin to be enabled.
11233          * The ALC268 does not have an SPDIF input.
11234          */
11235         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11236
11237         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11238          * this output to turn on an external amplifier.
11239          */
11240         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11241         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11242
11243         { } /* end */
11244 };
11245 #endif
11246
11247 /* create input playback/capture controls for the given pin */
11248 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11249                                     const char *ctlname, int idx)
11250 {
11251         char name[32];
11252         int err;
11253
11254         sprintf(name, "%s Playback Volume", ctlname);
11255         if (nid == 0x14) {
11256                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11257                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11258                                                       HDA_OUTPUT));
11259                 if (err < 0)
11260                         return err;
11261         } else if (nid == 0x15) {
11262                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11263                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11264                                                       HDA_OUTPUT));
11265                 if (err < 0)
11266                         return err;
11267         } else
11268                 return -1;
11269         sprintf(name, "%s Playback Switch", ctlname);
11270         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11271                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11272         if (err < 0)
11273                 return err;
11274         return 0;
11275 }
11276
11277 /* add playback controls from the parsed DAC table */
11278 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11279                                              const struct auto_pin_cfg *cfg)
11280 {
11281         hda_nid_t nid;
11282         int err;
11283
11284         spec->multiout.num_dacs = 2;    /* only use one dac */
11285         spec->multiout.dac_nids = spec->private_dac_nids;
11286         spec->multiout.dac_nids[0] = 2;
11287         spec->multiout.dac_nids[1] = 3;
11288
11289         nid = cfg->line_out_pins[0];
11290         if (nid)
11291                 alc268_new_analog_output(spec, nid, "Front", 0);
11292
11293         nid = cfg->speaker_pins[0];
11294         if (nid == 0x1d) {
11295                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11296                                   "Speaker Playback Volume",
11297                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11298                 if (err < 0)
11299                         return err;
11300         }
11301         nid = cfg->hp_pins[0];
11302         if (nid)
11303                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11304
11305         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11306         if (nid == 0x16) {
11307                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11308                                   "Mono Playback Switch",
11309                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11310                 if (err < 0)
11311                         return err;
11312         }
11313         return 0;
11314 }
11315
11316 /* create playback/capture controls for input pins */
11317 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11318                                                 const struct auto_pin_cfg *cfg)
11319 {
11320         struct hda_input_mux *imux = &spec->private_imux;
11321         int i, idx1;
11322
11323         for (i = 0; i < AUTO_PIN_LAST; i++) {
11324                 switch(cfg->input_pins[i]) {
11325                 case 0x18:
11326                         idx1 = 0;       /* Mic 1 */
11327                         break;
11328                 case 0x19:
11329                         idx1 = 1;       /* Mic 2 */
11330                         break;
11331                 case 0x1a:
11332                         idx1 = 2;       /* Line In */
11333                         break;
11334                 case 0x1c:
11335                         idx1 = 3;       /* CD */
11336                         break;
11337                 case 0x12:
11338                 case 0x13:
11339                         idx1 = 6;       /* digital mics */
11340                         break;
11341                 default:
11342                         continue;
11343                 }
11344                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11345                 imux->items[imux->num_items].index = idx1;
11346                 imux->num_items++;
11347         }
11348         return 0;
11349 }
11350
11351 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11352 {
11353         struct alc_spec *spec = codec->spec;
11354         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11355         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11356         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11357         unsigned int    dac_vol1, dac_vol2;
11358
11359         if (speaker_nid) {
11360                 snd_hda_codec_write(codec, speaker_nid, 0,
11361                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11362                 snd_hda_codec_write(codec, 0x0f, 0,
11363                                     AC_VERB_SET_AMP_GAIN_MUTE,
11364                                     AMP_IN_UNMUTE(1));
11365                 snd_hda_codec_write(codec, 0x10, 0,
11366                                     AC_VERB_SET_AMP_GAIN_MUTE,
11367                                     AMP_IN_UNMUTE(1));
11368         } else {
11369                 snd_hda_codec_write(codec, 0x0f, 0,
11370                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11371                 snd_hda_codec_write(codec, 0x10, 0,
11372                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11373         }
11374
11375         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11376         if (line_nid == 0x14)
11377                 dac_vol2 = AMP_OUT_ZERO;
11378         else if (line_nid == 0x15)
11379                 dac_vol1 = AMP_OUT_ZERO;
11380         if (hp_nid == 0x14)
11381                 dac_vol2 = AMP_OUT_ZERO;
11382         else if (hp_nid == 0x15)
11383                 dac_vol1 = AMP_OUT_ZERO;
11384         if (line_nid != 0x16 || hp_nid != 0x16 ||
11385             spec->autocfg.line_out_pins[1] != 0x16 ||
11386             spec->autocfg.line_out_pins[2] != 0x16)
11387                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11388
11389         snd_hda_codec_write(codec, 0x02, 0,
11390                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11391         snd_hda_codec_write(codec, 0x03, 0,
11392                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11393 }
11394
11395 /* pcm configuration: identiacal with ALC880 */
11396 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11397 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11398 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11399 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11400
11401 /*
11402  * BIOS auto configuration
11403  */
11404 static int alc268_parse_auto_config(struct hda_codec *codec)
11405 {
11406         struct alc_spec *spec = codec->spec;
11407         int err;
11408         static hda_nid_t alc268_ignore[] = { 0 };
11409
11410         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11411                                            alc268_ignore);
11412         if (err < 0)
11413                 return err;
11414         if (!spec->autocfg.line_outs)
11415                 return 0; /* can't find valid BIOS pin config */
11416
11417         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11418         if (err < 0)
11419                 return err;
11420         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11421         if (err < 0)
11422                 return err;
11423
11424         spec->multiout.max_channels = 2;
11425
11426         /* digital only support output */
11427         if (spec->autocfg.dig_out_pin)
11428                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11429
11430         if (spec->kctl_alloc)
11431                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11432
11433         if (spec->autocfg.speaker_pins[0] != 0x1d)
11434                 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
11435
11436         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
11437         spec->num_mux_defs = 1;
11438         spec->input_mux = &spec->private_imux;
11439
11440         err = alc_auto_add_mic_boost(codec);
11441         if (err < 0)
11442                 return err;
11443
11444         return 1;
11445 }
11446
11447 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11448 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11449 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11450
11451 /* init callback for auto-configuration model -- overriding the default init */
11452 static void alc268_auto_init(struct hda_codec *codec)
11453 {
11454         struct alc_spec *spec = codec->spec;
11455         alc268_auto_init_multi_out(codec);
11456         alc268_auto_init_hp_out(codec);
11457         alc268_auto_init_mono_speaker_out(codec);
11458         alc268_auto_init_analog_input(codec);
11459         if (spec->unsol_event)
11460                 alc_inithook(codec);
11461 }
11462
11463 /*
11464  * configuration and preset
11465  */
11466 static const char *alc268_models[ALC268_MODEL_LAST] = {
11467         [ALC267_QUANTA_IL1]     = "quanta-il1",
11468         [ALC268_3ST]            = "3stack",
11469         [ALC268_TOSHIBA]        = "toshiba",
11470         [ALC268_ACER]           = "acer",
11471         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
11472         [ALC268_DELL]           = "dell",
11473         [ALC268_ZEPTO]          = "zepto",
11474 #ifdef CONFIG_SND_DEBUG
11475         [ALC268_TEST]           = "test",
11476 #endif
11477         [ALC268_AUTO]           = "auto",
11478 };
11479
11480 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11481         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11482         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11483         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11484         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11485         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11486         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11487                                                 ALC268_ACER_ASPIRE_ONE),
11488         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11489         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11490         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11491         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11492         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11493         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11494         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11495         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11496         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11497         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11498         {}
11499 };
11500
11501 static struct alc_config_preset alc268_presets[] = {
11502         [ALC267_QUANTA_IL1] = {
11503                 .mixers = { alc267_quanta_il1_mixer },
11504                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11505                                 alc267_quanta_il1_verbs },
11506                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11507                 .dac_nids = alc268_dac_nids,
11508                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11509                 .adc_nids = alc268_adc_nids_alt,
11510                 .hp_nid = 0x03,
11511                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11512                 .channel_mode = alc268_modes,
11513                 .input_mux = &alc268_capture_source,
11514                 .unsol_event = alc267_quanta_il1_unsol_event,
11515                 .init_hook = alc267_quanta_il1_automute,
11516         },
11517         [ALC268_3ST] = {
11518                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11519                             alc268_beep_mixer },
11520                 .init_verbs = { alc268_base_init_verbs },
11521                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11522                 .dac_nids = alc268_dac_nids,
11523                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11524                 .adc_nids = alc268_adc_nids_alt,
11525                 .capsrc_nids = alc268_capsrc_nids,
11526                 .hp_nid = 0x03,
11527                 .dig_out_nid = ALC268_DIGOUT_NID,
11528                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11529                 .channel_mode = alc268_modes,
11530                 .input_mux = &alc268_capture_source,
11531         },
11532         [ALC268_TOSHIBA] = {
11533                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11534                             alc268_beep_mixer },
11535                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11536                                 alc268_toshiba_verbs },
11537                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11538                 .dac_nids = alc268_dac_nids,
11539                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11540                 .adc_nids = alc268_adc_nids_alt,
11541                 .capsrc_nids = alc268_capsrc_nids,
11542                 .hp_nid = 0x03,
11543                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11544                 .channel_mode = alc268_modes,
11545                 .input_mux = &alc268_capture_source,
11546                 .unsol_event = alc268_toshiba_unsol_event,
11547                 .init_hook = alc268_toshiba_automute,
11548         },
11549         [ALC268_ACER] = {
11550                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11551                             alc268_beep_mixer },
11552                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11553                                 alc268_acer_verbs },
11554                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11555                 .dac_nids = alc268_dac_nids,
11556                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11557                 .adc_nids = alc268_adc_nids_alt,
11558                 .capsrc_nids = alc268_capsrc_nids,
11559                 .hp_nid = 0x02,
11560                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11561                 .channel_mode = alc268_modes,
11562                 .input_mux = &alc268_acer_capture_source,
11563                 .unsol_event = alc268_acer_unsol_event,
11564                 .init_hook = alc268_acer_init_hook,
11565         },
11566         [ALC268_ACER_ASPIRE_ONE] = {
11567                 .mixers = { alc268_acer_aspire_one_mixer,
11568                                 alc268_capture_alt_mixer },
11569                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11570                                 alc268_acer_aspire_one_verbs },
11571                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11572                 .dac_nids = alc268_dac_nids,
11573                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11574                 .adc_nids = alc268_adc_nids_alt,
11575                 .capsrc_nids = alc268_capsrc_nids,
11576                 .hp_nid = 0x03,
11577                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11578                 .channel_mode = alc268_modes,
11579                 .input_mux = &alc268_acer_lc_capture_source,
11580                 .unsol_event = alc268_acer_lc_unsol_event,
11581                 .init_hook = alc268_acer_lc_init_hook,
11582         },
11583         [ALC268_DELL] = {
11584                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
11585                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11586                                 alc268_dell_verbs },
11587                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11588                 .dac_nids = alc268_dac_nids,
11589                 .hp_nid = 0x02,
11590                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11591                 .channel_mode = alc268_modes,
11592                 .unsol_event = alc268_dell_unsol_event,
11593                 .init_hook = alc268_dell_init_hook,
11594                 .input_mux = &alc268_capture_source,
11595         },
11596         [ALC268_ZEPTO] = {
11597                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11598                             alc268_beep_mixer },
11599                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11600                                 alc268_toshiba_verbs },
11601                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11602                 .dac_nids = alc268_dac_nids,
11603                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11604                 .adc_nids = alc268_adc_nids_alt,
11605                 .capsrc_nids = alc268_capsrc_nids,
11606                 .hp_nid = 0x03,
11607                 .dig_out_nid = ALC268_DIGOUT_NID,
11608                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11609                 .channel_mode = alc268_modes,
11610                 .input_mux = &alc268_capture_source,
11611                 .unsol_event = alc268_toshiba_unsol_event,
11612                 .init_hook = alc268_toshiba_automute
11613         },
11614 #ifdef CONFIG_SND_DEBUG
11615         [ALC268_TEST] = {
11616                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
11617                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11618                                 alc268_volume_init_verbs },
11619                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11620                 .dac_nids = alc268_dac_nids,
11621                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11622                 .adc_nids = alc268_adc_nids_alt,
11623                 .capsrc_nids = alc268_capsrc_nids,
11624                 .hp_nid = 0x03,
11625                 .dig_out_nid = ALC268_DIGOUT_NID,
11626                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11627                 .channel_mode = alc268_modes,
11628                 .input_mux = &alc268_capture_source,
11629         },
11630 #endif
11631 };
11632
11633 static int patch_alc268(struct hda_codec *codec)
11634 {
11635         struct alc_spec *spec;
11636         int board_config;
11637         int err;
11638
11639         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
11640         if (spec == NULL)
11641                 return -ENOMEM;
11642
11643         codec->spec = spec;
11644
11645         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
11646                                                   alc268_models,
11647                                                   alc268_cfg_tbl);
11648
11649         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
11650                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
11651                        "trying auto-probe from BIOS...\n");
11652                 board_config = ALC268_AUTO;
11653         }
11654
11655         if (board_config == ALC268_AUTO) {
11656                 /* automatic parse from the BIOS config */
11657                 err = alc268_parse_auto_config(codec);
11658                 if (err < 0) {
11659                         alc_free(codec);
11660                         return err;
11661                 } else if (!err) {
11662                         printk(KERN_INFO
11663                                "hda_codec: Cannot set up configuration "
11664                                "from BIOS.  Using base mode...\n");
11665                         board_config = ALC268_3ST;
11666                 }
11667         }
11668
11669         if (board_config != ALC268_AUTO)
11670                 setup_preset(spec, &alc268_presets[board_config]);
11671
11672         if (codec->vendor_id == 0x10ec0267) {
11673                 spec->stream_name_analog = "ALC267 Analog";
11674                 spec->stream_name_digital = "ALC267 Digital";
11675         } else {
11676                 spec->stream_name_analog = "ALC268 Analog";
11677                 spec->stream_name_digital = "ALC268 Digital";
11678         }
11679
11680         spec->stream_analog_playback = &alc268_pcm_analog_playback;
11681         spec->stream_analog_capture = &alc268_pcm_analog_capture;
11682         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
11683
11684         spec->stream_digital_playback = &alc268_pcm_digital_playback;
11685
11686         if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
11687                 /* override the amp caps for beep generator */
11688                 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
11689                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
11690                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
11691                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11692                                           (0 << AC_AMPCAP_MUTE_SHIFT));
11693
11694         if (!spec->adc_nids && spec->input_mux) {
11695                 /* check whether NID 0x07 is valid */
11696                 unsigned int wcap = get_wcaps(codec, 0x07);
11697                 int i;
11698
11699                 /* get type */
11700                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11701                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
11702                         spec->adc_nids = alc268_adc_nids_alt;
11703                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
11704                         spec->mixers[spec->num_mixers] =
11705                                         alc268_capture_alt_mixer;
11706                         spec->num_mixers++;
11707                 } else {
11708                         spec->adc_nids = alc268_adc_nids;
11709                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
11710                         spec->mixers[spec->num_mixers] =
11711                                 alc268_capture_mixer;
11712                         spec->num_mixers++;
11713                 }
11714                 spec->capsrc_nids = alc268_capsrc_nids;
11715                 /* set default input source */
11716                 for (i = 0; i < spec->num_adc_nids; i++)
11717                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
11718                                 0, AC_VERB_SET_CONNECT_SEL,
11719                                 spec->input_mux->items[0].index);
11720         }
11721
11722         spec->vmaster_nid = 0x02;
11723
11724         codec->patch_ops = alc_patch_ops;
11725         if (board_config == ALC268_AUTO)
11726                 spec->init_hook = alc268_auto_init;
11727
11728         return 0;
11729 }
11730
11731 /*
11732  *  ALC269 channel source setting (2 channel)
11733  */
11734 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
11735
11736 #define alc269_dac_nids         alc260_dac_nids
11737
11738 static hda_nid_t alc269_adc_nids[1] = {
11739         /* ADC1 */
11740         0x08,
11741 };
11742
11743 static hda_nid_t alc269_capsrc_nids[1] = {
11744         0x23,
11745 };
11746
11747 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
11748  *       not a mux!
11749  */
11750
11751 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
11752         .num_items = 2,
11753         .items = {
11754                 { "i-Mic", 0x5 },
11755                 { "e-Mic", 0x0 },
11756         },
11757 };
11758
11759 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
11760         .num_items = 2,
11761         .items = {
11762                 { "i-Mic", 0x1 },
11763                 { "e-Mic", 0x0 },
11764         },
11765 };
11766
11767 #define alc269_modes            alc260_modes
11768 #define alc269_capture_source   alc880_lg_lw_capture_source
11769
11770 static struct snd_kcontrol_new alc269_base_mixer[] = {
11771         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11772         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11773         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11774         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11775         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11776         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11777         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11778         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11779         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11780         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11781         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11782         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11783         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11784         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11785         { } /* end */
11786 };
11787
11788 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
11789         /* output mixer control */
11790         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11791         {
11792                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11793                 .name = "Master Playback Switch",
11794                 .info = snd_hda_mixer_amp_switch_info,
11795                 .get = snd_hda_mixer_amp_switch_get,
11796                 .put = alc268_acer_master_sw_put,
11797                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11798         },
11799         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11800         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11801         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11802         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11803         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11804         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11805         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
11806         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
11807         { }
11808 };
11809
11810 /* bind volumes of both NID 0x0c and 0x0d */
11811 static struct hda_bind_ctls alc269_epc_bind_vol = {
11812         .ops = &snd_hda_bind_vol,
11813         .values = {
11814                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11815                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11816                 0
11817         },
11818 };
11819
11820 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11821         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11822         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11823         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11824         { } /* end */
11825 };
11826
11827 /* capture mixer elements */
11828 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11829         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11830         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11831         {
11832                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11833                 /* The multiple "Capture Source" controls confuse alsamixer
11834                  * So call somewhat different..
11835                  */
11836                 /* .name = "Capture Source", */
11837                 .name = "Input Source",
11838                 .count = 1,
11839                 .info = alc_mux_enum_info,
11840                 .get = alc_mux_enum_get,
11841                 .put = alc_mux_enum_put,
11842         },
11843         { } /* end */
11844 };
11845
11846 /* capture mixer elements */
11847 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11848         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11849         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11850         { } /* end */
11851 };
11852
11853 /* beep control */
11854 static struct snd_kcontrol_new alc269_beep_mixer[] = {
11855         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11856         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11857         { } /* end */
11858 };
11859
11860 static struct hda_verb alc269_quanta_fl1_verbs[] = {
11861         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11862         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11863         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11864         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11865         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11866         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11867         { }
11868 };
11869
11870 /* toggle speaker-output according to the hp-jack state */
11871 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
11872 {
11873         unsigned int present;
11874         unsigned char bits;
11875
11876         present = snd_hda_codec_read(codec, 0x15, 0,
11877                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11878         bits = present ? AMP_IN_MUTE(0) : 0;
11879         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11880                         AMP_IN_MUTE(0), bits);
11881         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11882                         AMP_IN_MUTE(0), bits);
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, 0x680);
11888
11889         snd_hda_codec_write(codec, 0x20, 0,
11890                         AC_VERB_SET_COEF_INDEX, 0x0c);
11891         snd_hda_codec_write(codec, 0x20, 0,
11892                         AC_VERB_SET_PROC_COEF, 0x480);
11893 }
11894
11895 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
11896 {
11897         unsigned int present;
11898
11899         present = snd_hda_codec_read(codec, 0x18, 0,
11900                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11901         snd_hda_codec_write(codec, 0x23, 0,
11902                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
11903 }
11904
11905 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
11906                                     unsigned int res)
11907 {
11908         if ((res >> 26) == ALC880_HP_EVENT)
11909                 alc269_quanta_fl1_speaker_automute(codec);
11910         if ((res >> 26) == ALC880_MIC_EVENT)
11911                 alc269_quanta_fl1_mic_automute(codec);
11912 }
11913
11914 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
11915 {
11916         alc269_quanta_fl1_speaker_automute(codec);
11917         alc269_quanta_fl1_mic_automute(codec);
11918 }
11919
11920 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
11921         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11922         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
11923         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11924         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
11925         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11926         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11927         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11928         {}
11929 };
11930
11931 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
11932         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11933         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
11934         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
11935         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
11936         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11937         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11938         {}
11939 };
11940
11941 /* toggle speaker-output according to the hp-jack state */
11942 static void alc269_speaker_automute(struct hda_codec *codec)
11943 {
11944         unsigned int present;
11945         unsigned char bits;
11946
11947         present = snd_hda_codec_read(codec, 0x15, 0,
11948                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11949         bits = present ? AMP_IN_MUTE(0) : 0;
11950         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11951                                 AMP_IN_MUTE(0), bits);
11952         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11953                                 AMP_IN_MUTE(0), bits);
11954 }
11955
11956 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
11957 {
11958         unsigned int present;
11959
11960         present = snd_hda_codec_read(codec, 0x18, 0,
11961                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11962         snd_hda_codec_write(codec, 0x23, 0,
11963                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
11964 }
11965
11966 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
11967 {
11968         unsigned int present;
11969
11970         present = snd_hda_codec_read(codec, 0x18, 0,
11971                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11972         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11973                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
11974         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
11975                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
11976 }
11977
11978 /* unsolicited event for HP jack sensing */
11979 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
11980                                      unsigned int res)
11981 {
11982         if ((res >> 26) == ALC880_HP_EVENT)
11983                 alc269_speaker_automute(codec);
11984
11985         if ((res >> 26) == ALC880_MIC_EVENT)
11986                 alc269_eeepc_dmic_automute(codec);
11987 }
11988
11989 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
11990 {
11991         alc269_speaker_automute(codec);
11992         alc269_eeepc_dmic_automute(codec);
11993 }
11994
11995 /* unsolicited event for HP jack sensing */
11996 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
11997                                      unsigned int res)
11998 {
11999         if ((res >> 26) == ALC880_HP_EVENT)
12000                 alc269_speaker_automute(codec);
12001
12002         if ((res >> 26) == ALC880_MIC_EVENT)
12003                 alc269_eeepc_amic_automute(codec);
12004 }
12005
12006 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12007 {
12008         alc269_speaker_automute(codec);
12009         alc269_eeepc_amic_automute(codec);
12010 }
12011
12012 /*
12013  * generic initialization of ADC, input mixers and output mixers
12014  */
12015 static struct hda_verb alc269_init_verbs[] = {
12016         /*
12017          * Unmute ADC0 and set the default input to mic-in
12018          */
12019         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12020
12021         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12022          * analog-loopback mixer widget
12023          * Note: PASD motherboards uses the Line In 2 as the input for
12024          * front panel mic (mic 2)
12025          */
12026         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12027         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12028         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12029         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12030         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12031         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12032
12033         /*
12034          * Set up output mixers (0x0c - 0x0e)
12035          */
12036         /* set vol=0 to output mixers */
12037         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12038         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12039
12040         /* set up input amps for analog loopback */
12041         /* Amp Indices: DAC = 0, mixer = 1 */
12042         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12043         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12044         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12045         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12046         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12047         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12048
12049         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12050         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12051         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12052         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12053         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12054         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12055         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12056
12057         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12058         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12059         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12060         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12061         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12062         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12063         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12064
12065         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12066         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12067
12068         /* FIXME: use matrix-type input source selection */
12069         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12070         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12071         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12072         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12073         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12074         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12075
12076         /* set EAPD */
12077         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12078         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12079         { }
12080 };
12081
12082 /* add playback controls from the parsed DAC table */
12083 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12084                                              const struct auto_pin_cfg *cfg)
12085 {
12086         hda_nid_t nid;
12087         int err;
12088
12089         spec->multiout.num_dacs = 1;    /* only use one dac */
12090         spec->multiout.dac_nids = spec->private_dac_nids;
12091         spec->multiout.dac_nids[0] = 2;
12092
12093         nid = cfg->line_out_pins[0];
12094         if (nid) {
12095                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12096                                   "Front Playback Volume",
12097                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12098                 if (err < 0)
12099                         return err;
12100                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12101                                   "Front Playback Switch",
12102                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12103                 if (err < 0)
12104                         return err;
12105         }
12106
12107         nid = cfg->speaker_pins[0];
12108         if (nid) {
12109                 if (!cfg->line_out_pins[0]) {
12110                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12111                                           "Speaker Playback Volume",
12112                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12113                                                               HDA_OUTPUT));
12114                         if (err < 0)
12115                                 return err;
12116                 }
12117                 if (nid == 0x16) {
12118                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12119                                           "Speaker Playback Switch",
12120                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12121                                                               HDA_OUTPUT));
12122                         if (err < 0)
12123                                 return err;
12124                 } else {
12125                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12126                                           "Speaker Playback Switch",
12127                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12128                                                               HDA_OUTPUT));
12129                         if (err < 0)
12130                                 return err;
12131                 }
12132         }
12133         nid = cfg->hp_pins[0];
12134         if (nid) {
12135                 /* spec->multiout.hp_nid = 2; */
12136                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12137                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12138                                           "Headphone Playback Volume",
12139                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12140                                                               HDA_OUTPUT));
12141                         if (err < 0)
12142                                 return err;
12143                 }
12144                 if (nid == 0x16) {
12145                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12146                                           "Headphone Playback Switch",
12147                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12148                                                               HDA_OUTPUT));
12149                         if (err < 0)
12150                                 return err;
12151                 } else {
12152                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12153                                           "Headphone Playback Switch",
12154                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12155                                                               HDA_OUTPUT));
12156                         if (err < 0)
12157                                 return err;
12158                 }
12159         }
12160         return 0;
12161 }
12162
12163 #define alc269_auto_create_analog_input_ctls \
12164         alc880_auto_create_analog_input_ctls
12165
12166 #ifdef CONFIG_SND_HDA_POWER_SAVE
12167 #define alc269_loopbacks        alc880_loopbacks
12168 #endif
12169
12170 /* pcm configuration: identiacal with ALC880 */
12171 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12172 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12173 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12174 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12175
12176 /*
12177  * BIOS auto configuration
12178  */
12179 static int alc269_parse_auto_config(struct hda_codec *codec)
12180 {
12181         struct alc_spec *spec = codec->spec;
12182         int i, err;
12183         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12184
12185         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12186                                            alc269_ignore);
12187         if (err < 0)
12188                 return err;
12189
12190         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12191         if (err < 0)
12192                 return err;
12193         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12194         if (err < 0)
12195                 return err;
12196
12197         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12198
12199         if (spec->autocfg.dig_out_pin)
12200                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12201
12202         if (spec->kctl_alloc)
12203                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12204
12205         /* create a beep mixer control if the pin 0x1d isn't assigned */
12206         for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++)
12207                 if (spec->autocfg.input_pins[i] == 0x1d)
12208                         break;
12209         if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
12210                 spec->mixers[spec->num_mixers++] = alc269_beep_mixer;
12211
12212         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
12213         spec->num_mux_defs = 1;
12214         spec->input_mux = &spec->private_imux;
12215         /* set default input source */
12216         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12217                                   0, AC_VERB_SET_CONNECT_SEL,
12218                                   spec->input_mux->items[0].index);
12219
12220         err = alc_auto_add_mic_boost(codec);
12221         if (err < 0)
12222                 return err;
12223
12224         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
12225         spec->num_mixers++;
12226
12227         return 1;
12228 }
12229
12230 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12231 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12232 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12233
12234
12235 /* init callback for auto-configuration model -- overriding the default init */
12236 static void alc269_auto_init(struct hda_codec *codec)
12237 {
12238         struct alc_spec *spec = codec->spec;
12239         alc269_auto_init_multi_out(codec);
12240         alc269_auto_init_hp_out(codec);
12241         alc269_auto_init_analog_input(codec);
12242         if (spec->unsol_event)
12243                 alc_inithook(codec);
12244 }
12245
12246 /*
12247  * configuration and preset
12248  */
12249 static const char *alc269_models[ALC269_MODEL_LAST] = {
12250         [ALC269_BASIC]                  = "basic",
12251         [ALC269_QUANTA_FL1]             = "quanta",
12252         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12253         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901"
12254 };
12255
12256 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12257         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12258         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12259                       ALC269_ASUS_EEEPC_P703),
12260         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12261                       ALC269_ASUS_EEEPC_P901),
12262         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12263                       ALC269_ASUS_EEEPC_P901),
12264         {}
12265 };
12266
12267 static struct alc_config_preset alc269_presets[] = {
12268         [ALC269_BASIC] = {
12269                 .mixers = { alc269_base_mixer, alc269_capture_mixer },
12270                 .init_verbs = { alc269_init_verbs },
12271                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12272                 .dac_nids = alc269_dac_nids,
12273                 .hp_nid = 0x03,
12274                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12275                 .channel_mode = alc269_modes,
12276                 .input_mux = &alc269_capture_source,
12277         },
12278         [ALC269_QUANTA_FL1] = {
12279                 .mixers = { alc269_quanta_fl1_mixer },
12280                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12281                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12282                 .dac_nids = alc269_dac_nids,
12283                 .hp_nid = 0x03,
12284                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12285                 .channel_mode = alc269_modes,
12286                 .input_mux = &alc269_capture_source,
12287                 .unsol_event = alc269_quanta_fl1_unsol_event,
12288                 .init_hook = alc269_quanta_fl1_init_hook,
12289         },
12290         [ALC269_ASUS_EEEPC_P703] = {
12291                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
12292                 .init_verbs = { alc269_init_verbs,
12293                                 alc269_eeepc_amic_init_verbs },
12294                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12295                 .dac_nids = alc269_dac_nids,
12296                 .hp_nid = 0x03,
12297                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12298                 .channel_mode = alc269_modes,
12299                 .input_mux = &alc269_eeepc_amic_capture_source,
12300                 .unsol_event = alc269_eeepc_amic_unsol_event,
12301                 .init_hook = alc269_eeepc_amic_inithook,
12302         },
12303         [ALC269_ASUS_EEEPC_P901] = {
12304                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
12305                 .init_verbs = { alc269_init_verbs,
12306                                 alc269_eeepc_dmic_init_verbs },
12307                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12308                 .dac_nids = alc269_dac_nids,
12309                 .hp_nid = 0x03,
12310                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12311                 .channel_mode = alc269_modes,
12312                 .input_mux = &alc269_eeepc_dmic_capture_source,
12313                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12314                 .init_hook = alc269_eeepc_dmic_inithook,
12315         },
12316 };
12317
12318 static int patch_alc269(struct hda_codec *codec)
12319 {
12320         struct alc_spec *spec;
12321         int board_config;
12322         int err;
12323
12324         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12325         if (spec == NULL)
12326                 return -ENOMEM;
12327
12328         codec->spec = spec;
12329
12330         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12331
12332         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12333                                                   alc269_models,
12334                                                   alc269_cfg_tbl);
12335
12336         if (board_config < 0) {
12337                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12338                        "trying auto-probe from BIOS...\n");
12339                 board_config = ALC269_AUTO;
12340         }
12341
12342         if (board_config == ALC269_AUTO) {
12343                 /* automatic parse from the BIOS config */
12344                 err = alc269_parse_auto_config(codec);
12345                 if (err < 0) {
12346                         alc_free(codec);
12347                         return err;
12348                 } else if (!err) {
12349                         printk(KERN_INFO
12350                                "hda_codec: Cannot set up configuration "
12351                                "from BIOS.  Using base mode...\n");
12352                         board_config = ALC269_BASIC;
12353                 }
12354         }
12355
12356         if (board_config != ALC269_AUTO)
12357                 setup_preset(spec, &alc269_presets[board_config]);
12358
12359         spec->stream_name_analog = "ALC269 Analog";
12360         spec->stream_analog_playback = &alc269_pcm_analog_playback;
12361         spec->stream_analog_capture = &alc269_pcm_analog_capture;
12362
12363         spec->stream_name_digital = "ALC269 Digital";
12364         spec->stream_digital_playback = &alc269_pcm_digital_playback;
12365         spec->stream_digital_capture = &alc269_pcm_digital_capture;
12366
12367         spec->adc_nids = alc269_adc_nids;
12368         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12369         spec->capsrc_nids = alc269_capsrc_nids;
12370
12371         codec->patch_ops = alc_patch_ops;
12372         if (board_config == ALC269_AUTO)
12373                 spec->init_hook = alc269_auto_init;
12374 #ifdef CONFIG_SND_HDA_POWER_SAVE
12375         if (!spec->loopback.amplist)
12376                 spec->loopback.amplist = alc269_loopbacks;
12377 #endif
12378
12379         return 0;
12380 }
12381
12382 /*
12383  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
12384  */
12385
12386 /*
12387  * set the path ways for 2 channel output
12388  * need to set the codec line out and mic 1 pin widgets to inputs
12389  */
12390 static struct hda_verb alc861_threestack_ch2_init[] = {
12391         /* set pin widget 1Ah (line in) for input */
12392         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12393         /* set pin widget 18h (mic1/2) for input, for mic also enable
12394          * the vref
12395          */
12396         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12397
12398         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12399 #if 0
12400         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12401         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12402 #endif
12403         { } /* end */
12404 };
12405 /*
12406  * 6ch mode
12407  * need to set the codec line out and mic 1 pin widgets to outputs
12408  */
12409 static struct hda_verb alc861_threestack_ch6_init[] = {
12410         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12411         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12412         /* set pin widget 18h (mic1) for output (CLFE)*/
12413         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12414
12415         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12416         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12417
12418         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12419 #if 0
12420         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12421         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12422 #endif
12423         { } /* end */
12424 };
12425
12426 static struct hda_channel_mode alc861_threestack_modes[2] = {
12427         { 2, alc861_threestack_ch2_init },
12428         { 6, alc861_threestack_ch6_init },
12429 };
12430 /* Set mic1 as input and unmute the mixer */
12431 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
12432         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12433         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12434         { } /* end */
12435 };
12436 /* Set mic1 as output and mute mixer */
12437 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
12438         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12439         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12440         { } /* end */
12441 };
12442
12443 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
12444         { 2, alc861_uniwill_m31_ch2_init },
12445         { 4, alc861_uniwill_m31_ch4_init },
12446 };
12447
12448 /* Set mic1 and line-in as input and unmute the mixer */
12449 static struct hda_verb alc861_asus_ch2_init[] = {
12450         /* set pin widget 1Ah (line in) for input */
12451         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12452         /* set pin widget 18h (mic1/2) for input, for mic also enable
12453          * the vref
12454          */
12455         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12456
12457         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12458 #if 0
12459         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12460         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12461 #endif
12462         { } /* end */
12463 };
12464 /* Set mic1 nad line-in as output and mute mixer */
12465 static struct hda_verb alc861_asus_ch6_init[] = {
12466         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12467         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12468         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12469         /* set pin widget 18h (mic1) for output (CLFE)*/
12470         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12471         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12472         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12473         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12474
12475         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12476 #if 0
12477         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12478         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12479 #endif
12480         { } /* end */
12481 };
12482
12483 static struct hda_channel_mode alc861_asus_modes[2] = {
12484         { 2, alc861_asus_ch2_init },
12485         { 6, alc861_asus_ch6_init },
12486 };
12487
12488 /* patch-ALC861 */
12489
12490 static struct snd_kcontrol_new alc861_base_mixer[] = {
12491         /* output mixer control */
12492         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12493         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12494         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12495         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12496         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12497
12498         /*Input mixer control */
12499         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12500            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12501         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12502         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12503         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12504         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12505         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12506         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12507         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12508         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12509
12510         /* Capture mixer control */
12511         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12512         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12513         {
12514                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12515                 .name = "Capture Source",
12516                 .count = 1,
12517                 .info = alc_mux_enum_info,
12518                 .get = alc_mux_enum_get,
12519                 .put = alc_mux_enum_put,
12520         },
12521         { } /* end */
12522 };
12523
12524 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
12525         /* output mixer control */
12526         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12527         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12528         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12529         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12530         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12531
12532         /* Input mixer control */
12533         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12534            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12535         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12536         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12537         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12538         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12539         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12540         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12541         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12542         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12543
12544         /* Capture mixer control */
12545         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12546         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12547         {
12548                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12549                 .name = "Capture Source",
12550                 .count = 1,
12551                 .info = alc_mux_enum_info,
12552                 .get = alc_mux_enum_get,
12553                 .put = alc_mux_enum_put,
12554         },
12555         {
12556                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12557                 .name = "Channel Mode",
12558                 .info = alc_ch_mode_info,
12559                 .get = alc_ch_mode_get,
12560                 .put = alc_ch_mode_put,
12561                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
12562         },
12563         { } /* end */
12564 };
12565
12566 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
12567         /* output mixer control */
12568         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12569         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12570         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12571
12572         /*Capture mixer control */
12573         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12574         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12575         {
12576                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12577                 .name = "Capture Source",
12578                 .count = 1,
12579                 .info = alc_mux_enum_info,
12580                 .get = alc_mux_enum_get,
12581                 .put = alc_mux_enum_put,
12582         },
12583
12584         { } /* end */
12585 };
12586
12587 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
12588         /* output mixer control */
12589         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12590         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12591         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12592         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12593         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12594
12595         /* Input mixer control */
12596         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12597            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12598         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12599         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12600         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12601         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12602         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12603         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12604         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12605         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12606
12607         /* Capture mixer control */
12608         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12609         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12610         {
12611                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12612                 .name = "Capture Source",
12613                 .count = 1,
12614                 .info = alc_mux_enum_info,
12615                 .get = alc_mux_enum_get,
12616                 .put = alc_mux_enum_put,
12617         },
12618         {
12619                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12620                 .name = "Channel Mode",
12621                 .info = alc_ch_mode_info,
12622                 .get = alc_ch_mode_get,
12623                 .put = alc_ch_mode_put,
12624                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
12625         },
12626         { } /* end */
12627 };
12628
12629 static struct snd_kcontrol_new alc861_asus_mixer[] = {
12630         /* output mixer control */
12631         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12632         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12633         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12634         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12635         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12636
12637         /* Input mixer control */
12638         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12639         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12640         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12641         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12642         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12643         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12644         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12645         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12646         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12647         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
12648
12649         /* Capture mixer control */
12650         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12651         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12652         {
12653                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12654                 .name = "Capture Source",
12655                 .count = 1,
12656                 .info = alc_mux_enum_info,
12657                 .get = alc_mux_enum_get,
12658                 .put = alc_mux_enum_put,
12659         },
12660         {
12661                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12662                 .name = "Channel Mode",
12663                 .info = alc_ch_mode_info,
12664                 .get = alc_ch_mode_get,
12665                 .put = alc_ch_mode_put,
12666                 .private_value = ARRAY_SIZE(alc861_asus_modes),
12667         },
12668         { }
12669 };
12670
12671 /* additional mixer */
12672 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
12673         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12674         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12675         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
12676         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
12677         { }
12678 };
12679
12680 /*
12681  * generic initialization of ADC, input mixers and output mixers
12682  */
12683 static struct hda_verb alc861_base_init_verbs[] = {
12684         /*
12685          * Unmute ADC0 and set the default input to mic-in
12686          */
12687         /* port-A for surround (rear panel) */
12688         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12689         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
12690         /* port-B for mic-in (rear panel) with vref */
12691         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12692         /* port-C for line-in (rear panel) */
12693         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12694         /* port-D for Front */
12695         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12696         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12697         /* port-E for HP out (front panel) */
12698         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12699         /* route front PCM to HP */
12700         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12701         /* port-F for mic-in (front panel) with vref */
12702         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12703         /* port-G for CLFE (rear panel) */
12704         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12705         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12706         /* port-H for side (rear panel) */
12707         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12708         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
12709         /* CD-in */
12710         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12711         /* route front mic to ADC1*/
12712         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12713         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12714
12715         /* Unmute DAC0~3 & spdif out*/
12716         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12717         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12718         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12719         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12720         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12721
12722         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12723         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12724         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12725         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12726         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12727
12728         /* Unmute Stereo Mixer 15 */
12729         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12730         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12732         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12733
12734         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12735         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12736         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12737         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12738         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12739         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12740         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12741         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12742         /* hp used DAC 3 (Front) */
12743         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12744         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12745
12746         { }
12747 };
12748
12749 static struct hda_verb alc861_threestack_init_verbs[] = {
12750         /*
12751          * Unmute ADC0 and set the default input to mic-in
12752          */
12753         /* port-A for surround (rear panel) */
12754         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12755         /* port-B for mic-in (rear panel) with vref */
12756         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12757         /* port-C for line-in (rear panel) */
12758         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12759         /* port-D for Front */
12760         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12761         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12762         /* port-E for HP out (front panel) */
12763         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12764         /* route front PCM to HP */
12765         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12766         /* port-F for mic-in (front panel) with vref */
12767         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12768         /* port-G for CLFE (rear panel) */
12769         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12770         /* port-H for side (rear panel) */
12771         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12772         /* CD-in */
12773         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12774         /* route front mic to ADC1*/
12775         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12776         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12777         /* Unmute DAC0~3 & spdif out*/
12778         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12779         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12780         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12781         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12782         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12783
12784         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12785         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12786         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12787         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12788         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12789
12790         /* Unmute Stereo Mixer 15 */
12791         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12792         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12793         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12794         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12795
12796         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12797         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12798         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12799         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12800         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12801         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12802         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12803         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12804         /* hp used DAC 3 (Front) */
12805         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12806         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12807         { }
12808 };
12809
12810 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
12811         /*
12812          * Unmute ADC0 and set the default input to mic-in
12813          */
12814         /* port-A for surround (rear panel) */
12815         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12816         /* port-B for mic-in (rear panel) with vref */
12817         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12818         /* port-C for line-in (rear panel) */
12819         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12820         /* port-D for Front */
12821         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12822         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12823         /* port-E for HP out (front panel) */
12824         /* this has to be set to VREF80 */
12825         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12826         /* route front PCM to HP */
12827         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12828         /* port-F for mic-in (front panel) with vref */
12829         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12830         /* port-G for CLFE (rear panel) */
12831         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12832         /* port-H for side (rear panel) */
12833         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12834         /* CD-in */
12835         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12836         /* route front mic to ADC1*/
12837         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12838         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12839         /* Unmute DAC0~3 & spdif out*/
12840         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12841         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12842         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12843         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12844         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12845
12846         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12847         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12848         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12849         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12850         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12851
12852         /* Unmute Stereo Mixer 15 */
12853         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12855         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12856         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12857
12858         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12859         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12860         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12861         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12862         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12863         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12864         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12865         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12866         /* hp used DAC 3 (Front) */
12867         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12868         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12869         { }
12870 };
12871
12872 static struct hda_verb alc861_asus_init_verbs[] = {
12873         /*
12874          * Unmute ADC0 and set the default input to mic-in
12875          */
12876         /* port-A for surround (rear panel)
12877          * according to codec#0 this is the HP jack
12878          */
12879         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
12880         /* route front PCM to HP */
12881         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
12882         /* port-B for mic-in (rear panel) with vref */
12883         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12884         /* port-C for line-in (rear panel) */
12885         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12886         /* port-D for Front */
12887         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12888         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12889         /* port-E for HP out (front panel) */
12890         /* this has to be set to VREF80 */
12891         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12892         /* route front PCM to HP */
12893         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12894         /* port-F for mic-in (front panel) with vref */
12895         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12896         /* port-G for CLFE (rear panel) */
12897         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12898         /* port-H for side (rear panel) */
12899         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12900         /* CD-in */
12901         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12902         /* route front mic to ADC1*/
12903         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12904         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12905         /* Unmute DAC0~3 & spdif out*/
12906         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12907         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12908         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12909         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12910         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12911         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12912         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12913         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12914         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12915         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12916
12917         /* Unmute Stereo Mixer 15 */
12918         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12919         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12920         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12921         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12922
12923         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12924         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12925         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12926         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12927         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12928         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12929         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12930         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12931         /* hp used DAC 3 (Front) */
12932         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12933         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12934         { }
12935 };
12936
12937 /* additional init verbs for ASUS laptops */
12938 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
12939         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
12940         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
12941         { }
12942 };
12943
12944 /*
12945  * generic initialization of ADC, input mixers and output mixers
12946  */
12947 static struct hda_verb alc861_auto_init_verbs[] = {
12948         /*
12949          * Unmute ADC0 and set the default input to mic-in
12950          */
12951         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
12952         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12953
12954         /* Unmute DAC0~3 & spdif out*/
12955         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12956         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12957         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12958         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12959         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12960
12961         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12962         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12963         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12964         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12965         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12966
12967         /* Unmute Stereo Mixer 15 */
12968         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12969         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12970         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12971         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
12972
12973         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12974         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12975         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12976         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12977         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12978         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12979         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12980         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12981
12982         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12983         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12984         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12985         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12986         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12987         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12988         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12989         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12990
12991         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
12992
12993         { }
12994 };
12995
12996 static struct hda_verb alc861_toshiba_init_verbs[] = {
12997         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12998
12999         { }
13000 };
13001
13002 /* toggle speaker-output according to the hp-jack state */
13003 static void alc861_toshiba_automute(struct hda_codec *codec)
13004 {
13005         unsigned int present;
13006
13007         present = snd_hda_codec_read(codec, 0x0f, 0,
13008                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13009         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13010                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13011         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13012                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13013 }
13014
13015 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13016                                        unsigned int res)
13017 {
13018         if ((res >> 26) == ALC880_HP_EVENT)
13019                 alc861_toshiba_automute(codec);
13020 }
13021
13022 /* pcm configuration: identiacal with ALC880 */
13023 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13024 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13025 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13026 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13027
13028
13029 #define ALC861_DIGOUT_NID       0x07
13030
13031 static struct hda_channel_mode alc861_8ch_modes[1] = {
13032         { 8, NULL }
13033 };
13034
13035 static hda_nid_t alc861_dac_nids[4] = {
13036         /* front, surround, clfe, side */
13037         0x03, 0x06, 0x05, 0x04
13038 };
13039
13040 static hda_nid_t alc660_dac_nids[3] = {
13041         /* front, clfe, surround */
13042         0x03, 0x05, 0x06
13043 };
13044
13045 static hda_nid_t alc861_adc_nids[1] = {
13046         /* ADC0-2 */
13047         0x08,
13048 };
13049
13050 static struct hda_input_mux alc861_capture_source = {
13051         .num_items = 5,
13052         .items = {
13053                 { "Mic", 0x0 },
13054                 { "Front Mic", 0x3 },
13055                 { "Line", 0x1 },
13056                 { "CD", 0x4 },
13057                 { "Mixer", 0x5 },
13058         },
13059 };
13060
13061 /* fill in the dac_nids table from the parsed pin configuration */
13062 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13063                                      const struct auto_pin_cfg *cfg)
13064 {
13065         int i;
13066         hda_nid_t nid;
13067
13068         spec->multiout.dac_nids = spec->private_dac_nids;
13069         for (i = 0; i < cfg->line_outs; i++) {
13070                 nid = cfg->line_out_pins[i];
13071                 if (nid) {
13072                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13073                                 continue;
13074                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13075                 }
13076         }
13077         spec->multiout.num_dacs = cfg->line_outs;
13078         return 0;
13079 }
13080
13081 /* add playback controls from the parsed DAC table */
13082 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13083                                              const struct auto_pin_cfg *cfg)
13084 {
13085         char name[32];
13086         static const char *chname[4] = {
13087                 "Front", "Surround", NULL /*CLFE*/, "Side"
13088         };
13089         hda_nid_t nid;
13090         int i, idx, err;
13091
13092         for (i = 0; i < cfg->line_outs; i++) {
13093                 nid = spec->multiout.dac_nids[i];
13094                 if (!nid)
13095                         continue;
13096                 if (nid == 0x05) {
13097                         /* Center/LFE */
13098                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13099                                           "Center Playback Switch",
13100                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13101                                                               HDA_OUTPUT));
13102                         if (err < 0)
13103                                 return err;
13104                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13105                                           "LFE Playback Switch",
13106                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13107                                                               HDA_OUTPUT));
13108                         if (err < 0)
13109                                 return err;
13110                 } else {
13111                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13112                              idx++)
13113                                 if (nid == alc861_dac_nids[idx])
13114                                         break;
13115                         sprintf(name, "%s Playback Switch", chname[idx]);
13116                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13117                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13118                                                               HDA_OUTPUT));
13119                         if (err < 0)
13120                                 return err;
13121                 }
13122         }
13123         return 0;
13124 }
13125
13126 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13127 {
13128         int err;
13129         hda_nid_t nid;
13130
13131         if (!pin)
13132                 return 0;
13133
13134         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13135                 nid = 0x03;
13136                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13137                                   "Headphone Playback Switch",
13138                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13139                 if (err < 0)
13140                         return err;
13141                 spec->multiout.hp_nid = nid;
13142         }
13143         return 0;
13144 }
13145
13146 /* create playback/capture controls for input pins */
13147 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13148                                                 const struct auto_pin_cfg *cfg)
13149 {
13150         struct hda_input_mux *imux = &spec->private_imux;
13151         int i, err, idx, idx1;
13152
13153         for (i = 0; i < AUTO_PIN_LAST; i++) {
13154                 switch (cfg->input_pins[i]) {
13155                 case 0x0c:
13156                         idx1 = 1;
13157                         idx = 2;        /* Line In */
13158                         break;
13159                 case 0x0f:
13160                         idx1 = 2;
13161                         idx = 2;        /* Line In */
13162                         break;
13163                 case 0x0d:
13164                         idx1 = 0;
13165                         idx = 1;        /* Mic In */
13166                         break;
13167                 case 0x10:
13168                         idx1 = 3;
13169                         idx = 1;        /* Mic In */
13170                         break;
13171                 case 0x11:
13172                         idx1 = 4;
13173                         idx = 0;        /* CD */
13174                         break;
13175                 default:
13176                         continue;
13177                 }
13178
13179                 err = new_analog_input(spec, cfg->input_pins[i],
13180                                        auto_pin_cfg_labels[i], idx, 0x15);
13181                 if (err < 0)
13182                         return err;
13183
13184                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13185                 imux->items[imux->num_items].index = idx1;
13186                 imux->num_items++;
13187         }
13188         return 0;
13189 }
13190
13191 static struct snd_kcontrol_new alc861_capture_mixer[] = {
13192         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13193         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13194
13195         {
13196                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13197                 /* The multiple "Capture Source" controls confuse alsamixer
13198                  * So call somewhat different..
13199                  */
13200                 /* .name = "Capture Source", */
13201                 .name = "Input Source",
13202                 .count = 1,
13203                 .info = alc_mux_enum_info,
13204                 .get = alc_mux_enum_get,
13205                 .put = alc_mux_enum_put,
13206         },
13207         { } /* end */
13208 };
13209
13210 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13211                                               hda_nid_t nid,
13212                                               int pin_type, int dac_idx)
13213 {
13214         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13215                             pin_type);
13216         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13217                             AMP_OUT_UNMUTE);
13218 }
13219
13220 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13221 {
13222         struct alc_spec *spec = codec->spec;
13223         int i;
13224
13225         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13226         for (i = 0; i < spec->autocfg.line_outs; i++) {
13227                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13228                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13229                 if (nid)
13230                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13231                                                           spec->multiout.dac_nids[i]);
13232         }
13233 }
13234
13235 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13236 {
13237         struct alc_spec *spec = codec->spec;
13238         hda_nid_t pin;
13239
13240         pin = spec->autocfg.hp_pins[0];
13241         if (pin) /* connect to front */
13242                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13243                                                   spec->multiout.dac_nids[0]);
13244         pin = spec->autocfg.speaker_pins[0];
13245         if (pin)
13246                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13247 }
13248
13249 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13250 {
13251         struct alc_spec *spec = codec->spec;
13252         int i;
13253
13254         for (i = 0; i < AUTO_PIN_LAST; i++) {
13255                 hda_nid_t nid = spec->autocfg.input_pins[i];
13256                 if (nid >= 0x0c && nid <= 0x11) {
13257                         snd_hda_codec_write(codec, nid, 0,
13258                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
13259                                             i <= AUTO_PIN_FRONT_MIC ?
13260                                             PIN_VREF80 : PIN_IN);
13261                 }
13262         }
13263 }
13264
13265 /* parse the BIOS configuration and set up the alc_spec */
13266 /* return 1 if successful, 0 if the proper config is not found,
13267  * or a negative error code
13268  */
13269 static int alc861_parse_auto_config(struct hda_codec *codec)
13270 {
13271         struct alc_spec *spec = codec->spec;
13272         int err;
13273         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13274
13275         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13276                                            alc861_ignore);
13277         if (err < 0)
13278                 return err;
13279         if (!spec->autocfg.line_outs)
13280                 return 0; /* can't find valid BIOS pin config */
13281
13282         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13283         if (err < 0)
13284                 return err;
13285         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13286         if (err < 0)
13287                 return err;
13288         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13289         if (err < 0)
13290                 return err;
13291         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13292         if (err < 0)
13293                 return err;
13294
13295         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13296
13297         if (spec->autocfg.dig_out_pin)
13298                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13299
13300         if (spec->kctl_alloc)
13301                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13302
13303         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
13304
13305         spec->num_mux_defs = 1;
13306         spec->input_mux = &spec->private_imux;
13307
13308         spec->adc_nids = alc861_adc_nids;
13309         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13310         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
13311         spec->num_mixers++;
13312
13313         return 1;
13314 }
13315
13316 /* additional initialization for auto-configuration model */
13317 static void alc861_auto_init(struct hda_codec *codec)
13318 {
13319         struct alc_spec *spec = codec->spec;
13320         alc861_auto_init_multi_out(codec);
13321         alc861_auto_init_hp_out(codec);
13322         alc861_auto_init_analog_input(codec);
13323         if (spec->unsol_event)
13324                 alc_inithook(codec);
13325 }
13326
13327 #ifdef CONFIG_SND_HDA_POWER_SAVE
13328 static struct hda_amp_list alc861_loopbacks[] = {
13329         { 0x15, HDA_INPUT, 0 },
13330         { 0x15, HDA_INPUT, 1 },
13331         { 0x15, HDA_INPUT, 2 },
13332         { 0x15, HDA_INPUT, 3 },
13333         { } /* end */
13334 };
13335 #endif
13336
13337
13338 /*
13339  * configuration and preset
13340  */
13341 static const char *alc861_models[ALC861_MODEL_LAST] = {
13342         [ALC861_3ST]            = "3stack",
13343         [ALC660_3ST]            = "3stack-660",
13344         [ALC861_3ST_DIG]        = "3stack-dig",
13345         [ALC861_6ST_DIG]        = "6stack-dig",
13346         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13347         [ALC861_TOSHIBA]        = "toshiba",
13348         [ALC861_ASUS]           = "asus",
13349         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13350         [ALC861_AUTO]           = "auto",
13351 };
13352
13353 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13354         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13355         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13356         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13357         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13358         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13359         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13360         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13361         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13362          *        Any other models that need this preset?
13363          */
13364         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13365         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13366         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13367         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13368         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13369         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13370         /* FIXME: the below seems conflict */
13371         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13372         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13373         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13374         {}
13375 };
13376
13377 static struct alc_config_preset alc861_presets[] = {
13378         [ALC861_3ST] = {
13379                 .mixers = { alc861_3ST_mixer },
13380                 .init_verbs = { alc861_threestack_init_verbs },
13381                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13382                 .dac_nids = alc861_dac_nids,
13383                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13384                 .channel_mode = alc861_threestack_modes,
13385                 .need_dac_fix = 1,
13386                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13387                 .adc_nids = alc861_adc_nids,
13388                 .input_mux = &alc861_capture_source,
13389         },
13390         [ALC861_3ST_DIG] = {
13391                 .mixers = { alc861_base_mixer },
13392                 .init_verbs = { alc861_threestack_init_verbs },
13393                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13394                 .dac_nids = alc861_dac_nids,
13395                 .dig_out_nid = ALC861_DIGOUT_NID,
13396                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13397                 .channel_mode = alc861_threestack_modes,
13398                 .need_dac_fix = 1,
13399                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13400                 .adc_nids = alc861_adc_nids,
13401                 .input_mux = &alc861_capture_source,
13402         },
13403         [ALC861_6ST_DIG] = {
13404                 .mixers = { alc861_base_mixer },
13405                 .init_verbs = { alc861_base_init_verbs },
13406                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13407                 .dac_nids = alc861_dac_nids,
13408                 .dig_out_nid = ALC861_DIGOUT_NID,
13409                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13410                 .channel_mode = alc861_8ch_modes,
13411                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13412                 .adc_nids = alc861_adc_nids,
13413                 .input_mux = &alc861_capture_source,
13414         },
13415         [ALC660_3ST] = {
13416                 .mixers = { alc861_3ST_mixer },
13417                 .init_verbs = { alc861_threestack_init_verbs },
13418                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13419                 .dac_nids = alc660_dac_nids,
13420                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13421                 .channel_mode = alc861_threestack_modes,
13422                 .need_dac_fix = 1,
13423                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13424                 .adc_nids = alc861_adc_nids,
13425                 .input_mux = &alc861_capture_source,
13426         },
13427         [ALC861_UNIWILL_M31] = {
13428                 .mixers = { alc861_uniwill_m31_mixer },
13429                 .init_verbs = { alc861_uniwill_m31_init_verbs },
13430                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13431                 .dac_nids = alc861_dac_nids,
13432                 .dig_out_nid = ALC861_DIGOUT_NID,
13433                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13434                 .channel_mode = alc861_uniwill_m31_modes,
13435                 .need_dac_fix = 1,
13436                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13437                 .adc_nids = alc861_adc_nids,
13438                 .input_mux = &alc861_capture_source,
13439         },
13440         [ALC861_TOSHIBA] = {
13441                 .mixers = { alc861_toshiba_mixer },
13442                 .init_verbs = { alc861_base_init_verbs,
13443                                 alc861_toshiba_init_verbs },
13444                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13445                 .dac_nids = alc861_dac_nids,
13446                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13447                 .channel_mode = alc883_3ST_2ch_modes,
13448                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13449                 .adc_nids = alc861_adc_nids,
13450                 .input_mux = &alc861_capture_source,
13451                 .unsol_event = alc861_toshiba_unsol_event,
13452                 .init_hook = alc861_toshiba_automute,
13453         },
13454         [ALC861_ASUS] = {
13455                 .mixers = { alc861_asus_mixer },
13456                 .init_verbs = { alc861_asus_init_verbs },
13457                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13458                 .dac_nids = alc861_dac_nids,
13459                 .dig_out_nid = ALC861_DIGOUT_NID,
13460                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13461                 .channel_mode = alc861_asus_modes,
13462                 .need_dac_fix = 1,
13463                 .hp_nid = 0x06,
13464                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13465                 .adc_nids = alc861_adc_nids,
13466                 .input_mux = &alc861_capture_source,
13467         },
13468         [ALC861_ASUS_LAPTOP] = {
13469                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13470                 .init_verbs = { alc861_asus_init_verbs,
13471                                 alc861_asus_laptop_init_verbs },
13472                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13473                 .dac_nids = alc861_dac_nids,
13474                 .dig_out_nid = ALC861_DIGOUT_NID,
13475                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13476                 .channel_mode = alc883_3ST_2ch_modes,
13477                 .need_dac_fix = 1,
13478                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13479                 .adc_nids = alc861_adc_nids,
13480                 .input_mux = &alc861_capture_source,
13481         },
13482 };
13483
13484
13485 static int patch_alc861(struct hda_codec *codec)
13486 {
13487         struct alc_spec *spec;
13488         int board_config;
13489         int err;
13490
13491         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13492         if (spec == NULL)
13493                 return -ENOMEM;
13494
13495         codec->spec = spec;
13496
13497         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
13498                                                   alc861_models,
13499                                                   alc861_cfg_tbl);
13500
13501         if (board_config < 0) {
13502                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
13503                        "trying auto-probe from BIOS...\n");
13504                 board_config = ALC861_AUTO;
13505         }
13506
13507         if (board_config == ALC861_AUTO) {
13508                 /* automatic parse from the BIOS config */
13509                 err = alc861_parse_auto_config(codec);
13510                 if (err < 0) {
13511                         alc_free(codec);
13512                         return err;
13513                 } else if (!err) {
13514                         printk(KERN_INFO
13515                                "hda_codec: Cannot set up configuration "
13516                                "from BIOS.  Using base mode...\n");
13517                    board_config = ALC861_3ST_DIG;
13518                 }
13519         }
13520
13521         if (board_config != ALC861_AUTO)
13522                 setup_preset(spec, &alc861_presets[board_config]);
13523
13524         spec->stream_name_analog = "ALC861 Analog";
13525         spec->stream_analog_playback = &alc861_pcm_analog_playback;
13526         spec->stream_analog_capture = &alc861_pcm_analog_capture;
13527
13528         spec->stream_name_digital = "ALC861 Digital";
13529         spec->stream_digital_playback = &alc861_pcm_digital_playback;
13530         spec->stream_digital_capture = &alc861_pcm_digital_capture;
13531
13532         spec->vmaster_nid = 0x03;
13533
13534         codec->patch_ops = alc_patch_ops;
13535         if (board_config == ALC861_AUTO)
13536                 spec->init_hook = alc861_auto_init;
13537 #ifdef CONFIG_SND_HDA_POWER_SAVE
13538         if (!spec->loopback.amplist)
13539                 spec->loopback.amplist = alc861_loopbacks;
13540 #endif
13541
13542         return 0;
13543 }
13544
13545 /*
13546  * ALC861-VD support
13547  *
13548  * Based on ALC882
13549  *
13550  * In addition, an independent DAC
13551  */
13552 #define ALC861VD_DIGOUT_NID     0x06
13553
13554 static hda_nid_t alc861vd_dac_nids[4] = {
13555         /* front, surr, clfe, side surr */
13556         0x02, 0x03, 0x04, 0x05
13557 };
13558
13559 /* dac_nids for ALC660vd are in a different order - according to
13560  * Realtek's driver.
13561  * This should probably tesult in a different mixer for 6stack models
13562  * of ALC660vd codecs, but for now there is only 3stack mixer
13563  * - and it is the same as in 861vd.
13564  * adc_nids in ALC660vd are (is) the same as in 861vd
13565  */
13566 static hda_nid_t alc660vd_dac_nids[3] = {
13567         /* front, rear, clfe, rear_surr */
13568         0x02, 0x04, 0x03
13569 };
13570
13571 static hda_nid_t alc861vd_adc_nids[1] = {
13572         /* ADC0 */
13573         0x09,
13574 };
13575
13576 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
13577
13578 /* input MUX */
13579 /* FIXME: should be a matrix-type input source selection */
13580 static struct hda_input_mux alc861vd_capture_source = {
13581         .num_items = 4,
13582         .items = {
13583                 { "Mic", 0x0 },
13584                 { "Front Mic", 0x1 },
13585                 { "Line", 0x2 },
13586                 { "CD", 0x4 },
13587         },
13588 };
13589
13590 static struct hda_input_mux alc861vd_dallas_capture_source = {
13591         .num_items = 2,
13592         .items = {
13593                 { "Ext Mic", 0x0 },
13594                 { "Int Mic", 0x1 },
13595         },
13596 };
13597
13598 static struct hda_input_mux alc861vd_hp_capture_source = {
13599         .num_items = 2,
13600         .items = {
13601                 { "Front Mic", 0x0 },
13602                 { "ATAPI Mic", 0x1 },
13603         },
13604 };
13605
13606 #define alc861vd_mux_enum_info alc_mux_enum_info
13607 #define alc861vd_mux_enum_get alc_mux_enum_get
13608 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
13609 #define alc861vd_mux_enum_put alc882_mux_enum_put
13610
13611 /*
13612  * 2ch mode
13613  */
13614 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
13615         { 2, NULL }
13616 };
13617
13618 /*
13619  * 6ch mode
13620  */
13621 static struct hda_verb alc861vd_6stack_ch6_init[] = {
13622         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13623         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13624         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13625         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13626         { } /* end */
13627 };
13628
13629 /*
13630  * 8ch mode
13631  */
13632 static struct hda_verb alc861vd_6stack_ch8_init[] = {
13633         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13634         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13635         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13636         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13637         { } /* end */
13638 };
13639
13640 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
13641         { 6, alc861vd_6stack_ch6_init },
13642         { 8, alc861vd_6stack_ch8_init },
13643 };
13644
13645 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
13646         {
13647                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13648                 .name = "Channel Mode",
13649                 .info = alc_ch_mode_info,
13650                 .get = alc_ch_mode_get,
13651                 .put = alc_ch_mode_put,
13652         },
13653         { } /* end */
13654 };
13655
13656 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
13657         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13658         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13659
13660         {
13661                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13662                 /* The multiple "Capture Source" controls confuse alsamixer
13663                  * So call somewhat different..
13664                  */
13665                 /* .name = "Capture Source", */
13666                 .name = "Input Source",
13667                 .count = 1,
13668                 .info = alc861vd_mux_enum_info,
13669                 .get = alc861vd_mux_enum_get,
13670                 .put = alc861vd_mux_enum_put,
13671         },
13672         { } /* end */
13673 };
13674
13675 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13676  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13677  */
13678 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
13679         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13680         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13681
13682         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13683         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
13684
13685         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
13686                                 HDA_OUTPUT),
13687         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
13688                                 HDA_OUTPUT),
13689         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13690         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
13691
13692         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
13693         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
13694
13695         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13696
13697         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13698         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13699         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13700
13701         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13702         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13703         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13704
13705         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13706         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13707
13708         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13709         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13710
13711         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13712         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13713
13714         { } /* end */
13715 };
13716
13717 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
13718         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13719         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13720
13721         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13722
13723         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13724         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13725         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13726
13727         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13728         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13729         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13730
13731         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13732         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13733
13734         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13735         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13736
13737         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13738         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13739
13740         { } /* end */
13741 };
13742
13743 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
13744         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13745         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
13746         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13747
13748         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13749
13750         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13751         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13752         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13753
13754         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13755         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13756         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13757
13758         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13759         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13760
13761         { } /* end */
13762 };
13763
13764 /* Pin assignment: Speaker=0x14, HP = 0x15,
13765  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
13766  */
13767 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
13768         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13769         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
13770         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13771         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13772         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13773         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13774         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13775         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13776         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13777         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13778         HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
13779         HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
13780         { } /* end */
13781 };
13782
13783 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
13784  *                 Front Mic=0x18, ATAPI Mic = 0x19,
13785  */
13786 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
13787         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13788         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13789         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13790         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13791         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13792         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13793         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13794         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13795
13796         { } /* end */
13797 };
13798
13799 /*
13800  * generic initialization of ADC, input mixers and output mixers
13801  */
13802 static struct hda_verb alc861vd_volume_init_verbs[] = {
13803         /*
13804          * Unmute ADC0 and set the default input to mic-in
13805          */
13806         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13807         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13808
13809         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
13810          * the analog-loopback mixer widget
13811          */
13812         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13813         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13814         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13815         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13816         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13817         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13818
13819         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
13820         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13821         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13822         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13823         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13824
13825         /*
13826          * Set up output mixers (0x02 - 0x05)
13827          */
13828         /* set vol=0 to output mixers */
13829         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13830         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13831         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13832         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13833
13834         /* set up input amps for analog loopback */
13835         /* Amp Indices: DAC = 0, mixer = 1 */
13836         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13837         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13838         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13839         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13840         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13841         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13842         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13843         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13844
13845         { }
13846 };
13847
13848 /*
13849  * 3-stack pin configuration:
13850  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
13851  */
13852 static struct hda_verb alc861vd_3stack_init_verbs[] = {
13853         /*
13854          * Set pin mode and muting
13855          */
13856         /* set front pin widgets 0x14 for output */
13857         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13858         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13859         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13860
13861         /* Mic (rear) pin: input vref at 80% */
13862         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13863         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13864         /* Front Mic pin: input vref at 80% */
13865         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13866         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13867         /* Line In pin: input */
13868         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13869         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13870         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13871         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13872         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13873         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13874         /* CD pin widget for input */
13875         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13876
13877         { }
13878 };
13879
13880 /*
13881  * 6-stack pin configuration:
13882  */
13883 static struct hda_verb alc861vd_6stack_init_verbs[] = {
13884         /*
13885          * Set pin mode and muting
13886          */
13887         /* set front pin widgets 0x14 for output */
13888         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13889         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13890         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13891
13892         /* Rear Pin: output 1 (0x0d) */
13893         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13894         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13895         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13896         /* CLFE Pin: output 2 (0x0e) */
13897         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13898         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13899         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
13900         /* Side Pin: output 3 (0x0f) */
13901         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13902         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13903         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
13904
13905         /* Mic (rear) pin: input vref at 80% */
13906         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13907         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13908         /* Front Mic pin: input vref at 80% */
13909         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13910         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13911         /* Line In pin: input */
13912         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13913         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13914         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13915         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13916         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13917         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13918         /* CD pin widget for input */
13919         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13920
13921         { }
13922 };
13923
13924 static struct hda_verb alc861vd_eapd_verbs[] = {
13925         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13926         { }
13927 };
13928
13929 static struct hda_verb alc660vd_eapd_verbs[] = {
13930         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13931         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13932         { }
13933 };
13934
13935 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
13936         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13937         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13938         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
13939         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13940         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13941         {}
13942 };
13943
13944 /* toggle speaker-output according to the hp-jack state */
13945 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
13946 {
13947         unsigned int present;
13948         unsigned char bits;
13949
13950         present = snd_hda_codec_read(codec, 0x1b, 0,
13951                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13952         bits = present ? HDA_AMP_MUTE : 0;
13953         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
13954                                  HDA_AMP_MUTE, bits);
13955 }
13956
13957 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
13958 {
13959         unsigned int present;
13960         unsigned char bits;
13961
13962         present = snd_hda_codec_read(codec, 0x18, 0,
13963                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13964         bits = present ? HDA_AMP_MUTE : 0;
13965         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
13966                                  HDA_AMP_MUTE, bits);
13967 }
13968
13969 static void alc861vd_lenovo_automute(struct hda_codec *codec)
13970 {
13971         alc861vd_lenovo_hp_automute(codec);
13972         alc861vd_lenovo_mic_automute(codec);
13973 }
13974
13975 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
13976                                         unsigned int res)
13977 {
13978         switch (res >> 26) {
13979         case ALC880_HP_EVENT:
13980                 alc861vd_lenovo_hp_automute(codec);
13981                 break;
13982         case ALC880_MIC_EVENT:
13983                 alc861vd_lenovo_mic_automute(codec);
13984                 break;
13985         }
13986 }
13987
13988 static struct hda_verb alc861vd_dallas_verbs[] = {
13989         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13990         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13991         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13992         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13993
13994         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13995         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13996         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13997         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13998         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13999         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14000         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14001         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14002
14003         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14004         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14005         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14006         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14007         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14008         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14009         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14010         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14011
14012         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14013         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14014         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14015         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14016         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14017         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14018         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14019         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14020
14021         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14022         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14023         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14024         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14025
14026         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14027         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14028         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14029
14030         { } /* end */
14031 };
14032
14033 /* toggle speaker-output according to the hp-jack state */
14034 static void alc861vd_dallas_automute(struct hda_codec *codec)
14035 {
14036         unsigned int present;
14037
14038         present = snd_hda_codec_read(codec, 0x15, 0,
14039                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14040         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14041                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14042 }
14043
14044 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14045 {
14046         if ((res >> 26) == ALC880_HP_EVENT)
14047                 alc861vd_dallas_automute(codec);
14048 }
14049
14050 #ifdef CONFIG_SND_HDA_POWER_SAVE
14051 #define alc861vd_loopbacks      alc880_loopbacks
14052 #endif
14053
14054 /* pcm configuration: identiacal with ALC880 */
14055 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14056 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14057 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14058 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14059
14060 /*
14061  * configuration and preset
14062  */
14063 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14064         [ALC660VD_3ST]          = "3stack-660",
14065         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14066         [ALC861VD_3ST]          = "3stack",
14067         [ALC861VD_3ST_DIG]      = "3stack-digout",
14068         [ALC861VD_6ST_DIG]      = "6stack-digout",
14069         [ALC861VD_LENOVO]       = "lenovo",
14070         [ALC861VD_DALLAS]       = "dallas",
14071         [ALC861VD_HP]           = "hp",
14072         [ALC861VD_AUTO]         = "auto",
14073 };
14074
14075 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14076         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14077         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14078         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14079         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14080         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
14081         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14082         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14083         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14084         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14085         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14086         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14087         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14088         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14089         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
14090         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
14091         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
14092         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14093         {}
14094 };
14095
14096 static struct alc_config_preset alc861vd_presets[] = {
14097         [ALC660VD_3ST] = {
14098                 .mixers = { alc861vd_3st_mixer },
14099                 .init_verbs = { alc861vd_volume_init_verbs,
14100                                  alc861vd_3stack_init_verbs },
14101                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14102                 .dac_nids = alc660vd_dac_nids,
14103                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14104                 .channel_mode = alc861vd_3stack_2ch_modes,
14105                 .input_mux = &alc861vd_capture_source,
14106         },
14107         [ALC660VD_3ST_DIG] = {
14108                 .mixers = { alc861vd_3st_mixer },
14109                 .init_verbs = { alc861vd_volume_init_verbs,
14110                                  alc861vd_3stack_init_verbs },
14111                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14112                 .dac_nids = alc660vd_dac_nids,
14113                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14114                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14115                 .channel_mode = alc861vd_3stack_2ch_modes,
14116                 .input_mux = &alc861vd_capture_source,
14117         },
14118         [ALC861VD_3ST] = {
14119                 .mixers = { alc861vd_3st_mixer },
14120                 .init_verbs = { alc861vd_volume_init_verbs,
14121                                  alc861vd_3stack_init_verbs },
14122                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14123                 .dac_nids = alc861vd_dac_nids,
14124                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14125                 .channel_mode = alc861vd_3stack_2ch_modes,
14126                 .input_mux = &alc861vd_capture_source,
14127         },
14128         [ALC861VD_3ST_DIG] = {
14129                 .mixers = { alc861vd_3st_mixer },
14130                 .init_verbs = { alc861vd_volume_init_verbs,
14131                                  alc861vd_3stack_init_verbs },
14132                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14133                 .dac_nids = alc861vd_dac_nids,
14134                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14135                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14136                 .channel_mode = alc861vd_3stack_2ch_modes,
14137                 .input_mux = &alc861vd_capture_source,
14138         },
14139         [ALC861VD_6ST_DIG] = {
14140                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14141                 .init_verbs = { alc861vd_volume_init_verbs,
14142                                 alc861vd_6stack_init_verbs },
14143                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14144                 .dac_nids = alc861vd_dac_nids,
14145                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14146                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14147                 .channel_mode = alc861vd_6stack_modes,
14148                 .input_mux = &alc861vd_capture_source,
14149         },
14150         [ALC861VD_LENOVO] = {
14151                 .mixers = { alc861vd_lenovo_mixer },
14152                 .init_verbs = { alc861vd_volume_init_verbs,
14153                                 alc861vd_3stack_init_verbs,
14154                                 alc861vd_eapd_verbs,
14155                                 alc861vd_lenovo_unsol_verbs },
14156                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14157                 .dac_nids = alc660vd_dac_nids,
14158                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14159                 .channel_mode = alc861vd_3stack_2ch_modes,
14160                 .input_mux = &alc861vd_capture_source,
14161                 .unsol_event = alc861vd_lenovo_unsol_event,
14162                 .init_hook = alc861vd_lenovo_automute,
14163         },
14164         [ALC861VD_DALLAS] = {
14165                 .mixers = { alc861vd_dallas_mixer },
14166                 .init_verbs = { alc861vd_dallas_verbs },
14167                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14168                 .dac_nids = alc861vd_dac_nids,
14169                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14170                 .channel_mode = alc861vd_3stack_2ch_modes,
14171                 .input_mux = &alc861vd_dallas_capture_source,
14172                 .unsol_event = alc861vd_dallas_unsol_event,
14173                 .init_hook = alc861vd_dallas_automute,
14174         },
14175         [ALC861VD_HP] = {
14176                 .mixers = { alc861vd_hp_mixer },
14177                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14178                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14179                 .dac_nids = alc861vd_dac_nids,
14180                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14181                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14182                 .channel_mode = alc861vd_3stack_2ch_modes,
14183                 .input_mux = &alc861vd_hp_capture_source,
14184                 .unsol_event = alc861vd_dallas_unsol_event,
14185                 .init_hook = alc861vd_dallas_automute,
14186         },
14187 };
14188
14189 /*
14190  * BIOS auto configuration
14191  */
14192 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14193                                 hda_nid_t nid, int pin_type, int dac_idx)
14194 {
14195         alc_set_pin_output(codec, nid, pin_type);
14196 }
14197
14198 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14199 {
14200         struct alc_spec *spec = codec->spec;
14201         int i;
14202
14203         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14204         for (i = 0; i <= HDA_SIDE; i++) {
14205                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14206                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14207                 if (nid)
14208                         alc861vd_auto_set_output_and_unmute(codec, nid,
14209                                                             pin_type, i);
14210         }
14211 }
14212
14213
14214 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14215 {
14216         struct alc_spec *spec = codec->spec;
14217         hda_nid_t pin;
14218
14219         pin = spec->autocfg.hp_pins[0];
14220         if (pin) /* connect to front and  use dac 0 */
14221                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14222         pin = spec->autocfg.speaker_pins[0];
14223         if (pin)
14224                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14225 }
14226
14227 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14228 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14229
14230 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14231 {
14232         struct alc_spec *spec = codec->spec;
14233         int i;
14234
14235         for (i = 0; i < AUTO_PIN_LAST; i++) {
14236                 hda_nid_t nid = spec->autocfg.input_pins[i];
14237                 if (alc861vd_is_input_pin(nid)) {
14238                         snd_hda_codec_write(codec, nid, 0,
14239                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
14240                                         i <= AUTO_PIN_FRONT_MIC ?
14241                                                         PIN_VREF80 : PIN_IN);
14242                         if (nid != ALC861VD_PIN_CD_NID)
14243                                 snd_hda_codec_write(codec, nid, 0,
14244                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14245                                                 AMP_OUT_MUTE);
14246                 }
14247         }
14248 }
14249
14250 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14251
14252 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14253 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14254
14255 /* add playback controls from the parsed DAC table */
14256 /* Based on ALC880 version. But ALC861VD has separate,
14257  * different NIDs for mute/unmute switch and volume control */
14258 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14259                                              const struct auto_pin_cfg *cfg)
14260 {
14261         char name[32];
14262         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14263         hda_nid_t nid_v, nid_s;
14264         int i, err;
14265
14266         for (i = 0; i < cfg->line_outs; i++) {
14267                 if (!spec->multiout.dac_nids[i])
14268                         continue;
14269                 nid_v = alc861vd_idx_to_mixer_vol(
14270                                 alc880_dac_to_idx(
14271                                         spec->multiout.dac_nids[i]));
14272                 nid_s = alc861vd_idx_to_mixer_switch(
14273                                 alc880_dac_to_idx(
14274                                         spec->multiout.dac_nids[i]));
14275
14276                 if (i == 2) {
14277                         /* Center/LFE */
14278                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14279                                           "Center Playback Volume",
14280                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14281                                                               HDA_OUTPUT));
14282                         if (err < 0)
14283                                 return err;
14284                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14285                                           "LFE Playback Volume",
14286                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14287                                                               HDA_OUTPUT));
14288                         if (err < 0)
14289                                 return err;
14290                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14291                                           "Center Playback Switch",
14292                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14293                                                               HDA_INPUT));
14294                         if (err < 0)
14295                                 return err;
14296                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14297                                           "LFE Playback Switch",
14298                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14299                                                               HDA_INPUT));
14300                         if (err < 0)
14301                                 return err;
14302                 } else {
14303                         sprintf(name, "%s Playback Volume", chname[i]);
14304                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14305                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14306                                                               HDA_OUTPUT));
14307                         if (err < 0)
14308                                 return err;
14309                         sprintf(name, "%s Playback Switch", chname[i]);
14310                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14311                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14312                                                               HDA_INPUT));
14313                         if (err < 0)
14314                                 return err;
14315                 }
14316         }
14317         return 0;
14318 }
14319
14320 /* add playback controls for speaker and HP outputs */
14321 /* Based on ALC880 version. But ALC861VD has separate,
14322  * different NIDs for mute/unmute switch and volume control */
14323 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14324                                         hda_nid_t pin, const char *pfx)
14325 {
14326         hda_nid_t nid_v, nid_s;
14327         int err;
14328         char name[32];
14329
14330         if (!pin)
14331                 return 0;
14332
14333         if (alc880_is_fixed_pin(pin)) {
14334                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14335                 /* specify the DAC as the extra output */
14336                 if (!spec->multiout.hp_nid)
14337                         spec->multiout.hp_nid = nid_v;
14338                 else
14339                         spec->multiout.extra_out_nid[0] = nid_v;
14340                 /* control HP volume/switch on the output mixer amp */
14341                 nid_v = alc861vd_idx_to_mixer_vol(
14342                                 alc880_fixed_pin_idx(pin));
14343                 nid_s = alc861vd_idx_to_mixer_switch(
14344                                 alc880_fixed_pin_idx(pin));
14345
14346                 sprintf(name, "%s Playback Volume", pfx);
14347                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14348                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14349                 if (err < 0)
14350                         return err;
14351                 sprintf(name, "%s Playback Switch", pfx);
14352                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14353                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14354                 if (err < 0)
14355                         return err;
14356         } else if (alc880_is_multi_pin(pin)) {
14357                 /* set manual connection */
14358                 /* we have only a switch on HP-out PIN */
14359                 sprintf(name, "%s Playback Switch", pfx);
14360                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14361                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14362                 if (err < 0)
14363                         return err;
14364         }
14365         return 0;
14366 }
14367
14368 /* parse the BIOS configuration and set up the alc_spec
14369  * return 1 if successful, 0 if the proper config is not found,
14370  * or a negative error code
14371  * Based on ALC880 version - had to change it to override
14372  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14373 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14374 {
14375         struct alc_spec *spec = codec->spec;
14376         int err;
14377         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14378
14379         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14380                                            alc861vd_ignore);
14381         if (err < 0)
14382                 return err;
14383         if (!spec->autocfg.line_outs)
14384                 return 0; /* can't find valid BIOS pin config */
14385
14386         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14387         if (err < 0)
14388                 return err;
14389         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14390         if (err < 0)
14391                 return err;
14392         err = alc861vd_auto_create_extra_out(spec,
14393                                              spec->autocfg.speaker_pins[0],
14394                                              "Speaker");
14395         if (err < 0)
14396                 return err;
14397         err = alc861vd_auto_create_extra_out(spec,
14398                                              spec->autocfg.hp_pins[0],
14399                                              "Headphone");
14400         if (err < 0)
14401                 return err;
14402         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14403         if (err < 0)
14404                 return err;
14405
14406         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14407
14408         if (spec->autocfg.dig_out_pin)
14409                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14410
14411         if (spec->kctl_alloc)
14412                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14413
14414         spec->init_verbs[spec->num_init_verbs++]
14415                 = alc861vd_volume_init_verbs;
14416
14417         spec->num_mux_defs = 1;
14418         spec->input_mux = &spec->private_imux;
14419
14420         err = alc_auto_add_mic_boost(codec);
14421         if (err < 0)
14422                 return err;
14423
14424         return 1;
14425 }
14426
14427 /* additional initialization for auto-configuration model */
14428 static void alc861vd_auto_init(struct hda_codec *codec)
14429 {
14430         struct alc_spec *spec = codec->spec;
14431         alc861vd_auto_init_multi_out(codec);
14432         alc861vd_auto_init_hp_out(codec);
14433         alc861vd_auto_init_analog_input(codec);
14434         alc861vd_auto_init_input_src(codec);
14435         if (spec->unsol_event)
14436                 alc_inithook(codec);
14437 }
14438
14439 static int patch_alc861vd(struct hda_codec *codec)
14440 {
14441         struct alc_spec *spec;
14442         int err, board_config;
14443
14444         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14445         if (spec == NULL)
14446                 return -ENOMEM;
14447
14448         codec->spec = spec;
14449
14450         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14451                                                   alc861vd_models,
14452                                                   alc861vd_cfg_tbl);
14453
14454         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14455                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
14456                         "ALC861VD, trying auto-probe from BIOS...\n");
14457                 board_config = ALC861VD_AUTO;
14458         }
14459
14460         if (board_config == ALC861VD_AUTO) {
14461                 /* automatic parse from the BIOS config */
14462                 err = alc861vd_parse_auto_config(codec);
14463                 if (err < 0) {
14464                         alc_free(codec);
14465                         return err;
14466                 } else if (!err) {
14467                         printk(KERN_INFO
14468                                "hda_codec: Cannot set up configuration "
14469                                "from BIOS.  Using base mode...\n");
14470                         board_config = ALC861VD_3ST;
14471                 }
14472         }
14473
14474         if (board_config != ALC861VD_AUTO)
14475                 setup_preset(spec, &alc861vd_presets[board_config]);
14476
14477         if (codec->vendor_id == 0x10ec0660) {
14478                 spec->stream_name_analog = "ALC660-VD Analog";
14479                 spec->stream_name_digital = "ALC660-VD Digital";
14480                 /* always turn on EAPD */
14481                 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
14482         } else {
14483                 spec->stream_name_analog = "ALC861VD Analog";
14484                 spec->stream_name_digital = "ALC861VD Digital";
14485         }
14486
14487         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14488         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14489
14490         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14491         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14492
14493         spec->adc_nids = alc861vd_adc_nids;
14494         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14495         spec->capsrc_nids = alc861vd_capsrc_nids;
14496
14497         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
14498         spec->num_mixers++;
14499
14500         spec->vmaster_nid = 0x02;
14501
14502         codec->patch_ops = alc_patch_ops;
14503
14504         if (board_config == ALC861VD_AUTO)
14505                 spec->init_hook = alc861vd_auto_init;
14506 #ifdef CONFIG_SND_HDA_POWER_SAVE
14507         if (!spec->loopback.amplist)
14508                 spec->loopback.amplist = alc861vd_loopbacks;
14509 #endif
14510
14511         return 0;
14512 }
14513
14514 /*
14515  * ALC662 support
14516  *
14517  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
14518  * configuration.  Each pin widget can choose any input DACs and a mixer.
14519  * Each ADC is connected from a mixer of all inputs.  This makes possible
14520  * 6-channel independent captures.
14521  *
14522  * In addition, an independent DAC for the multi-playback (not used in this
14523  * driver yet).
14524  */
14525 #define ALC662_DIGOUT_NID       0x06
14526 #define ALC662_DIGIN_NID        0x0a
14527
14528 static hda_nid_t alc662_dac_nids[4] = {
14529         /* front, rear, clfe, rear_surr */
14530         0x02, 0x03, 0x04
14531 };
14532
14533 static hda_nid_t alc662_adc_nids[1] = {
14534         /* ADC1-2 */
14535         0x09,
14536 };
14537
14538 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
14539
14540 /* input MUX */
14541 /* FIXME: should be a matrix-type input source selection */
14542 static struct hda_input_mux alc662_capture_source = {
14543         .num_items = 4,
14544         .items = {
14545                 { "Mic", 0x0 },
14546                 { "Front Mic", 0x1 },
14547                 { "Line", 0x2 },
14548                 { "CD", 0x4 },
14549         },
14550 };
14551
14552 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
14553         .num_items = 2,
14554         .items = {
14555                 { "Mic", 0x1 },
14556                 { "Line", 0x2 },
14557         },
14558 };
14559
14560 static struct hda_input_mux alc662_eeepc_capture_source = {
14561         .num_items = 2,
14562         .items = {
14563                 { "i-Mic", 0x1 },
14564                 { "e-Mic", 0x0 },
14565         },
14566 };
14567
14568 static struct hda_input_mux alc663_capture_source = {
14569         .num_items = 3,
14570         .items = {
14571                 { "Mic", 0x0 },
14572                 { "Front Mic", 0x1 },
14573                 { "Line", 0x2 },
14574         },
14575 };
14576
14577 static struct hda_input_mux alc663_m51va_capture_source = {
14578         .num_items = 2,
14579         .items = {
14580                 { "Ext-Mic", 0x0 },
14581                 { "D-Mic", 0x9 },
14582         },
14583 };
14584
14585 #define alc662_mux_enum_info alc_mux_enum_info
14586 #define alc662_mux_enum_get alc_mux_enum_get
14587 #define alc662_mux_enum_put alc882_mux_enum_put
14588
14589 /*
14590  * 2ch mode
14591  */
14592 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
14593         { 2, NULL }
14594 };
14595
14596 /*
14597  * 2ch mode
14598  */
14599 static struct hda_verb alc662_3ST_ch2_init[] = {
14600         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
14601         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14602         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
14603         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14604         { } /* end */
14605 };
14606
14607 /*
14608  * 6ch mode
14609  */
14610 static struct hda_verb alc662_3ST_ch6_init[] = {
14611         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14612         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14613         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
14614         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14615         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14616         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
14617         { } /* end */
14618 };
14619
14620 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
14621         { 2, alc662_3ST_ch2_init },
14622         { 6, alc662_3ST_ch6_init },
14623 };
14624
14625 /*
14626  * 2ch mode
14627  */
14628 static struct hda_verb alc662_sixstack_ch6_init[] = {
14629         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14630         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14631         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14632         { } /* end */
14633 };
14634
14635 /*
14636  * 6ch mode
14637  */
14638 static struct hda_verb alc662_sixstack_ch8_init[] = {
14639         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14640         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14641         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14642         { } /* end */
14643 };
14644
14645 static struct hda_channel_mode alc662_5stack_modes[2] = {
14646         { 2, alc662_sixstack_ch6_init },
14647         { 6, alc662_sixstack_ch8_init },
14648 };
14649
14650 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14651  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14652  */
14653
14654 static struct snd_kcontrol_new alc662_base_mixer[] = {
14655         /* output mixer control */
14656         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
14657         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14658         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
14659         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14660         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14661         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14662         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14663         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14664         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14665
14666         /*Input mixer control */
14667         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
14668         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
14669         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
14670         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
14671         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
14672         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
14673         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
14674         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
14675         { } /* end */
14676 };
14677
14678 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
14679         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14680         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14681         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14682         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14683         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14684         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14685         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14686         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14687         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14688         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14689         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14690         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14691         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14692         { } /* end */
14693 };
14694
14695 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
14696         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14697         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14698         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14699         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14700         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14701         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14702         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14703         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14704         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14705         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14706         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14707         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14708         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14709         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14710         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14711         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14712         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14713         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14714         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14715         { } /* end */
14716 };
14717
14718 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
14719         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14720         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
14721         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14722         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
14723         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14724         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14725         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14726         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14727         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14728         { } /* end */
14729 };
14730
14731 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
14732         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14733
14734         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14735         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14736
14737         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
14738         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14739         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14740
14741         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
14742         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14743         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14744         { } /* end */
14745 };
14746
14747 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
14748         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14749         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14750         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14751         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
14752         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14753         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14754         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
14755         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
14756         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14757         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
14758         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14759         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14761         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14762         { } /* end */
14763 };
14764
14765 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
14766         .ops = &snd_hda_bind_vol,
14767         .values = {
14768                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14769                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
14770                 0
14771         },
14772 };
14773
14774 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
14775         .ops = &snd_hda_bind_sw,
14776         .values = {
14777                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14778                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14779                 0
14780         },
14781 };
14782
14783 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
14784         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14785         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
14786         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14787         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14788         { } /* end */
14789 };
14790
14791 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
14792         .ops = &snd_hda_bind_sw,
14793         .values = {
14794                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14795                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14796                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14797                 0
14798         },
14799 };
14800
14801 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
14802         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14803         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
14804         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14805         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14806         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14807         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14808
14809         { } /* end */
14810 };
14811
14812 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
14813         .ops = &snd_hda_bind_sw,
14814         .values = {
14815                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14816                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14817                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
14818                 0
14819         },
14820 };
14821
14822 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
14823         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14824         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
14825         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14826         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14827         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14828         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14829         { } /* end */
14830 };
14831
14832 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
14833         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14834         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14835         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14836         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14837         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14838         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14839         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14840         { } /* end */
14841 };
14842
14843 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
14844         .ops = &snd_hda_bind_vol,
14845         .values = {
14846                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14847                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
14848                 0
14849         },
14850 };
14851
14852 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
14853         .ops = &snd_hda_bind_sw,
14854         .values = {
14855                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14856                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
14857                 0
14858         },
14859 };
14860
14861 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
14862         HDA_BIND_VOL("Master Playback Volume",
14863                                 &alc663_asus_two_bind_master_vol),
14864         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14865         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14866         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14867         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14868         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14869         { } /* end */
14870 };
14871
14872 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
14873         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14874         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14875         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14876         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14877         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14878         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14879         { } /* end */
14880 };
14881
14882 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
14883         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14884         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14885         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14886         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14887         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14888
14889         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14890         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14891         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14892         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14893         { } /* end */
14894 };
14895
14896 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
14897         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14898         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14899         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14900
14901         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14902         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14903         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14904         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14905         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14906         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14907         { } /* end */
14908 };
14909
14910 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
14911         {
14912                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14913                 .name = "Channel Mode",
14914                 .info = alc_ch_mode_info,
14915                 .get = alc_ch_mode_get,
14916                 .put = alc_ch_mode_put,
14917         },
14918         { } /* end */
14919 };
14920
14921 static struct hda_verb alc662_init_verbs[] = {
14922         /* ADC: mute amp left and right */
14923         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14924         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14925         /* Front mixer: unmute input/output amp left and right (volume = 0) */
14926
14927         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14928         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14929         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14930         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14931         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14932
14933         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14934         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14935         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14936         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14937         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14938         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14939
14940         /* Front Pin: output 0 (0x0c) */
14941         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14942         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14943
14944         /* Rear Pin: output 1 (0x0d) */
14945         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14946         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14947
14948         /* CLFE Pin: output 2 (0x0e) */
14949         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14950         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14951
14952         /* Mic (rear) pin: input vref at 80% */
14953         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14954         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14955         /* Front Mic pin: input vref at 80% */
14956         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14957         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14958         /* Line In pin: input */
14959         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14960         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14961         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14962         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14963         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14964         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14965         /* CD pin widget for input */
14966         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14967
14968         /* FIXME: use matrix-type input source selection */
14969         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
14970         /* Input mixer */
14971         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14972         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14973         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14974         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14975
14976         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14977         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14978         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14979         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14980
14981         /* always trun on EAPD */
14982         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14983         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14984
14985         { }
14986 };
14987
14988 static struct hda_verb alc662_sue_init_verbs[] = {
14989         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
14990         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
14991         {}
14992 };
14993
14994 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
14995         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14996         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14997         {}
14998 };
14999
15000 /* Set Unsolicited Event*/
15001 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15002         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15003         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15004         {}
15005 };
15006
15007 /*
15008  * generic initialization of ADC, input mixers and output mixers
15009  */
15010 static struct hda_verb alc662_auto_init_verbs[] = {
15011         /*
15012          * Unmute ADC and set the default input to mic-in
15013          */
15014         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15015         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15016
15017         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15018          * mixer widget
15019          * Note: PASD motherboards uses the Line In 2 as the input for front
15020          * panel mic (mic 2)
15021          */
15022         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15023         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15024         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15025         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15026         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15027         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15028
15029         /*
15030          * Set up output mixers (0x0c - 0x0f)
15031          */
15032         /* set vol=0 to output mixers */
15033         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15034         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15035         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15036
15037         /* set up input amps for analog loopback */
15038         /* Amp Indices: DAC = 0, mixer = 1 */
15039         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15040         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15041         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15042         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15043         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15044         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15045
15046
15047         /* FIXME: use matrix-type input source selection */
15048         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15049         /* Input mixer */
15050         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15051         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15052         { }
15053 };
15054
15055 /* additional verbs for ALC663 */
15056 static struct hda_verb alc663_auto_init_verbs[] = {
15057         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15058         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15059         { }
15060 };
15061
15062 static struct hda_verb alc663_m51va_init_verbs[] = {
15063         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15064         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15065         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15066         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15067         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15068         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15069         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15070         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15071         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15072         {}
15073 };
15074
15075 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15076         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15077         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15078         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15079         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15080         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15081         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15082         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15083         {}
15084 };
15085
15086 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15087         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15088         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15089         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15090         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15091         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15092         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15093         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15094         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15095         {}
15096 };
15097
15098 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15099         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15100         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15101         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15102         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15103         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15104         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15105         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15106         {}
15107 };
15108
15109 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15110         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15111         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15112         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15113         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15114         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15115         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15116         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15117         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15118         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15119         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15120         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15121         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15122         {}
15123 };
15124
15125 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15126         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15127         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15128         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15129         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15130         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15131         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15132         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15133         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15134         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15135         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15136         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15137         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15138         {}
15139 };
15140
15141 static struct hda_verb alc663_g71v_init_verbs[] = {
15142         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15143         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15144         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15145
15146         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15147         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15148         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15149
15150         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15151         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15152         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15153         {}
15154 };
15155
15156 static struct hda_verb alc663_g50v_init_verbs[] = {
15157         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15158         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15159         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15160
15161         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15162         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15163         {}
15164 };
15165
15166 static struct hda_verb alc662_ecs_init_verbs[] = {
15167         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15168         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15169         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15170         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15171         {}
15172 };
15173
15174 /* capture mixer elements */
15175 static struct snd_kcontrol_new alc662_capture_mixer[] = {
15176         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15177         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15178         {
15179                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15180                 /* The multiple "Capture Source" controls confuse alsamixer
15181                  * So call somewhat different..
15182                  */
15183                 /* .name = "Capture Source", */
15184                 .name = "Input Source",
15185                 .count = 1,
15186                 .info = alc662_mux_enum_info,
15187                 .get = alc662_mux_enum_get,
15188                 .put = alc662_mux_enum_put,
15189         },
15190         { } /* end */
15191 };
15192
15193 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15194         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15195         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15196         { } /* end */
15197 };
15198
15199 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15200 {
15201         unsigned int present;
15202         unsigned char bits;
15203
15204         present = snd_hda_codec_read(codec, 0x14, 0,
15205                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15206         bits = present ? HDA_AMP_MUTE : 0;
15207         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15208                                  HDA_AMP_MUTE, bits);
15209 }
15210
15211 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15212 {
15213         unsigned int present;
15214         unsigned char bits;
15215
15216         present = snd_hda_codec_read(codec, 0x1b, 0,
15217                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15218         bits = present ? HDA_AMP_MUTE : 0;
15219         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15220                                  HDA_AMP_MUTE, bits);
15221         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15222                                  HDA_AMP_MUTE, bits);
15223 }
15224
15225 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15226                                            unsigned int res)
15227 {
15228         if ((res >> 26) == ALC880_HP_EVENT)
15229                 alc662_lenovo_101e_all_automute(codec);
15230         if ((res >> 26) == ALC880_FRONT_EVENT)
15231                 alc662_lenovo_101e_ispeaker_automute(codec);
15232 }
15233
15234 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15235 {
15236         unsigned int present;
15237
15238         present = snd_hda_codec_read(codec, 0x18, 0,
15239                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15240         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15241                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15242         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15243                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15244         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15245                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15246         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15247                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15248 }
15249
15250 /* unsolicited event for HP jack sensing */
15251 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15252                                      unsigned int res)
15253 {
15254         if ((res >> 26) == ALC880_HP_EVENT)
15255                 alc262_hippo1_automute( codec );
15256
15257         if ((res >> 26) == ALC880_MIC_EVENT)
15258                 alc662_eeepc_mic_automute(codec);
15259 }
15260
15261 static void alc662_eeepc_inithook(struct hda_codec *codec)
15262 {
15263         alc262_hippo1_automute( codec );
15264         alc662_eeepc_mic_automute(codec);
15265 }
15266
15267 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15268 {
15269         unsigned int mute;
15270         unsigned int present;
15271
15272         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15273         present = snd_hda_codec_read(codec, 0x14, 0,
15274                                      AC_VERB_GET_PIN_SENSE, 0);
15275         present = (present & 0x80000000) != 0;
15276         if (present) {
15277                 /* mute internal speaker */
15278                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15279                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15280         } else {
15281                 /* unmute internal speaker if necessary */
15282                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15283                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15284                                         HDA_AMP_MUTE, mute);
15285         }
15286 }
15287
15288 /* unsolicited event for HP jack sensing */
15289 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15290                                           unsigned int res)
15291 {
15292         if ((res >> 26) == ALC880_HP_EVENT)
15293                 alc662_eeepc_ep20_automute(codec);
15294 }
15295
15296 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15297 {
15298         alc662_eeepc_ep20_automute(codec);
15299 }
15300
15301 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15302 {
15303         unsigned int present;
15304         unsigned char bits;
15305
15306         present = snd_hda_codec_read(codec, 0x21, 0,
15307                         AC_VERB_GET_PIN_SENSE, 0)
15308                         & AC_PINSENSE_PRESENCE;
15309         bits = present ? HDA_AMP_MUTE : 0;
15310         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15311                                 AMP_IN_MUTE(0), bits);
15312         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15313                                 AMP_IN_MUTE(0), bits);
15314 }
15315
15316 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15317 {
15318         unsigned int present;
15319         unsigned char bits;
15320
15321         present = snd_hda_codec_read(codec, 0x21, 0,
15322                         AC_VERB_GET_PIN_SENSE, 0)
15323                         & AC_PINSENSE_PRESENCE;
15324         bits = present ? HDA_AMP_MUTE : 0;
15325         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15326                                 AMP_IN_MUTE(0), bits);
15327         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15328                                 AMP_IN_MUTE(0), bits);
15329         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15330                                 AMP_IN_MUTE(0), bits);
15331         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15332                                 AMP_IN_MUTE(0), bits);
15333 }
15334
15335 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15336 {
15337         unsigned int present;
15338         unsigned char bits;
15339
15340         present = snd_hda_codec_read(codec, 0x15, 0,
15341                         AC_VERB_GET_PIN_SENSE, 0)
15342                         & AC_PINSENSE_PRESENCE;
15343         bits = present ? HDA_AMP_MUTE : 0;
15344         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15345                                 AMP_IN_MUTE(0), bits);
15346         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15347                                 AMP_IN_MUTE(0), bits);
15348         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15349                                 AMP_IN_MUTE(0), bits);
15350         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15351                                 AMP_IN_MUTE(0), bits);
15352 }
15353
15354 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15355 {
15356         unsigned int present;
15357         unsigned char bits;
15358
15359         present = snd_hda_codec_read(codec, 0x1b, 0,
15360                         AC_VERB_GET_PIN_SENSE, 0)
15361                         & AC_PINSENSE_PRESENCE;
15362         bits = present ? 0 : PIN_OUT;
15363         snd_hda_codec_write(codec, 0x14, 0,
15364                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15365 }
15366
15367 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15368 {
15369         unsigned int present1, present2;
15370
15371         present1 = snd_hda_codec_read(codec, 0x21, 0,
15372                         AC_VERB_GET_PIN_SENSE, 0)
15373                         & AC_PINSENSE_PRESENCE;
15374         present2 = snd_hda_codec_read(codec, 0x15, 0,
15375                         AC_VERB_GET_PIN_SENSE, 0)
15376                         & AC_PINSENSE_PRESENCE;
15377
15378         if (present1 || present2) {
15379                 snd_hda_codec_write_cache(codec, 0x14, 0,
15380                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15381         } else {
15382                 snd_hda_codec_write_cache(codec, 0x14, 0,
15383                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15384         }
15385 }
15386
15387 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15388 {
15389         unsigned int present1, present2;
15390
15391         present1 = snd_hda_codec_read(codec, 0x1b, 0,
15392                                 AC_VERB_GET_PIN_SENSE, 0)
15393                                 & AC_PINSENSE_PRESENCE;
15394         present2 = snd_hda_codec_read(codec, 0x15, 0,
15395                                 AC_VERB_GET_PIN_SENSE, 0)
15396                                 & AC_PINSENSE_PRESENCE;
15397
15398         if (present1 || present2) {
15399                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15400                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15401                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15402                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15403         } else {
15404                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15405                                 AMP_IN_MUTE(0), 0);
15406                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15407                                 AMP_IN_MUTE(0), 0);
15408         }
15409 }
15410
15411 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15412 {
15413         unsigned int present;
15414
15415         present = snd_hda_codec_read(codec, 0x18, 0,
15416                         AC_VERB_GET_PIN_SENSE, 0)
15417                         & AC_PINSENSE_PRESENCE;
15418         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15419                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15420         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15421                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15422         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15423                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15424         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15425                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15426 }
15427
15428 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15429                                            unsigned int res)
15430 {
15431         switch (res >> 26) {
15432         case ALC880_HP_EVENT:
15433                 alc663_m51va_speaker_automute(codec);
15434                 break;
15435         case ALC880_MIC_EVENT:
15436                 alc663_m51va_mic_automute(codec);
15437                 break;
15438         }
15439 }
15440
15441 static void alc663_m51va_inithook(struct hda_codec *codec)
15442 {
15443         alc663_m51va_speaker_automute(codec);
15444         alc663_m51va_mic_automute(codec);
15445 }
15446
15447 /* ***************** Mode1 ******************************/
15448 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15449                                            unsigned int res)
15450 {
15451         switch (res >> 26) {
15452         case ALC880_HP_EVENT:
15453                 alc663_m51va_speaker_automute(codec);
15454                 break;
15455         case ALC880_MIC_EVENT:
15456                 alc662_eeepc_mic_automute(codec);
15457                 break;
15458         }
15459 }
15460
15461 static void alc663_mode1_inithook(struct hda_codec *codec)
15462 {
15463         alc663_m51va_speaker_automute(codec);
15464         alc662_eeepc_mic_automute(codec);
15465 }
15466 /* ***************** Mode2 ******************************/
15467 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15468                                            unsigned int res)
15469 {
15470         switch (res >> 26) {
15471         case ALC880_HP_EVENT:
15472                 alc662_f5z_speaker_automute(codec);
15473                 break;
15474         case ALC880_MIC_EVENT:
15475                 alc662_eeepc_mic_automute(codec);
15476                 break;
15477         }
15478 }
15479
15480 static void alc662_mode2_inithook(struct hda_codec *codec)
15481 {
15482         alc662_f5z_speaker_automute(codec);
15483         alc662_eeepc_mic_automute(codec);
15484 }
15485 /* ***************** Mode3 ******************************/
15486 static void alc663_mode3_unsol_event(struct hda_codec *codec,
15487                                            unsigned int res)
15488 {
15489         switch (res >> 26) {
15490         case ALC880_HP_EVENT:
15491                 alc663_two_hp_m1_speaker_automute(codec);
15492                 break;
15493         case ALC880_MIC_EVENT:
15494                 alc662_eeepc_mic_automute(codec);
15495                 break;
15496         }
15497 }
15498
15499 static void alc663_mode3_inithook(struct hda_codec *codec)
15500 {
15501         alc663_two_hp_m1_speaker_automute(codec);
15502         alc662_eeepc_mic_automute(codec);
15503 }
15504 /* ***************** Mode4 ******************************/
15505 static void alc663_mode4_unsol_event(struct hda_codec *codec,
15506                                            unsigned int res)
15507 {
15508         switch (res >> 26) {
15509         case ALC880_HP_EVENT:
15510                 alc663_21jd_two_speaker_automute(codec);
15511                 break;
15512         case ALC880_MIC_EVENT:
15513                 alc662_eeepc_mic_automute(codec);
15514                 break;
15515         }
15516 }
15517
15518 static void alc663_mode4_inithook(struct hda_codec *codec)
15519 {
15520         alc663_21jd_two_speaker_automute(codec);
15521         alc662_eeepc_mic_automute(codec);
15522 }
15523 /* ***************** Mode5 ******************************/
15524 static void alc663_mode5_unsol_event(struct hda_codec *codec,
15525                                            unsigned int res)
15526 {
15527         switch (res >> 26) {
15528         case ALC880_HP_EVENT:
15529                 alc663_15jd_two_speaker_automute(codec);
15530                 break;
15531         case ALC880_MIC_EVENT:
15532                 alc662_eeepc_mic_automute(codec);
15533                 break;
15534         }
15535 }
15536
15537 static void alc663_mode5_inithook(struct hda_codec *codec)
15538 {
15539         alc663_15jd_two_speaker_automute(codec);
15540         alc662_eeepc_mic_automute(codec);
15541 }
15542 /* ***************** Mode6 ******************************/
15543 static void alc663_mode6_unsol_event(struct hda_codec *codec,
15544                                            unsigned int res)
15545 {
15546         switch (res >> 26) {
15547         case ALC880_HP_EVENT:
15548                 alc663_two_hp_m2_speaker_automute(codec);
15549                 break;
15550         case ALC880_MIC_EVENT:
15551                 alc662_eeepc_mic_automute(codec);
15552                 break;
15553         }
15554 }
15555
15556 static void alc663_mode6_inithook(struct hda_codec *codec)
15557 {
15558         alc663_two_hp_m2_speaker_automute(codec);
15559         alc662_eeepc_mic_automute(codec);
15560 }
15561
15562 static void alc663_g71v_hp_automute(struct hda_codec *codec)
15563 {
15564         unsigned int present;
15565         unsigned char bits;
15566
15567         present = snd_hda_codec_read(codec, 0x21, 0,
15568                                      AC_VERB_GET_PIN_SENSE, 0)
15569                 & AC_PINSENSE_PRESENCE;
15570         bits = present ? HDA_AMP_MUTE : 0;
15571         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15572                                  HDA_AMP_MUTE, bits);
15573         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15574                                  HDA_AMP_MUTE, bits);
15575 }
15576
15577 static void alc663_g71v_front_automute(struct hda_codec *codec)
15578 {
15579         unsigned int present;
15580         unsigned char bits;
15581
15582         present = snd_hda_codec_read(codec, 0x15, 0,
15583                                      AC_VERB_GET_PIN_SENSE, 0)
15584                 & AC_PINSENSE_PRESENCE;
15585         bits = present ? HDA_AMP_MUTE : 0;
15586         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15587                                  HDA_AMP_MUTE, bits);
15588 }
15589
15590 static void alc663_g71v_unsol_event(struct hda_codec *codec,
15591                                            unsigned int res)
15592 {
15593         switch (res >> 26) {
15594         case ALC880_HP_EVENT:
15595                 alc663_g71v_hp_automute(codec);
15596                 break;
15597         case ALC880_FRONT_EVENT:
15598                 alc663_g71v_front_automute(codec);
15599                 break;
15600         case ALC880_MIC_EVENT:
15601                 alc662_eeepc_mic_automute(codec);
15602                 break;
15603         }
15604 }
15605
15606 static void alc663_g71v_inithook(struct hda_codec *codec)
15607 {
15608         alc663_g71v_front_automute(codec);
15609         alc663_g71v_hp_automute(codec);
15610         alc662_eeepc_mic_automute(codec);
15611 }
15612
15613 static void alc663_g50v_unsol_event(struct hda_codec *codec,
15614                                            unsigned int res)
15615 {
15616         switch (res >> 26) {
15617         case ALC880_HP_EVENT:
15618                 alc663_m51va_speaker_automute(codec);
15619                 break;
15620         case ALC880_MIC_EVENT:
15621                 alc662_eeepc_mic_automute(codec);
15622                 break;
15623         }
15624 }
15625
15626 static void alc663_g50v_inithook(struct hda_codec *codec)
15627 {
15628         alc663_m51va_speaker_automute(codec);
15629         alc662_eeepc_mic_automute(codec);
15630 }
15631
15632 /* bind hp and internal speaker mute (with plug check) */
15633 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
15634                                      struct snd_ctl_elem_value *ucontrol)
15635 {
15636         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
15637         long *valp = ucontrol->value.integer.value;
15638         int change;
15639
15640         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
15641                                           HDA_AMP_MUTE,
15642                                           valp[0] ? 0 : HDA_AMP_MUTE);
15643         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
15644                                            HDA_AMP_MUTE,
15645                                            valp[1] ? 0 : HDA_AMP_MUTE);
15646         if (change)
15647                 alc262_hippo1_automute(codec);
15648         return change;
15649 }
15650
15651 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
15652         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15653         {
15654                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15655                 .name = "Master Playback Switch",
15656                 .info = snd_hda_mixer_amp_switch_info,
15657                 .get = snd_hda_mixer_amp_switch_get,
15658                 .put = alc662_ecs_master_sw_put,
15659                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15660         },
15661
15662         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
15663         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
15664         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
15665
15666         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15667         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15668         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15669         { } /* end */
15670 };
15671
15672 #ifdef CONFIG_SND_HDA_POWER_SAVE
15673 #define alc662_loopbacks        alc880_loopbacks
15674 #endif
15675
15676
15677 /* pcm configuration: identiacal with ALC880 */
15678 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
15679 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
15680 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
15681 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
15682
15683 /*
15684  * configuration and preset
15685  */
15686 static const char *alc662_models[ALC662_MODEL_LAST] = {
15687         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
15688         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
15689         [ALC662_3ST_6ch]        = "3stack-6ch",
15690         [ALC662_5ST_DIG]        = "6stack-dig",
15691         [ALC662_LENOVO_101E]    = "lenovo-101e",
15692         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
15693         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
15694         [ALC662_ECS] = "ecs",
15695         [ALC663_ASUS_M51VA] = "m51va",
15696         [ALC663_ASUS_G71V] = "g71v",
15697         [ALC663_ASUS_H13] = "h13",
15698         [ALC663_ASUS_G50V] = "g50v",
15699         [ALC663_ASUS_MODE1] = "asus-mode1",
15700         [ALC662_ASUS_MODE2] = "asus-mode2",
15701         [ALC663_ASUS_MODE3] = "asus-mode3",
15702         [ALC663_ASUS_MODE4] = "asus-mode4",
15703         [ALC663_ASUS_MODE5] = "asus-mode5",
15704         [ALC663_ASUS_MODE6] = "asus-mode6",
15705         [ALC662_AUTO]           = "auto",
15706 };
15707
15708 static struct snd_pci_quirk alc662_cfg_tbl[] = {
15709         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
15710         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
15711         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
15712         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
15713         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
15714         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
15715         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),
15716         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
15717         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
15718         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
15719         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),
15720         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
15721         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
15722         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
15723         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
15724         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
15725         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
15726         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
15727         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
15728         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
15729         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
15730         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
15731         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
15732         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
15733         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
15734         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
15735         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
15736         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
15737         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
15738         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
15739         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
15740         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
15741         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
15742         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
15743         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
15744         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
15745         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
15746         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
15747                       ALC662_3ST_6ch_DIG),
15748         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
15749         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
15750         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
15751         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
15752                       ALC662_3ST_6ch_DIG),
15753         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
15754         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
15755                                         ALC662_3ST_6ch_DIG),
15756         SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
15757         SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
15758         SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
15759         {}
15760 };
15761
15762 static struct alc_config_preset alc662_presets[] = {
15763         [ALC662_3ST_2ch_DIG] = {
15764                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
15765                 .init_verbs = { alc662_init_verbs },
15766                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15767                 .dac_nids = alc662_dac_nids,
15768                 .dig_out_nid = ALC662_DIGOUT_NID,
15769                 .dig_in_nid = ALC662_DIGIN_NID,
15770                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15771                 .channel_mode = alc662_3ST_2ch_modes,
15772                 .input_mux = &alc662_capture_source,
15773         },
15774         [ALC662_3ST_6ch_DIG] = {
15775                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15776                             alc662_capture_mixer },
15777                 .init_verbs = { alc662_init_verbs },
15778                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15779                 .dac_nids = alc662_dac_nids,
15780                 .dig_out_nid = ALC662_DIGOUT_NID,
15781                 .dig_in_nid = ALC662_DIGIN_NID,
15782                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15783                 .channel_mode = alc662_3ST_6ch_modes,
15784                 .need_dac_fix = 1,
15785                 .input_mux = &alc662_capture_source,
15786         },
15787         [ALC662_3ST_6ch] = {
15788                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15789                             alc662_capture_mixer },
15790                 .init_verbs = { alc662_init_verbs },
15791                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15792                 .dac_nids = alc662_dac_nids,
15793                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15794                 .channel_mode = alc662_3ST_6ch_modes,
15795                 .need_dac_fix = 1,
15796                 .input_mux = &alc662_capture_source,
15797         },
15798         [ALC662_5ST_DIG] = {
15799                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
15800                             alc662_capture_mixer },
15801                 .init_verbs = { alc662_init_verbs },
15802                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15803                 .dac_nids = alc662_dac_nids,
15804                 .dig_out_nid = ALC662_DIGOUT_NID,
15805                 .dig_in_nid = ALC662_DIGIN_NID,
15806                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
15807                 .channel_mode = alc662_5stack_modes,
15808                 .input_mux = &alc662_capture_source,
15809         },
15810         [ALC662_LENOVO_101E] = {
15811                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
15812                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
15813                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15814                 .dac_nids = alc662_dac_nids,
15815                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15816                 .channel_mode = alc662_3ST_2ch_modes,
15817                 .input_mux = &alc662_lenovo_101e_capture_source,
15818                 .unsol_event = alc662_lenovo_101e_unsol_event,
15819                 .init_hook = alc662_lenovo_101e_all_automute,
15820         },
15821         [ALC662_ASUS_EEEPC_P701] = {
15822                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
15823                 .init_verbs = { alc662_init_verbs,
15824                                 alc662_eeepc_sue_init_verbs },
15825                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15826                 .dac_nids = alc662_dac_nids,
15827                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15828                 .channel_mode = alc662_3ST_2ch_modes,
15829                 .input_mux = &alc662_eeepc_capture_source,
15830                 .unsol_event = alc662_eeepc_unsol_event,
15831                 .init_hook = alc662_eeepc_inithook,
15832         },
15833         [ALC662_ASUS_EEEPC_EP20] = {
15834                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
15835                             alc662_chmode_mixer },
15836                 .init_verbs = { alc662_init_verbs,
15837                                 alc662_eeepc_ep20_sue_init_verbs },
15838                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15839                 .dac_nids = alc662_dac_nids,
15840                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15841                 .channel_mode = alc662_3ST_6ch_modes,
15842                 .input_mux = &alc662_lenovo_101e_capture_source,
15843                 .unsol_event = alc662_eeepc_ep20_unsol_event,
15844                 .init_hook = alc662_eeepc_ep20_inithook,
15845         },
15846         [ALC662_ECS] = {
15847                 .mixers = { alc662_ecs_mixer, alc662_capture_mixer },
15848                 .init_verbs = { alc662_init_verbs,
15849                                 alc662_ecs_init_verbs },
15850                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15851                 .dac_nids = alc662_dac_nids,
15852                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15853                 .channel_mode = alc662_3ST_2ch_modes,
15854                 .input_mux = &alc662_eeepc_capture_source,
15855                 .unsol_event = alc662_eeepc_unsol_event,
15856                 .init_hook = alc662_eeepc_inithook,
15857         },
15858         [ALC663_ASUS_M51VA] = {
15859                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15860                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15861                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15862                 .dac_nids = alc662_dac_nids,
15863                 .dig_out_nid = ALC662_DIGOUT_NID,
15864                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15865                 .channel_mode = alc662_3ST_2ch_modes,
15866                 .input_mux = &alc663_m51va_capture_source,
15867                 .unsol_event = alc663_m51va_unsol_event,
15868                 .init_hook = alc663_m51va_inithook,
15869         },
15870         [ALC663_ASUS_G71V] = {
15871                 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
15872                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
15873                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15874                 .dac_nids = alc662_dac_nids,
15875                 .dig_out_nid = ALC662_DIGOUT_NID,
15876                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15877                 .channel_mode = alc662_3ST_2ch_modes,
15878                 .input_mux = &alc662_eeepc_capture_source,
15879                 .unsol_event = alc663_g71v_unsol_event,
15880                 .init_hook = alc663_g71v_inithook,
15881         },
15882         [ALC663_ASUS_H13] = {
15883                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15884                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15885                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15886                 .dac_nids = alc662_dac_nids,
15887                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15888                 .channel_mode = alc662_3ST_2ch_modes,
15889                 .input_mux = &alc663_m51va_capture_source,
15890                 .unsol_event = alc663_m51va_unsol_event,
15891                 .init_hook = alc663_m51va_inithook,
15892         },
15893         [ALC663_ASUS_G50V] = {
15894                 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
15895                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
15896                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15897                 .dac_nids = alc662_dac_nids,
15898                 .dig_out_nid = ALC662_DIGOUT_NID,
15899                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15900                 .channel_mode = alc662_3ST_6ch_modes,
15901                 .input_mux = &alc663_capture_source,
15902                 .unsol_event = alc663_g50v_unsol_event,
15903                 .init_hook = alc663_g50v_inithook,
15904         },
15905         [ALC663_ASUS_MODE1] = {
15906                 .mixers = { alc663_m51va_mixer, alc662_auto_capture_mixer },
15907                 .init_verbs = { alc662_init_verbs,
15908                                 alc663_21jd_amic_init_verbs },
15909                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15910                 .hp_nid = 0x03,
15911                 .dac_nids = alc662_dac_nids,
15912                 .dig_out_nid = ALC662_DIGOUT_NID,
15913                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15914                 .channel_mode = alc662_3ST_2ch_modes,
15915                 .input_mux = &alc662_eeepc_capture_source,
15916                 .unsol_event = alc663_mode1_unsol_event,
15917                 .init_hook = alc663_mode1_inithook,
15918         },
15919         [ALC662_ASUS_MODE2] = {
15920                 .mixers = { alc662_1bjd_mixer, alc662_auto_capture_mixer },
15921                 .init_verbs = { alc662_init_verbs,
15922                                 alc662_1bjd_amic_init_verbs },
15923                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15924                 .dac_nids = alc662_dac_nids,
15925                 .dig_out_nid = ALC662_DIGOUT_NID,
15926                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15927                 .channel_mode = alc662_3ST_2ch_modes,
15928                 .input_mux = &alc662_eeepc_capture_source,
15929                 .unsol_event = alc662_mode2_unsol_event,
15930                 .init_hook = alc662_mode2_inithook,
15931         },
15932         [ALC663_ASUS_MODE3] = {
15933                 .mixers = { alc663_two_hp_m1_mixer, alc662_auto_capture_mixer },
15934                 .init_verbs = { alc662_init_verbs,
15935                                 alc663_two_hp_amic_m1_init_verbs },
15936                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15937                 .hp_nid = 0x03,
15938                 .dac_nids = alc662_dac_nids,
15939                 .dig_out_nid = ALC662_DIGOUT_NID,
15940                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15941                 .channel_mode = alc662_3ST_2ch_modes,
15942                 .input_mux = &alc662_eeepc_capture_source,
15943                 .unsol_event = alc663_mode3_unsol_event,
15944                 .init_hook = alc663_mode3_inithook,
15945         },
15946         [ALC663_ASUS_MODE4] = {
15947                 .mixers = { alc663_asus_21jd_clfe_mixer,
15948                                 alc662_auto_capture_mixer},
15949                 .init_verbs = { alc662_init_verbs,
15950                                 alc663_21jd_amic_init_verbs},
15951                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15952                 .hp_nid = 0x03,
15953                 .dac_nids = alc662_dac_nids,
15954                 .dig_out_nid = ALC662_DIGOUT_NID,
15955                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15956                 .channel_mode = alc662_3ST_2ch_modes,
15957                 .input_mux = &alc662_eeepc_capture_source,
15958                 .unsol_event = alc663_mode4_unsol_event,
15959                 .init_hook = alc663_mode4_inithook,
15960         },
15961         [ALC663_ASUS_MODE5] = {
15962                 .mixers = { alc663_asus_15jd_clfe_mixer,
15963                                 alc662_auto_capture_mixer },
15964                 .init_verbs = { alc662_init_verbs,
15965                                 alc663_15jd_amic_init_verbs },
15966                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15967                 .hp_nid = 0x03,
15968                 .dac_nids = alc662_dac_nids,
15969                 .dig_out_nid = ALC662_DIGOUT_NID,
15970                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15971                 .channel_mode = alc662_3ST_2ch_modes,
15972                 .input_mux = &alc662_eeepc_capture_source,
15973                 .unsol_event = alc663_mode5_unsol_event,
15974                 .init_hook = alc663_mode5_inithook,
15975         },
15976         [ALC663_ASUS_MODE6] = {
15977                 .mixers = { alc663_two_hp_m2_mixer, alc662_auto_capture_mixer },
15978                 .init_verbs = { alc662_init_verbs,
15979                                 alc663_two_hp_amic_m2_init_verbs },
15980                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15981                 .hp_nid = 0x03,
15982                 .dac_nids = alc662_dac_nids,
15983                 .dig_out_nid = ALC662_DIGOUT_NID,
15984                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15985                 .channel_mode = alc662_3ST_2ch_modes,
15986                 .input_mux = &alc662_eeepc_capture_source,
15987                 .unsol_event = alc663_mode6_unsol_event,
15988                 .init_hook = alc663_mode6_inithook,
15989         },
15990 };
15991
15992
15993 /*
15994  * BIOS auto configuration
15995  */
15996
15997 /* add playback controls from the parsed DAC table */
15998 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
15999                                              const struct auto_pin_cfg *cfg)
16000 {
16001         char name[32];
16002         static const char *chname[4] = {
16003                 "Front", "Surround", NULL /*CLFE*/, "Side"
16004         };
16005         hda_nid_t nid;
16006         int i, err;
16007
16008         for (i = 0; i < cfg->line_outs; i++) {
16009                 if (!spec->multiout.dac_nids[i])
16010                         continue;
16011                 nid = alc880_idx_to_dac(i);
16012                 if (i == 2) {
16013                         /* Center/LFE */
16014                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16015                                           "Center Playback Volume",
16016                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16017                                                               HDA_OUTPUT));
16018                         if (err < 0)
16019                                 return err;
16020                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16021                                           "LFE Playback Volume",
16022                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16023                                                               HDA_OUTPUT));
16024                         if (err < 0)
16025                                 return err;
16026                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16027                                           "Center Playback Switch",
16028                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16029                                                               HDA_INPUT));
16030                         if (err < 0)
16031                                 return err;
16032                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16033                                           "LFE Playback Switch",
16034                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16035                                                               HDA_INPUT));
16036                         if (err < 0)
16037                                 return err;
16038                 } else {
16039                         sprintf(name, "%s Playback Volume", chname[i]);
16040                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16041                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16042                                                               HDA_OUTPUT));
16043                         if (err < 0)
16044                                 return err;
16045                         sprintf(name, "%s Playback Switch", chname[i]);
16046                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16047                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16048                                                     3, 0, HDA_INPUT));
16049                         if (err < 0)
16050                                 return err;
16051                 }
16052         }
16053         return 0;
16054 }
16055
16056 /* add playback controls for speaker and HP outputs */
16057 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16058                                         const char *pfx)
16059 {
16060         hda_nid_t nid;
16061         int err;
16062         char name[32];
16063
16064         if (!pin)
16065                 return 0;
16066
16067         if (pin == 0x17) {
16068                 /* ALC663 has a mono output pin on 0x17 */
16069                 sprintf(name, "%s Playback Switch", pfx);
16070                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16071                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16072                 return err;
16073         }
16074
16075         if (alc880_is_fixed_pin(pin)) {
16076                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16077                 /* printk("DAC nid=%x\n",nid); */
16078                 /* specify the DAC as the extra output */
16079                 if (!spec->multiout.hp_nid)
16080                         spec->multiout.hp_nid = nid;
16081                 else
16082                         spec->multiout.extra_out_nid[0] = nid;
16083                 /* control HP volume/switch on the output mixer amp */
16084                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16085                 sprintf(name, "%s Playback Volume", pfx);
16086                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16087                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16088                 if (err < 0)
16089                         return err;
16090                 sprintf(name, "%s Playback Switch", pfx);
16091                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16092                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16093                 if (err < 0)
16094                         return err;
16095         } else if (alc880_is_multi_pin(pin)) {
16096                 /* set manual connection */
16097                 /* we have only a switch on HP-out PIN */
16098                 sprintf(name, "%s Playback Switch", pfx);
16099                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16100                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16101                 if (err < 0)
16102                         return err;
16103         }
16104         return 0;
16105 }
16106
16107 /* create playback/capture controls for input pins */
16108 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16109                                                 const struct auto_pin_cfg *cfg)
16110 {
16111         struct hda_input_mux *imux = &spec->private_imux;
16112         int i, err, idx;
16113
16114         for (i = 0; i < AUTO_PIN_LAST; i++) {
16115                 if (alc880_is_input_pin(cfg->input_pins[i])) {
16116                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
16117                         err = new_analog_input(spec, cfg->input_pins[i],
16118                                                auto_pin_cfg_labels[i],
16119                                                idx, 0x0b);
16120                         if (err < 0)
16121                                 return err;
16122                         imux->items[imux->num_items].label =
16123                                 auto_pin_cfg_labels[i];
16124                         imux->items[imux->num_items].index =
16125                                 alc880_input_pin_idx(cfg->input_pins[i]);
16126                         imux->num_items++;
16127                 }
16128         }
16129         return 0;
16130 }
16131
16132 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16133                                               hda_nid_t nid, int pin_type,
16134                                               int dac_idx)
16135 {
16136         alc_set_pin_output(codec, nid, pin_type);
16137         /* need the manual connection? */
16138         if (alc880_is_multi_pin(nid)) {
16139                 struct alc_spec *spec = codec->spec;
16140                 int idx = alc880_multi_pin_idx(nid);
16141                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16142                                     AC_VERB_SET_CONNECT_SEL,
16143                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16144         }
16145 }
16146
16147 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16148 {
16149         struct alc_spec *spec = codec->spec;
16150         int i;
16151
16152         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16153         for (i = 0; i <= HDA_SIDE; i++) {
16154                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16155                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16156                 if (nid)
16157                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16158                                                           i);
16159         }
16160 }
16161
16162 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16163 {
16164         struct alc_spec *spec = codec->spec;
16165         hda_nid_t pin;
16166
16167         pin = spec->autocfg.hp_pins[0];
16168         if (pin) /* connect to front */
16169                 /* use dac 0 */
16170                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16171         pin = spec->autocfg.speaker_pins[0];
16172         if (pin)
16173                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16174 }
16175
16176 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
16177 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16178
16179 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16180 {
16181         struct alc_spec *spec = codec->spec;
16182         int i;
16183
16184         for (i = 0; i < AUTO_PIN_LAST; i++) {
16185                 hda_nid_t nid = spec->autocfg.input_pins[i];
16186                 if (alc662_is_input_pin(nid)) {
16187                         snd_hda_codec_write(codec, nid, 0,
16188                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
16189                                             (i <= AUTO_PIN_FRONT_MIC ?
16190                                              PIN_VREF80 : PIN_IN));
16191                         if (nid != ALC662_PIN_CD_NID)
16192                                 snd_hda_codec_write(codec, nid, 0,
16193                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16194                                                     AMP_OUT_MUTE);
16195                 }
16196         }
16197 }
16198
16199 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16200
16201 static int alc662_parse_auto_config(struct hda_codec *codec)
16202 {
16203         struct alc_spec *spec = codec->spec;
16204         int err;
16205         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16206
16207         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16208                                            alc662_ignore);
16209         if (err < 0)
16210                 return err;
16211         if (!spec->autocfg.line_outs)
16212                 return 0; /* can't find valid BIOS pin config */
16213
16214         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16215         if (err < 0)
16216                 return err;
16217         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16218         if (err < 0)
16219                 return err;
16220         err = alc662_auto_create_extra_out(spec,
16221                                            spec->autocfg.speaker_pins[0],
16222                                            "Speaker");
16223         if (err < 0)
16224                 return err;
16225         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16226                                            "Headphone");
16227         if (err < 0)
16228                 return err;
16229         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16230         if (err < 0)
16231                 return err;
16232
16233         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16234
16235         if (spec->autocfg.dig_out_pin)
16236                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16237
16238         if (spec->kctl_alloc)
16239                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
16240
16241         spec->num_mux_defs = 1;
16242         spec->input_mux = &spec->private_imux;
16243
16244         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
16245         if (codec->vendor_id == 0x10ec0663)
16246                 spec->init_verbs[spec->num_init_verbs++] =
16247                         alc663_auto_init_verbs;
16248
16249         err = alc_auto_add_mic_boost(codec);
16250         if (err < 0)
16251                 return err;
16252
16253         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
16254         spec->num_mixers++;
16255         return 1;
16256 }
16257
16258 /* additional initialization for auto-configuration model */
16259 static void alc662_auto_init(struct hda_codec *codec)
16260 {
16261         struct alc_spec *spec = codec->spec;
16262         alc662_auto_init_multi_out(codec);
16263         alc662_auto_init_hp_out(codec);
16264         alc662_auto_init_analog_input(codec);
16265         alc662_auto_init_input_src(codec);
16266         if (spec->unsol_event)
16267                 alc_inithook(codec);
16268 }
16269
16270 static int patch_alc662(struct hda_codec *codec)
16271 {
16272         struct alc_spec *spec;
16273         int err, board_config;
16274
16275         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16276         if (!spec)
16277                 return -ENOMEM;
16278
16279         codec->spec = spec;
16280
16281         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16282
16283         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16284                                                   alc662_models,
16285                                                   alc662_cfg_tbl);
16286         if (board_config < 0) {
16287                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16288                        "trying auto-probe from BIOS...\n");
16289                 board_config = ALC662_AUTO;
16290         }
16291
16292         if (board_config == ALC662_AUTO) {
16293                 /* automatic parse from the BIOS config */
16294                 err = alc662_parse_auto_config(codec);
16295                 if (err < 0) {
16296                         alc_free(codec);
16297                         return err;
16298                 } else if (!err) {
16299                         printk(KERN_INFO
16300                                "hda_codec: Cannot set up configuration "
16301                                "from BIOS.  Using base mode...\n");
16302                         board_config = ALC662_3ST_2ch_DIG;
16303                 }
16304         }
16305
16306         if (board_config != ALC662_AUTO)
16307                 setup_preset(spec, &alc662_presets[board_config]);
16308
16309         if (codec->vendor_id == 0x10ec0663) {
16310                 spec->stream_name_analog = "ALC663 Analog";
16311                 spec->stream_name_digital = "ALC663 Digital";
16312         } else if (codec->vendor_id == 0x10ec0272) {
16313                 spec->stream_name_analog = "ALC272 Analog";
16314                 spec->stream_name_digital = "ALC272 Digital";
16315         } else {
16316                 spec->stream_name_analog = "ALC662 Analog";
16317                 spec->stream_name_digital = "ALC662 Digital";
16318         }
16319
16320         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16321         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16322
16323         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16324         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16325
16326         spec->adc_nids = alc662_adc_nids;
16327         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16328         spec->capsrc_nids = alc662_capsrc_nids;
16329
16330         spec->vmaster_nid = 0x02;
16331
16332         codec->patch_ops = alc_patch_ops;
16333         if (board_config == ALC662_AUTO)
16334                 spec->init_hook = alc662_auto_init;
16335 #ifdef CONFIG_SND_HDA_POWER_SAVE
16336         if (!spec->loopback.amplist)
16337                 spec->loopback.amplist = alc662_loopbacks;
16338 #endif
16339
16340         return 0;
16341 }
16342
16343 /*
16344  * patch entries
16345  */
16346 struct hda_codec_preset snd_hda_preset_realtek[] = {
16347         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16348         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16349         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16350         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16351         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16352         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16353         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16354           .patch = patch_alc861 },
16355         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16356         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16357         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16358         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16359           .patch = patch_alc883 },
16360         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16361           .patch = patch_alc662 },
16362         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16363         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16364         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16365         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16366         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16367           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16368         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16369           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16370         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16371         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16372         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16373         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16374           .patch = patch_alc883 },
16375         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16376         {} /* terminator */
16377 };