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 #ifdef SND_HDA_NEEDS_RESUME
 312 #define ALC_MAX_PINS    16
 313         unsigned int num_pins;
 314         hda_nid_t pin_nids[ALC_MAX_PINS];
 315         unsigned int pin_cfgs[ALC_MAX_PINS];
 316 #endif
 317 };
 318
 319 /*
 320  * configuration template - to be copied to the spec instance
 321  */
 322 struct alc_config_preset {
 323         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 324                                              * with spec
 325                                              */
 326         const struct hda_verb *init_verbs[5];
 327         unsigned int num_dacs;
 328         hda_nid_t *dac_nids;
 329         hda_nid_t dig_out_nid;          /* optional */
 330         hda_nid_t hp_nid;               /* optional */
 331         unsigned int num_adc_nids;
 332         hda_nid_t *adc_nids;
 333         hda_nid_t *capsrc_nids;
 334         hda_nid_t dig_in_nid;
 335         unsigned int num_channel_mode;
 336         const struct hda_channel_mode *channel_mode;
 337         int need_dac_fix;
 338         unsigned int num_mux_defs;
 339         const struct hda_input_mux *input_mux;
 340         void (*unsol_event)(struct hda_codec *, unsigned int);
 341         void (*init_hook)(struct hda_codec *);
 342 #ifdef CONFIG_SND_HDA_POWER_SAVE
 343         struct hda_amp_list *loopbacks;
 344 #endif
 345 };
 346
 347
 348 /*
 349  * input MUX handling
 350  */
 351 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 352                              struct snd_ctl_elem_info *uinfo)
 353 {
 354         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 355         struct alc_spec *spec = codec->spec;
 356         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 357         if (mux_idx >= spec->num_mux_defs)
 358                 mux_idx = 0;
 359         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 360 }
 361
 362 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 363                             struct snd_ctl_elem_value *ucontrol)
 364 {
 365         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 366         struct alc_spec *spec = codec->spec;
 367         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 368
 369         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 370         return 0;
 371 }
 372
 373 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 374                             struct snd_ctl_elem_value *ucontrol)
 375 {
 376         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 377         struct alc_spec *spec = codec->spec;
 378         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 379         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 380         hda_nid_t nid = spec->capsrc_nids ?
 381                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 382         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
 383                                      nid, &spec->cur_mux[adc_idx]);
 384 }
 385
 386
 387 /*
 388  * channel mode setting
 389  */
 390 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 391                             struct snd_ctl_elem_info *uinfo)
 392 {
 393         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 394         struct alc_spec *spec = codec->spec;
 395         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 396                                     spec->num_channel_mode);
 397 }
 398
 399 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 400                            struct snd_ctl_elem_value *ucontrol)
 401 {
 402         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 403         struct alc_spec *spec = codec->spec;
 404         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 405                                    spec->num_channel_mode,
 406                                    spec->multiout.max_channels);
 407 }
 408
 409 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 410                            struct snd_ctl_elem_value *ucontrol)
 411 {
 412         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 413         struct alc_spec *spec = codec->spec;
 414         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 415                                       spec->num_channel_mode,
 416                                       &spec->multiout.max_channels);
 417         if (err >= 0 && spec->need_dac_fix)
 418                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 419         return err;
 420 }
 421
 422 /*
 423  * Control the mode of pin widget settings via the mixer.  "pc" is used
 424  * instead of "%" to avoid consequences of accidently treating the % as
 425  * being part of a format specifier.  Maximum allowed length of a value is
 426  * 63 characters plus NULL terminator.
 427  *
 428  * Note: some retasking pin complexes seem to ignore requests for input
 429  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 430  * are requested.  Therefore order this list so that this behaviour will not
 431  * cause problems when mixer clients move through the enum sequentially.
 432  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 433  * March 2006.
 434  */
 435 static char *alc_pin_mode_names[] = {
 436         "Mic 50pc bias", "Mic 80pc bias",
 437         "Line in", "Line out", "Headphone out",
 438 };
 439 static unsigned char alc_pin_mode_values[] = {
 440         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 441 };
 442 /* The control can present all 5 options, or it can limit the options based
 443  * in the pin being assumed to be exclusively an input or an output pin.  In
 444  * addition, "input" pins may or may not process the mic bias option
 445  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 446  * accept requests for bias as of chip versions up to March 2006) and/or
 447  * wiring in the computer.
 448  */
 449 #define ALC_PIN_DIR_IN              0x00
 450 #define ALC_PIN_DIR_OUT             0x01
 451 #define ALC_PIN_DIR_INOUT           0x02
 452 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 453 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 454
 455 /* Info about the pin modes supported by the different pin direction modes.
 456  * For each direction the minimum and maximum values are given.
 457  */
 458 static signed char alc_pin_mode_dir_info[5][2] = {
 459         { 0, 2 },    /* ALC_PIN_DIR_IN */
 460         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 461         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 462         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 463         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 464 };
 465 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 466 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 467 #define alc_pin_mode_n_items(_dir) \
 468         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 469
 470 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 471                              struct snd_ctl_elem_info *uinfo)
 472 {
 473         unsigned int item_num = uinfo->value.enumerated.item;
 474         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 475
 476         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 477         uinfo->count = 1;
 478         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 479
 480         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 481                 item_num = alc_pin_mode_min(dir);
 482         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 483         return 0;
 484 }
 485
 486 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 487                             struct snd_ctl_elem_value *ucontrol)
 488 {
 489         unsigned int i;
 490         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 491         hda_nid_t nid = kcontrol->private_value & 0xffff;
 492         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 493         long *valp = ucontrol->value.integer.value;
 494         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 495                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 496                                                  0x00);
 497
 498         /* Find enumerated value for current pinctl setting */
 499         i = alc_pin_mode_min(dir);
 500         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 501                 i++;
 502         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 503         return 0;
 504 }
 505
 506 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 507                             struct snd_ctl_elem_value *ucontrol)
 508 {
 509         signed int change;
 510         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 511         hda_nid_t nid = kcontrol->private_value & 0xffff;
 512         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 513         long val = *ucontrol->value.integer.value;
 514         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 515                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 516                                                  0x00);
 517
 518         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 519                 val = alc_pin_mode_min(dir);
 520
 521         change = pinctl != alc_pin_mode_values[val];
 522         if (change) {
 523                 /* Set pin mode to that requested */
 524                 snd_hda_codec_write_cache(codec, nid, 0,
 525                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 526                                           alc_pin_mode_values[val]);
 527
 528                 /* Also enable the retasking pin's input/output as required
 529                  * for the requested pin mode.  Enum values of 2 or less are
 530                  * input modes.
 531                  *
 532                  * Dynamically switching the input/output buffers probably
 533                  * reduces noise slightly (particularly on input) so we'll
 534                  * do it.  However, having both input and output buffers
 535                  * enabled simultaneously doesn't seem to be problematic if
 536                  * this turns out to be necessary in the future.
 537                  */
 538                 if (val <= 2) {
 539                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 540                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 541                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 542                                                  HDA_AMP_MUTE, 0);
 543                 } else {
 544                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 545                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 546                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 547                                                  HDA_AMP_MUTE, 0);
 548                 }
 549         }
 550         return change;
 551 }
 552
 553 #define ALC_PIN_MODE(xname, nid, dir) \
 554         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 555           .info = alc_pin_mode_info, \
 556           .get = alc_pin_mode_get, \
 557           .put = alc_pin_mode_put, \
 558           .private_value = nid | (dir<<16) }
 559
 560 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 561  * together using a mask with more than one bit set.  This control is
 562  * currently used only by the ALC260 test model.  At this stage they are not
 563  * needed for any "production" models.
 564  */
 565 #ifdef CONFIG_SND_DEBUG
 566 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 567
 568 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 569                              struct snd_ctl_elem_value *ucontrol)
 570 {
 571         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 572         hda_nid_t nid = kcontrol->private_value & 0xffff;
 573         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 574         long *valp = ucontrol->value.integer.value;
 575         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 576                                               AC_VERB_GET_GPIO_DATA, 0x00);
 577
 578         *valp = (val & mask) != 0;
 579         return 0;
 580 }
 581 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 582                              struct snd_ctl_elem_value *ucontrol)
 583 {
 584         signed int change;
 585         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 586         hda_nid_t nid = kcontrol->private_value & 0xffff;
 587         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 588         long val = *ucontrol->value.integer.value;
 589         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 590                                                     AC_VERB_GET_GPIO_DATA,
 591                                                     0x00);
 592
 593         /* Set/unset the masked GPIO bit(s) as needed */
 594         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 595         if (val == 0)
 596                 gpio_data &= ~mask;
 597         else
 598                 gpio_data |= mask;
 599         snd_hda_codec_write_cache(codec, nid, 0,
 600                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 601
 602         return change;
 603 }
 604 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 605         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 606           .info = alc_gpio_data_info, \
 607           .get = alc_gpio_data_get, \
 608           .put = alc_gpio_data_put, \
 609           .private_value = nid | (mask<<16) }
 610 #endif   /* CONFIG_SND_DEBUG */
 611
 612 /* A switch control to allow the enabling of the digital IO pins on the
 613  * ALC260.  This is incredibly simplistic; the intention of this control is
 614  * to provide something in the test model allowing digital outputs to be
 615  * identified if present.  If models are found which can utilise these
 616  * outputs a more complete mixer control can be devised for those models if
 617  * necessary.
 618  */
 619 #ifdef CONFIG_SND_DEBUG
 620 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 621
 622 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 623                               struct snd_ctl_elem_value *ucontrol)
 624 {
 625         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 626         hda_nid_t nid = kcontrol->private_value & 0xffff;
 627         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 628         long *valp = ucontrol->value.integer.value;
 629         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 630                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 631
 632         *valp = (val & mask) != 0;
 633         return 0;
 634 }
 635 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 636                               struct snd_ctl_elem_value *ucontrol)
 637 {
 638         signed int change;
 639         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 640         hda_nid_t nid = kcontrol->private_value & 0xffff;
 641         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 642         long val = *ucontrol->value.integer.value;
 643         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 644                                                     AC_VERB_GET_DIGI_CONVERT_1,
 645                                                     0x00);
 646
 647         /* Set/unset the masked control bit(s) as needed */
 648         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 649         if (val==0)
 650                 ctrl_data &= ~mask;
 651         else
 652                 ctrl_data |= mask;
 653         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 654                                   ctrl_data);
 655
 656         return change;
 657 }
 658 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 659         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 660           .info = alc_spdif_ctrl_info, \
 661           .get = alc_spdif_ctrl_get, \
 662           .put = alc_spdif_ctrl_put, \
 663           .private_value = nid | (mask<<16) }
 664 #endif   /* CONFIG_SND_DEBUG */
 665
 666 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 667  * Again, this is only used in the ALC26x test models to help identify when
 668  * the EAPD line must be asserted for features to work.
 669  */
 670 #ifdef CONFIG_SND_DEBUG
 671 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 672
 673 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 674                               struct snd_ctl_elem_value *ucontrol)
 675 {
 676         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 677         hda_nid_t nid = kcontrol->private_value & 0xffff;
 678         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 679         long *valp = ucontrol->value.integer.value;
 680         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 681                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 682
 683         *valp = (val & mask) != 0;
 684         return 0;
 685 }
 686
 687 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 688                               struct snd_ctl_elem_value *ucontrol)
 689 {
 690         int change;
 691         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 692         hda_nid_t nid = kcontrol->private_value & 0xffff;
 693         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 694         long val = *ucontrol->value.integer.value;
 695         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 696                                                     AC_VERB_GET_EAPD_BTLENABLE,
 697                                                     0x00);
 698
 699         /* Set/unset the masked control bit(s) as needed */
 700         change = (!val ? 0 : mask) != (ctrl_data & mask);
 701         if (!val)
 702                 ctrl_data &= ~mask;
 703         else
 704                 ctrl_data |= mask;
 705         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 706                                   ctrl_data);
 707
 708         return change;
 709 }
 710
 711 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 712         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 713           .info = alc_eapd_ctrl_info, \
 714           .get = alc_eapd_ctrl_get, \
 715           .put = alc_eapd_ctrl_put, \
 716           .private_value = nid | (mask<<16) }
 717 #endif   /* CONFIG_SND_DEBUG */
 718
 719 /*
 720  * set up from the preset table
 721  */
 722 static void setup_preset(struct alc_spec *spec,
 723                          const struct alc_config_preset *preset)
 724 {
 725         int i;
 726
 727         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 728                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
 729         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 730              i++)
 731                 spec->init_verbs[spec->num_init_verbs++] =
 732                         preset->init_verbs[i];
 733
 734         spec->channel_mode = preset->channel_mode;
 735         spec->num_channel_mode = preset->num_channel_mode;
 736         spec->need_dac_fix = preset->need_dac_fix;
 737
 738         spec->multiout.max_channels = spec->channel_mode[0].channels;
 739
 740         spec->multiout.num_dacs = preset->num_dacs;
 741         spec->multiout.dac_nids = preset->dac_nids;
 742         spec->multiout.dig_out_nid = preset->dig_out_nid;
 743         spec->multiout.hp_nid = preset->hp_nid;
 744
 745         spec->num_mux_defs = preset->num_mux_defs;
 746         if (!spec->num_mux_defs)
 747                 spec->num_mux_defs = 1;
 748         spec->input_mux = preset->input_mux;
 749
 750         spec->num_adc_nids = preset->num_adc_nids;
 751         spec->adc_nids = preset->adc_nids;
 752         spec->capsrc_nids = preset->capsrc_nids;
 753         spec->dig_in_nid = preset->dig_in_nid;
 754
 755         spec->unsol_event = preset->unsol_event;
 756         spec->init_hook = preset->init_hook;
 757 #ifdef CONFIG_SND_HDA_POWER_SAVE
 758         spec->loopback.amplist = preset->loopbacks;
 759 #endif
 760 }
 761
 762 /* Enable GPIO mask and set output */
 763 static struct hda_verb alc_gpio1_init_verbs[] = {
 764         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 765         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 766         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 767         { }
 768 };
 769
 770 static struct hda_verb alc_gpio2_init_verbs[] = {
 771         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 772         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 773         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 774         { }
 775 };
 776
 777 static struct hda_verb alc_gpio3_init_verbs[] = {
 778         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 779         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 780         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 781         { }
 782 };
 783
 784 /*
 785  * Fix hardware PLL issue
 786  * On some codecs, the analog PLL gating control must be off while
 787  * the default value is 1.
 788  */
 789 static void alc_fix_pll(struct hda_codec *codec)
 790 {
 791         struct alc_spec *spec = codec->spec;
 792         unsigned int val;
 793
 794         if (!spec->pll_nid)
 795                 return;
 796         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 797                             spec->pll_coef_idx);
 798         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 799                                  AC_VERB_GET_PROC_COEF, 0);
 800         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 801                             spec->pll_coef_idx);
 802         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 803                             val & ~(1 << spec->pll_coef_bit));
 804 }
 805
 806 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 807                              unsigned int coef_idx, unsigned int coef_bit)
 808 {
 809         struct alc_spec *spec = codec->spec;
 810         spec->pll_nid = nid;
 811         spec->pll_coef_idx = coef_idx;
 812         spec->pll_coef_bit = coef_bit;
 813         alc_fix_pll(codec);
 814 }
 815
 816 static void alc_sku_automute(struct hda_codec *codec)
 817 {
 818         struct alc_spec *spec = codec->spec;
 819         unsigned int present;
 820         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 821         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 822
 823         /* need to execute and sync at first */
 824         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 825         present = snd_hda_codec_read(codec, hp_nid, 0,
 826                                      AC_VERB_GET_PIN_SENSE, 0);
 827         spec->jack_present = (present & 0x80000000) != 0;
 828         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 829                             spec->jack_present ? 0 : PIN_OUT);
 830 }
 831
 832 #if 0 /* it's broken in some acses -- temporarily disabled */
 833 static void alc_mic_automute(struct hda_codec *codec)
 834 {
 835         struct alc_spec *spec = codec->spec;
 836         unsigned int present;
 837         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 838         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 839         unsigned int mix_nid = spec->capsrc_nids[0];
 840         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 841
 842         capsrc_idx_mic = mic_nid - 0x18;
 843         capsrc_idx_fmic = fmic_nid - 0x18;
 844         present = snd_hda_codec_read(codec, mic_nid, 0,
 845                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 846         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 847                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 848         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 849                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 850         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 851                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 852 }
 853 #else
 854 #define alc_mic_automute(codec) /* NOP */
 855 #endif /* disabled */
 856
 857 /* unsolicited event for HP jack sensing */
 858 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 859 {
 860         if (codec->vendor_id == 0x10ec0880)
 861                 res >>= 28;
 862         else
 863                 res >>= 26;
 864         if (res == ALC880_HP_EVENT)
 865                 alc_sku_automute(codec);
 866
 867         if (res == ALC880_MIC_EVENT)
 868                 alc_mic_automute(codec);
 869 }
 870
 871 static void alc_inithook(struct hda_codec *codec)
 872 {
 873         alc_sku_automute(codec);
 874         alc_mic_automute(codec);
 875 }
 876
 877 /* additional initialization for ALC888 variants */
 878 static void alc888_coef_init(struct hda_codec *codec)
 879 {
 880         unsigned int tmp;
 881
 882         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 883         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 884         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 885         if ((tmp & 0xf0) == 2)
 886                 /* alc888S-VC */
 887                 snd_hda_codec_read(codec, 0x20, 0,
 888                                    AC_VERB_SET_PROC_COEF, 0x830);
 889          else
 890                  /* alc888-VB */
 891                  snd_hda_codec_read(codec, 0x20, 0,
 892                                     AC_VERB_SET_PROC_COEF, 0x3030);
 893 }
 894
 895 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 896  *      31 ~ 16 :       Manufacture ID
 897  *      15 ~ 8  :       SKU ID
 898  *      7  ~ 0  :       Assembly ID
 899  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 900  */
 901 static void alc_subsystem_id(struct hda_codec *codec,
 902                              unsigned int porta, unsigned int porte,
 903                              unsigned int portd)
 904 {
 905         unsigned int ass, tmp, i;
 906         unsigned nid;
 907         struct alc_spec *spec = codec->spec;
 908
 909         ass = codec->subsystem_id & 0xffff;
 910         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
 911                 goto do_sku;
 912
 913         /*
 914          * 31~30        : port conetcivity
 915          * 29~21        : reserve
 916          * 20           : PCBEEP input
 917          * 19~16        : Check sum (15:1)
 918          * 15~1         : Custom
 919          * 0            : override
 920         */
 921         nid = 0x1d;
 922         if (codec->vendor_id == 0x10ec0260)
 923                 nid = 0x17;
 924         ass = snd_hda_codec_read(codec, nid, 0,
 925                                  AC_VERB_GET_CONFIG_DEFAULT, 0);
 926         if (!(ass & 1) && !(ass & 0x100000))
 927                 return;
 928         if ((ass >> 30) != 1)   /* no physical connection */
 929                 return;
 930
 931         /* check sum */
 932         tmp = 0;
 933         for (i = 1; i < 16; i++) {
 934                 if ((ass >> i) & 1)
 935                         tmp++;
 936         }
 937         if (((ass >> 16) & 0xf) != tmp)
 938                 return;
 939 do_sku:
 940         /*
 941          * 0 : override
 942          * 1 :  Swap Jack
 943          * 2 : 0 --> Desktop, 1 --> Laptop
 944          * 3~5 : External Amplifier control
 945          * 7~6 : Reserved
 946         */
 947         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 948         switch (tmp) {
 949         case 1:
 950                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
 951                 break;
 952         case 3:
 953                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
 954                 break;
 955         case 7:
 956                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
 957                 break;
 958         case 5: /* set EAPD output high */
 959                 switch (codec->vendor_id) {
 960                 case 0x10ec0260:
 961                         snd_hda_codec_write(codec, 0x0f, 0,
 962                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 963                         snd_hda_codec_write(codec, 0x10, 0,
 964                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 965                         break;
 966                 case 0x10ec0262:
 967                 case 0x10ec0267:
 968                 case 0x10ec0268:
 969                 case 0x10ec0269:
 970                 case 0x10ec0660:
 971                 case 0x10ec0662:
 972                 case 0x10ec0663:
 973                 case 0x10ec0862:
 974                 case 0x10ec0889:
 975                         snd_hda_codec_write(codec, 0x14, 0,
 976                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 977                         snd_hda_codec_write(codec, 0x15, 0,
 978                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
 979                         break;
 980                 }
 981                 switch (codec->vendor_id) {
 982                 case 0x10ec0260:
 983                         snd_hda_codec_write(codec, 0x1a, 0,
 984                                             AC_VERB_SET_COEF_INDEX, 7);
 985                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
 986                                                  AC_VERB_GET_PROC_COEF, 0);
 987                         snd_hda_codec_write(codec, 0x1a, 0,
 988                                             AC_VERB_SET_COEF_INDEX, 7);
 989                         snd_hda_codec_write(codec, 0x1a, 0,
 990                                             AC_VERB_SET_PROC_COEF,
 991                                             tmp | 0x2010);
 992                         break;
 993                 case 0x10ec0262:
 994                 case 0x10ec0880:
 995                 case 0x10ec0882:
 996                 case 0x10ec0883:
 997                 case 0x10ec0885:
 998                 case 0x10ec0889:
 999                         snd_hda_codec_write(codec, 0x20, 0,
1000                                             AC_VERB_SET_COEF_INDEX, 7);
1001                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1002                                                  AC_VERB_GET_PROC_COEF, 0);
1003                         snd_hda_codec_write(codec, 0x20, 0,
1004                                             AC_VERB_SET_COEF_INDEX, 7);
1005                         snd_hda_codec_write(codec, 0x20, 0,
1006                                             AC_VERB_SET_PROC_COEF,
1007                                             tmp | 0x2010);
1008                         break;
1009                 case 0x10ec0888:
1010                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1011                         break;
1012                 case 0x10ec0267:
1013                 case 0x10ec0268:
1014                         snd_hda_codec_write(codec, 0x20, 0,
1015                                             AC_VERB_SET_COEF_INDEX, 7);
1016                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1017                                                  AC_VERB_GET_PROC_COEF, 0);
1018                         snd_hda_codec_write(codec, 0x20, 0,
1019                                             AC_VERB_SET_COEF_INDEX, 7);
1020                         snd_hda_codec_write(codec, 0x20, 0,
1021                                             AC_VERB_SET_PROC_COEF,
1022                                             tmp | 0x3000);
1023                         break;
1024                 }
1025         default:
1026                 break;
1027         }
1028
1029         /* is laptop or Desktop and enable the function "Mute internal speaker
1030          * when the external headphone out jack is plugged"
1031          */
1032         if (!(ass & 0x8000))
1033                 return;
1034         /*
1035          * 10~8 : Jack location
1036          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1037          * 14~13: Resvered
1038          * 15   : 1 --> enable the function "Mute internal speaker
1039          *              when the external headphone out jack is plugged"
1040          */
1041         if (!spec->autocfg.speaker_pins[0]) {
1042                 if (spec->autocfg.line_out_pins[0])
1043                         spec->autocfg.speaker_pins[0] =
1044                                 spec->autocfg.line_out_pins[0];
1045                 else
1046                         return;
1047         }
1048
1049         if (!spec->autocfg.hp_pins[0]) {
1050                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1051                 if (tmp == 0)
1052                         spec->autocfg.hp_pins[0] = porta;
1053                 else if (tmp == 1)
1054                         spec->autocfg.hp_pins[0] = porte;
1055                 else if (tmp == 2)
1056                         spec->autocfg.hp_pins[0] = portd;
1057                 else
1058                         return;
1059         }
1060         if (spec->autocfg.hp_pins[0])
1061                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1062                         AC_VERB_SET_UNSOLICITED_ENABLE,
1063                         AC_USRSP_EN | ALC880_HP_EVENT);
1064
1065 #if 0 /* it's broken in some acses -- temporarily disabled */
1066         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1067                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1068                 snd_hda_codec_write(codec,
1069                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1070                         AC_VERB_SET_UNSOLICITED_ENABLE,
1071                         AC_USRSP_EN | ALC880_MIC_EVENT);
1072 #endif /* disabled */
1073
1074         spec->unsol_event = alc_sku_unsol_event;
1075 }
1076
1077 /*
1078  * Fix-up pin default configurations
1079  */
1080
1081 struct alc_pincfg {
1082         hda_nid_t nid;
1083         u32 val;
1084 };
1085
1086 static void alc_fix_pincfg(struct hda_codec *codec,
1087                            const struct snd_pci_quirk *quirk,
1088                            const struct alc_pincfg **pinfix)
1089 {
1090         const struct alc_pincfg *cfg;
1091
1092         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1093         if (!quirk)
1094                 return;
1095
1096         cfg = pinfix[quirk->value];
1097         for (; cfg->nid; cfg++) {
1098                 int i;
1099                 u32 val = cfg->val;
1100                 for (i = 0; i < 4; i++) {
1101                         snd_hda_codec_write(codec, cfg->nid, 0,
1102                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1103                                     val & 0xff);
1104                         val >>= 8;
1105                 }
1106         }
1107 }
1108
1109 /*
1110  * ALC880 3-stack model
1111  *
1112  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1113  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1114  *                 F-Mic = 0x1b, HP = 0x19
1115  */
1116
1117 static hda_nid_t alc880_dac_nids[4] = {
1118         /* front, rear, clfe, rear_surr */
1119         0x02, 0x05, 0x04, 0x03
1120 };
1121
1122 static hda_nid_t alc880_adc_nids[3] = {
1123         /* ADC0-2 */
1124         0x07, 0x08, 0x09,
1125 };
1126
1127 /* The datasheet says the node 0x07 is connected from inputs,
1128  * but it shows zero connection in the real implementation on some devices.
1129  * Note: this is a 915GAV bug, fixed on 915GLV
1130  */
1131 static hda_nid_t alc880_adc_nids_alt[2] = {
1132         /* ADC1-2 */
1133         0x08, 0x09,
1134 };
1135
1136 #define ALC880_DIGOUT_NID       0x06
1137 #define ALC880_DIGIN_NID        0x0a
1138
1139 static struct hda_input_mux alc880_capture_source = {
1140         .num_items = 4,
1141         .items = {
1142                 { "Mic", 0x0 },
1143                 { "Front Mic", 0x3 },
1144                 { "Line", 0x2 },
1145                 { "CD", 0x4 },
1146         },
1147 };
1148
1149 /* channel source setting (2/6 channel selection for 3-stack) */
1150 /* 2ch mode */
1151 static struct hda_verb alc880_threestack_ch2_init[] = {
1152         /* set line-in to input, mute it */
1153         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1154         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1155         /* set mic-in to input vref 80%, mute it */
1156         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1157         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1158         { } /* end */
1159 };
1160
1161 /* 6ch mode */
1162 static struct hda_verb alc880_threestack_ch6_init[] = {
1163         /* set line-in to output, unmute it */
1164         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1165         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1166         /* set mic-in to output, unmute it */
1167         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1168         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1169         { } /* end */
1170 };
1171
1172 static struct hda_channel_mode alc880_threestack_modes[2] = {
1173         { 2, alc880_threestack_ch2_init },
1174         { 6, alc880_threestack_ch6_init },
1175 };
1176
1177 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1178         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1179         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1180         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1181         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1182         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1183         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1184         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1185         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1186         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1187         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1188         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1189         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1190         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1191         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1192         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1193         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1194         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1195         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1196         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1197         {
1198                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1199                 .name = "Channel Mode",
1200                 .info = alc_ch_mode_info,
1201                 .get = alc_ch_mode_get,
1202                 .put = alc_ch_mode_put,
1203         },
1204         { } /* end */
1205 };
1206
1207 /* capture mixer elements */
1208 static struct snd_kcontrol_new alc880_capture_mixer[] = {
1209         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
1210         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
1211         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
1212         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
1213         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
1214         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
1215         {
1216                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1217                 /* The multiple "Capture Source" controls confuse alsamixer
1218                  * So call somewhat different..
1219                  */
1220                 /* .name = "Capture Source", */
1221                 .name = "Input Source",
1222                 .count = 3,
1223                 .info = alc_mux_enum_info,
1224                 .get = alc_mux_enum_get,
1225                 .put = alc_mux_enum_put,
1226         },
1227         { } /* end */
1228 };
1229
1230 /* capture mixer elements (in case NID 0x07 not available) */
1231 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
1232         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1233         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1234         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
1235         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
1236         {
1237                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1238                 /* The multiple "Capture Source" controls confuse alsamixer
1239                  * So call somewhat different..
1240                  */
1241                 /* .name = "Capture Source", */
1242                 .name = "Input Source",
1243                 .count = 2,
1244                 .info = alc_mux_enum_info,
1245                 .get = alc_mux_enum_get,
1246                 .put = alc_mux_enum_put,
1247         },
1248         { } /* end */
1249 };
1250
1251
1252
1253 /*
1254  * ALC880 5-stack model
1255  *
1256  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1257  *      Side = 0x02 (0xd)
1258  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1259  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1260  */
1261
1262 /* additional mixers to alc880_three_stack_mixer */
1263 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1264         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1265         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1266         { } /* end */
1267 };
1268
1269 /* channel source setting (6/8 channel selection for 5-stack) */
1270 /* 6ch mode */
1271 static struct hda_verb alc880_fivestack_ch6_init[] = {
1272         /* set line-in to input, mute it */
1273         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1274         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1275         { } /* end */
1276 };
1277
1278 /* 8ch mode */
1279 static struct hda_verb alc880_fivestack_ch8_init[] = {
1280         /* set line-in to output, unmute it */
1281         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1282         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1283         { } /* end */
1284 };
1285
1286 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1287         { 6, alc880_fivestack_ch6_init },
1288         { 8, alc880_fivestack_ch8_init },
1289 };
1290
1291
1292 /*
1293  * ALC880 6-stack model
1294  *
1295  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1296  *      Side = 0x05 (0x0f)
1297  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1298  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1299  */
1300
1301 static hda_nid_t alc880_6st_dac_nids[4] = {
1302         /* front, rear, clfe, rear_surr */
1303         0x02, 0x03, 0x04, 0x05
1304 };
1305
1306 static struct hda_input_mux alc880_6stack_capture_source = {
1307         .num_items = 4,
1308         .items = {
1309                 { "Mic", 0x0 },
1310                 { "Front Mic", 0x1 },
1311                 { "Line", 0x2 },
1312                 { "CD", 0x4 },
1313         },
1314 };
1315
1316 /* fixed 8-channels */
1317 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1318         { 8, NULL },
1319 };
1320
1321 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1322         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1323         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1324         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1325         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1326         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1327         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1328         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1329         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1330         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1331         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1332         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1333         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1334         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1335         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1336         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1337         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1338         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1339         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1340         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1341         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1342         {
1343                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1344                 .name = "Channel Mode",
1345                 .info = alc_ch_mode_info,
1346                 .get = alc_ch_mode_get,
1347                 .put = alc_ch_mode_put,
1348         },
1349         { } /* end */
1350 };
1351
1352
1353 /*
1354  * ALC880 W810 model
1355  *
1356  * W810 has rear IO for:
1357  * Front (DAC 02)
1358  * Surround (DAC 03)
1359  * Center/LFE (DAC 04)
1360  * Digital out (06)
1361  *
1362  * The system also has a pair of internal speakers, and a headphone jack.
1363  * These are both connected to Line2 on the codec, hence to DAC 02.
1364  *
1365  * There is a variable resistor to control the speaker or headphone
1366  * volume. This is a hardware-only device without a software API.
1367  *
1368  * Plugging headphones in will disable the internal speakers. This is
1369  * implemented in hardware, not via the driver using jack sense. In
1370  * a similar fashion, plugging into the rear socket marked "front" will
1371  * disable both the speakers and headphones.
1372  *
1373  * For input, there's a microphone jack, and an "audio in" jack.
1374  * These may not do anything useful with this driver yet, because I
1375  * haven't setup any initialization verbs for these yet...
1376  */
1377
1378 static hda_nid_t alc880_w810_dac_nids[3] = {
1379         /* front, rear/surround, clfe */
1380         0x02, 0x03, 0x04
1381 };
1382
1383 /* fixed 6 channels */
1384 static struct hda_channel_mode alc880_w810_modes[1] = {
1385         { 6, NULL }
1386 };
1387
1388 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1389 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1390         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1391         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1392         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1393         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1394         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1395         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1396         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1397         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1398         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1399         { } /* end */
1400 };
1401
1402
1403 /*
1404  * Z710V model
1405  *
1406  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1407  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1408  *                 Line = 0x1a
1409  */
1410
1411 static hda_nid_t alc880_z71v_dac_nids[1] = {
1412         0x02
1413 };
1414 #define ALC880_Z71V_HP_DAC      0x03
1415
1416 /* fixed 2 channels */
1417 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1418         { 2, NULL }
1419 };
1420
1421 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1422         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1423         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1424         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1425         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1426         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1427         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1428         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1429         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1430         { } /* end */
1431 };
1432
1433
1434 /*
1435  * ALC880 F1734 model
1436  *
1437  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1438  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1439  */
1440
1441 static hda_nid_t alc880_f1734_dac_nids[1] = {
1442         0x03
1443 };
1444 #define ALC880_F1734_HP_DAC     0x02
1445
1446 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1447         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1448         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1449         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1450         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1451         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1452         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1453         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1454         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1455         { } /* end */
1456 };
1457
1458 static struct hda_input_mux alc880_f1734_capture_source = {
1459         .num_items = 2,
1460         .items = {
1461                 { "Mic", 0x1 },
1462                 { "CD", 0x4 },
1463         },
1464 };
1465
1466
1467 /*
1468  * ALC880 ASUS model
1469  *
1470  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1471  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1472  *  Mic = 0x18, Line = 0x1a
1473  */
1474
1475 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1476 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1477
1478 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1479         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1480         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1481         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1482         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1483         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1484         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1485         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1486         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1487         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1488         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1489         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1490         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1491         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1492         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1493         {
1494                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1495                 .name = "Channel Mode",
1496                 .info = alc_ch_mode_info,
1497                 .get = alc_ch_mode_get,
1498                 .put = alc_ch_mode_put,
1499         },
1500         { } /* end */
1501 };
1502
1503 /*
1504  * ALC880 ASUS W1V model
1505  *
1506  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1507  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1508  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1509  */
1510
1511 /* additional mixers to alc880_asus_mixer */
1512 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1513         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1514         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1515         { } /* end */
1516 };
1517
1518 /* additional mixers to alc880_asus_mixer */
1519 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1520         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1521         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1522         { } /* end */
1523 };
1524
1525 /* TCL S700 */
1526 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1527         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1528         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1529         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1530         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1531         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1532         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1533         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1534         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1535         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1536         {
1537                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1538                 /* The multiple "Capture Source" controls confuse alsamixer
1539                  * So call somewhat different..
1540                  */
1541                 /* .name = "Capture Source", */
1542                 .name = "Input Source",
1543                 .count = 1,
1544                 .info = alc_mux_enum_info,
1545                 .get = alc_mux_enum_get,
1546                 .put = alc_mux_enum_put,
1547         },
1548         { } /* end */
1549 };
1550
1551 /* Uniwill */
1552 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1553         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1554         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1555         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1556         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1557         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1558         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1559         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1560         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1561         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1562         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1563         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1564         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1565         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1566         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1567         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1568         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1569         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1570         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1571         {
1572                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1573                 .name = "Channel Mode",
1574                 .info = alc_ch_mode_info,
1575                 .get = alc_ch_mode_get,
1576                 .put = alc_ch_mode_put,
1577         },
1578         { } /* end */
1579 };
1580
1581 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1582         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1583         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1584         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1585         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1586         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1587         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1588         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1589         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1590         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1591         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1592         { } /* end */
1593 };
1594
1595 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1596         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1597         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1598         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1599         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1600         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1601         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1602         { } /* end */
1603 };
1604
1605 /*
1606  * virtual master controls
1607  */
1608
1609 /*
1610  * slave controls for virtual master
1611  */
1612 static const char *alc_slave_vols[] = {
1613         "Front Playback Volume",
1614         "Surround Playback Volume",
1615         "Center Playback Volume",
1616         "LFE Playback Volume",
1617         "Side Playback Volume",
1618         "Headphone Playback Volume",
1619         "Speaker Playback Volume",
1620         "Mono Playback Volume",
1621         "Line-Out Playback Volume",
1622         NULL,
1623 };
1624
1625 static const char *alc_slave_sws[] = {
1626         "Front Playback Switch",
1627         "Surround Playback Switch",
1628         "Center Playback Switch",
1629         "LFE Playback Switch",
1630         "Side Playback Switch",
1631         "Headphone Playback Switch",
1632         "Speaker Playback Switch",
1633         "Mono Playback Switch",
1634         "IEC958 Playback Switch",
1635         NULL,
1636 };
1637
1638 /*
1639  * build control elements
1640  */
1641 static int alc_build_controls(struct hda_codec *codec)
1642 {
1643         struct alc_spec *spec = codec->spec;
1644         int err;
1645         int i;
1646
1647         for (i = 0; i < spec->num_mixers; i++) {
1648                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1649                 if (err < 0)
1650                         return err;
1651         }
1652
1653         if (spec->multiout.dig_out_nid) {
1654                 err = snd_hda_create_spdif_out_ctls(codec,
1655                                                     spec->multiout.dig_out_nid);
1656                 if (err < 0)
1657                         return err;
1658                 err = snd_hda_create_spdif_share_sw(codec,
1659                                                     &spec->multiout);
1660                 if (err < 0)
1661                         return err;
1662                 spec->multiout.share_spdif = 1;
1663         }
1664         if (spec->dig_in_nid) {
1665                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1666                 if (err < 0)
1667                         return err;
1668         }
1669
1670         /* if we have no master control, let's create it */
1671         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1672                 unsigned int vmaster_tlv[4];
1673                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1674                                         HDA_OUTPUT, vmaster_tlv);
1675                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1676                                           vmaster_tlv, alc_slave_vols);
1677                 if (err < 0)
1678                         return err;
1679         }
1680         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1681                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1682                                           NULL, alc_slave_sws);
1683                 if (err < 0)
1684                         return err;
1685         }
1686
1687         return 0;
1688 }
1689
1690
1691 /*
1692  * initialize the codec volumes, etc
1693  */
1694
1695 /*
1696  * generic initialization of ADC, input mixers and output mixers
1697  */
1698 static struct hda_verb alc880_volume_init_verbs[] = {
1699         /*
1700          * Unmute ADC0-2 and set the default input to mic-in
1701          */
1702         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
1703         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1704         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
1705         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1706         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
1707         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1708
1709         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1710          * mixer widget
1711          * Note: PASD motherboards uses the Line In 2 as the input for front
1712          * panel mic (mic 2)
1713          */
1714         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1715         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1716         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1717         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
1718         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
1719         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
1720         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
1721         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
1722
1723         /*
1724          * Set up output mixers (0x0c - 0x0f)
1725          */
1726         /* set vol=0 to output mixers */
1727         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1728         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1729         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1730         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1731         /* set up input amps for analog loopback */
1732         /* Amp Indices: DAC = 0, mixer = 1 */
1733         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1734         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1735         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1736         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1737         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1738         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1739         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1740         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1741
1742         { }
1743 };
1744
1745 /*
1746  * 3-stack pin configuration:
1747  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1748  */
1749 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1750         /*
1751          * preset connection lists of input pins
1752          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1753          */
1754         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1755         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1756         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1757
1758         /*
1759          * Set pin mode and muting
1760          */
1761         /* set front pin widgets 0x14 for output */
1762         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1763         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1764         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1765         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1766         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1767         /* Mic2 (as headphone out) for HP output */
1768         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1769         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1770         /* Line In pin widget for input */
1771         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1772         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1773         /* Line2 (as front mic) pin widget for input and vref at 80% */
1774         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1775         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1776         /* CD pin widget for input */
1777         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1778
1779         { }
1780 };
1781
1782 /*
1783  * 5-stack pin configuration:
1784  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1785  * line-in/side = 0x1a, f-mic = 0x1b
1786  */
1787 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1788         /*
1789          * preset connection lists of input pins
1790          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1791          */
1792         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1793         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1794
1795         /*
1796          * Set pin mode and muting
1797          */
1798         /* set pin widgets 0x14-0x17 for output */
1799         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1800         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1801         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1802         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1803         /* unmute pins for output (no gain on this amp) */
1804         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1805         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1806         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1807         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1808
1809         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1810         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1811         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1812         /* Mic2 (as headphone out) for HP output */
1813         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1814         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1815         /* Line In pin widget for input */
1816         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1817         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1818         /* Line2 (as front mic) pin widget for input and vref at 80% */
1819         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1820         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1821         /* CD pin widget for input */
1822         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1823
1824         { }
1825 };
1826
1827 /*
1828  * W810 pin configuration:
1829  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1830  */
1831 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1832         /* hphone/speaker input selector: front DAC */
1833         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1834
1835         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1836         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1837         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1838         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1839         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1840         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1841
1842         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1843         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1844
1845         { }
1846 };
1847
1848 /*
1849  * Z71V pin configuration:
1850  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1851  */
1852 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1853         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1854         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1855         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1856         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1857
1858         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1859         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1860         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1861         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1862
1863         { }
1864 };
1865
1866 /*
1867  * 6-stack pin configuration:
1868  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
1869  * f-mic = 0x19, line = 0x1a, HP = 0x1b
1870  */
1871 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1872         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1873
1874         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1875         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1876         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1877         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1878         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1879         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1880         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1881         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1882
1883         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1884         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1885         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1886         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1887         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1888         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1889         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1890         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1891         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1892
1893         { }
1894 };
1895
1896 /*
1897  * Uniwill pin configuration:
1898  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
1899  * line = 0x1a
1900  */
1901 static struct hda_verb alc880_uniwill_init_verbs[] = {
1902         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1903
1904         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1905         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1906         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1907         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1908         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1909         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1910         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1911         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1912         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1913         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1914         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1915         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1916         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1917         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1918
1919         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1920         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1921         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1922         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1923         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1924         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1925         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
1926         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
1927         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1928
1929         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1930         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
1931
1932         { }
1933 };
1934
1935 /*
1936 * Uniwill P53
1937 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
1938  */
1939 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
1940         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1941
1942         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1943         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1944         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1945         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1946         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1947         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1948         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1949         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1950         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1951         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1952         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
1953         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
1954
1955         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1956         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1957         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1958         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1959         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1960         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1961
1962         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
1963         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
1964
1965         { }
1966 };
1967
1968 static struct hda_verb alc880_beep_init_verbs[] = {
1969         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
1970         { }
1971 };
1972
1973 /* toggle speaker-output according to the hp-jack state */
1974 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
1975 {
1976         unsigned int present;
1977         unsigned char bits;
1978
1979         present = snd_hda_codec_read(codec, 0x14, 0,
1980                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1981         bits = present ? HDA_AMP_MUTE : 0;
1982         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1983                                  HDA_AMP_MUTE, bits);
1984         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
1985                                  HDA_AMP_MUTE, bits);
1986 }
1987
1988 /* auto-toggle front mic */
1989 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
1990 {
1991         unsigned int present;
1992         unsigned char bits;
1993
1994         present = snd_hda_codec_read(codec, 0x18, 0,
1995                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1996         bits = present ? HDA_AMP_MUTE : 0;
1997         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
1998 }
1999
2000 static void alc880_uniwill_automute(struct hda_codec *codec)
2001 {
2002         alc880_uniwill_hp_automute(codec);
2003         alc880_uniwill_mic_automute(codec);
2004 }
2005
2006 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2007                                        unsigned int res)
2008 {
2009         /* Looks like the unsol event is incompatible with the standard
2010          * definition.  4bit tag is placed at 28 bit!
2011          */
2012         switch (res >> 28) {
2013         case ALC880_HP_EVENT:
2014                 alc880_uniwill_hp_automute(codec);
2015                 break;
2016         case ALC880_MIC_EVENT:
2017                 alc880_uniwill_mic_automute(codec);
2018                 break;
2019         }
2020 }
2021
2022 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2023 {
2024         unsigned int present;
2025         unsigned char bits;
2026
2027         present = snd_hda_codec_read(codec, 0x14, 0,
2028                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2029         bits = present ? HDA_AMP_MUTE : 0;
2030         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2031 }
2032
2033 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2034 {
2035         unsigned int present;
2036
2037         present = snd_hda_codec_read(codec, 0x21, 0,
2038                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2039         present &= HDA_AMP_VOLMASK;
2040         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2041                                  HDA_AMP_VOLMASK, present);
2042         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2043                                  HDA_AMP_VOLMASK, present);
2044 }
2045
2046 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2047                                            unsigned int res)
2048 {
2049         /* Looks like the unsol event is incompatible with the standard
2050          * definition.  4bit tag is placed at 28 bit!
2051          */
2052         if ((res >> 28) == ALC880_HP_EVENT)
2053                 alc880_uniwill_p53_hp_automute(codec);
2054         if ((res >> 28) == ALC880_DCVOL_EVENT)
2055                 alc880_uniwill_p53_dcvol_automute(codec);
2056 }
2057
2058 /*
2059  * F1734 pin configuration:
2060  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2061  */
2062 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2063         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2064         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2065         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2066         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2067         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2068
2069         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2070         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2071         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2072         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2073
2074         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2075         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2076         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2077         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2078         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2079         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2080         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2081         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2082         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2083
2084         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2085         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2086
2087         { }
2088 };
2089
2090 /*
2091  * ASUS pin configuration:
2092  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2093  */
2094 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2095         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2096         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2097         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2098         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2099
2100         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2101         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2102         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2103         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2104         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2106         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2107         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2108
2109         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2110         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2111         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2112         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2113         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2114         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2115         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2116         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2117         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2118
2119         { }
2120 };
2121
2122 /* Enable GPIO mask and set output */
2123 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2124 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2125
2126 /* Clevo m520g init */
2127 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2128         /* headphone output */
2129         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2130         /* line-out */
2131         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2132         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2133         /* Line-in */
2134         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2135         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2136         /* CD */
2137         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2138         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2139         /* Mic1 (rear panel) */
2140         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2141         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2142         /* Mic2 (front panel) */
2143         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2144         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2145         /* headphone */
2146         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2147         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2148         /* change to EAPD mode */
2149         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2150         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2151
2152         { }
2153 };
2154
2155 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2156         /* change to EAPD mode */
2157         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2158         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2159
2160         /* Headphone output */
2161         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2162         /* Front output*/
2163         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2164         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2165
2166         /* Line In pin widget for input */
2167         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2168         /* CD pin widget for input */
2169         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2170         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2171         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2172
2173         /* change to EAPD mode */
2174         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2175         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2176
2177         { }
2178 };
2179
2180 /*
2181  * LG m1 express dual
2182  *
2183  * Pin assignment:
2184  *   Rear Line-In/Out (blue): 0x14
2185  *   Build-in Mic-In: 0x15
2186  *   Speaker-out: 0x17
2187  *   HP-Out (green): 0x1b
2188  *   Mic-In/Out (red): 0x19
2189  *   SPDIF-Out: 0x1e
2190  */
2191
2192 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2193 static hda_nid_t alc880_lg_dac_nids[3] = {
2194         0x05, 0x02, 0x03
2195 };
2196
2197 /* seems analog CD is not working */
2198 static struct hda_input_mux alc880_lg_capture_source = {
2199         .num_items = 3,
2200         .items = {
2201                 { "Mic", 0x1 },
2202                 { "Line", 0x5 },
2203                 { "Internal Mic", 0x6 },
2204         },
2205 };
2206
2207 /* 2,4,6 channel modes */
2208 static struct hda_verb alc880_lg_ch2_init[] = {
2209         /* set line-in and mic-in to input */
2210         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2211         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2212         { }
2213 };
2214
2215 static struct hda_verb alc880_lg_ch4_init[] = {
2216         /* set line-in to out and mic-in to input */
2217         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2218         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2219         { }
2220 };
2221
2222 static struct hda_verb alc880_lg_ch6_init[] = {
2223         /* set line-in and mic-in to output */
2224         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2225         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2226         { }
2227 };
2228
2229 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2230         { 2, alc880_lg_ch2_init },
2231         { 4, alc880_lg_ch4_init },
2232         { 6, alc880_lg_ch6_init },
2233 };
2234
2235 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2236         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2237         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2238         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2239         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2240         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2241         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2242         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2243         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2244         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2245         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2246         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2247         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2248         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2249         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2250         {
2251                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2252                 .name = "Channel Mode",
2253                 .info = alc_ch_mode_info,
2254                 .get = alc_ch_mode_get,
2255                 .put = alc_ch_mode_put,
2256         },
2257         { } /* end */
2258 };
2259
2260 static struct hda_verb alc880_lg_init_verbs[] = {
2261         /* set capture source to mic-in */
2262         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2263         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2264         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2265         /* mute all amp mixer inputs */
2266         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2267         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2268         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2269         /* line-in to input */
2270         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2271         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2272         /* built-in mic */
2273         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2274         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2275         /* speaker-out */
2276         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2277         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2278         /* mic-in to input */
2279         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2280         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2281         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2282         /* HP-out */
2283         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2284         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2285         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2286         /* jack sense */
2287         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2288         { }
2289 };
2290
2291 /* toggle speaker-output according to the hp-jack state */
2292 static void alc880_lg_automute(struct hda_codec *codec)
2293 {
2294         unsigned int present;
2295         unsigned char bits;
2296
2297         present = snd_hda_codec_read(codec, 0x1b, 0,
2298                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2299         bits = present ? HDA_AMP_MUTE : 0;
2300         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2301                                  HDA_AMP_MUTE, bits);
2302 }
2303
2304 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2305 {
2306         /* Looks like the unsol event is incompatible with the standard
2307          * definition.  4bit tag is placed at 28 bit!
2308          */
2309         if ((res >> 28) == 0x01)
2310                 alc880_lg_automute(codec);
2311 }
2312
2313 /*
2314  * LG LW20
2315  *
2316  * Pin assignment:
2317  *   Speaker-out: 0x14
2318  *   Mic-In: 0x18
2319  *   Built-in Mic-In: 0x19
2320  *   Line-In: 0x1b
2321  *   HP-Out: 0x1a
2322  *   SPDIF-Out: 0x1e
2323  */
2324
2325 static struct hda_input_mux alc880_lg_lw_capture_source = {
2326         .num_items = 3,
2327         .items = {
2328                 { "Mic", 0x0 },
2329                 { "Internal Mic", 0x1 },
2330                 { "Line In", 0x2 },
2331         },
2332 };
2333
2334 #define alc880_lg_lw_modes alc880_threestack_modes
2335
2336 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2337         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2338         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2339         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2340         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2341         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2342         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2343         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2344         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2345         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2346         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2348         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2349         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2350         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2351         {
2352                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2353                 .name = "Channel Mode",
2354                 .info = alc_ch_mode_info,
2355                 .get = alc_ch_mode_get,
2356                 .put = alc_ch_mode_put,
2357         },
2358         { } /* end */
2359 };
2360
2361 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2362         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2363         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2364         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2365
2366         /* set capture source to mic-in */
2367         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2368         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2369         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2370         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2371         /* speaker-out */
2372         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2373         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2374         /* HP-out */
2375         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2376         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2377         /* mic-in to input */
2378         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2379         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2380         /* built-in mic */
2381         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2382         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2383         /* jack sense */
2384         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2385         { }
2386 };
2387
2388 /* toggle speaker-output according to the hp-jack state */
2389 static void alc880_lg_lw_automute(struct hda_codec *codec)
2390 {
2391         unsigned int present;
2392         unsigned char bits;
2393
2394         present = snd_hda_codec_read(codec, 0x1b, 0,
2395                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2396         bits = present ? HDA_AMP_MUTE : 0;
2397         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2398                                  HDA_AMP_MUTE, bits);
2399 }
2400
2401 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2402 {
2403         /* Looks like the unsol event is incompatible with the standard
2404          * definition.  4bit tag is placed at 28 bit!
2405          */
2406         if ((res >> 28) == 0x01)
2407                 alc880_lg_lw_automute(codec);
2408 }
2409
2410 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2411         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2412         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2413         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2414         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2415         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2416         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2417         { } /* end */
2418 };
2419
2420 static struct hda_input_mux alc880_medion_rim_capture_source = {
2421         .num_items = 2,
2422         .items = {
2423                 { "Mic", 0x0 },
2424                 { "Internal Mic", 0x1 },
2425         },
2426 };
2427
2428 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2429         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2430
2431         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2432         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2433
2434         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2435         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2436         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2437         /* Mic2 (as headphone out) for HP output */
2438         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2439         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2440         /* Internal Speaker */
2441         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2442         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2443
2444         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2445         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2446
2447         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2448         { }
2449 };
2450
2451 /* toggle speaker-output according to the hp-jack state */
2452 static void alc880_medion_rim_automute(struct hda_codec *codec)
2453 {
2454         unsigned int present;
2455         unsigned char bits;
2456
2457         present = snd_hda_codec_read(codec, 0x14, 0,
2458                                      AC_VERB_GET_PIN_SENSE, 0)
2459                 & AC_PINSENSE_PRESENCE;
2460         bits = present ? HDA_AMP_MUTE : 0;
2461         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2462                                  HDA_AMP_MUTE, bits);
2463         if (present)
2464                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2465         else
2466                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2467 }
2468
2469 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2470                                           unsigned int res)
2471 {
2472         /* Looks like the unsol event is incompatible with the standard
2473          * definition.  4bit tag is placed at 28 bit!
2474          */
2475         if ((res >> 28) == ALC880_HP_EVENT)
2476                 alc880_medion_rim_automute(codec);
2477 }
2478
2479 #ifdef CONFIG_SND_HDA_POWER_SAVE
2480 static struct hda_amp_list alc880_loopbacks[] = {
2481         { 0x0b, HDA_INPUT, 0 },
2482         { 0x0b, HDA_INPUT, 1 },
2483         { 0x0b, HDA_INPUT, 2 },
2484         { 0x0b, HDA_INPUT, 3 },
2485         { 0x0b, HDA_INPUT, 4 },
2486         { } /* end */
2487 };
2488
2489 static struct hda_amp_list alc880_lg_loopbacks[] = {
2490         { 0x0b, HDA_INPUT, 1 },
2491         { 0x0b, HDA_INPUT, 6 },
2492         { 0x0b, HDA_INPUT, 7 },
2493         { } /* end */
2494 };
2495 #endif
2496
2497 /*
2498  * Common callbacks
2499  */
2500
2501 static int alc_init(struct hda_codec *codec)
2502 {
2503         struct alc_spec *spec = codec->spec;
2504         unsigned int i;
2505
2506         alc_fix_pll(codec);
2507         if (codec->vendor_id == 0x10ec0888)
2508                 alc888_coef_init(codec);
2509
2510         for (i = 0; i < spec->num_init_verbs; i++)
2511                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2512
2513         if (spec->init_hook)
2514                 spec->init_hook(codec);
2515
2516         return 0;
2517 }
2518
2519 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2520 {
2521         struct alc_spec *spec = codec->spec;
2522
2523         if (spec->unsol_event)
2524                 spec->unsol_event(codec, res);
2525 }
2526
2527 #ifdef CONFIG_SND_HDA_POWER_SAVE
2528 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2529 {
2530         struct alc_spec *spec = codec->spec;
2531         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2532 }
2533 #endif
2534
2535 /*
2536  * Analog playback callbacks
2537  */
2538 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2539                                     struct hda_codec *codec,
2540                                     struct snd_pcm_substream *substream)
2541 {
2542         struct alc_spec *spec = codec->spec;
2543         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2544                                              hinfo);
2545 }
2546
2547 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2548                                        struct hda_codec *codec,
2549                                        unsigned int stream_tag,
2550                                        unsigned int format,
2551                                        struct snd_pcm_substream *substream)
2552 {
2553         struct alc_spec *spec = codec->spec;
2554         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2555                                                 stream_tag, format, substream);
2556 }
2557
2558 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2559                                        struct hda_codec *codec,
2560                                        struct snd_pcm_substream *substream)
2561 {
2562         struct alc_spec *spec = codec->spec;
2563         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2564 }
2565
2566 /*
2567  * Digital out
2568  */
2569 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2570                                         struct hda_codec *codec,
2571                                         struct snd_pcm_substream *substream)
2572 {
2573         struct alc_spec *spec = codec->spec;
2574         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2575 }
2576
2577 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2578                                            struct hda_codec *codec,
2579                                            unsigned int stream_tag,
2580                                            unsigned int format,
2581                                            struct snd_pcm_substream *substream)
2582 {
2583         struct alc_spec *spec = codec->spec;
2584         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2585                                              stream_tag, format, substream);
2586 }
2587
2588 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2589                                          struct hda_codec *codec,
2590                                          struct snd_pcm_substream *substream)
2591 {
2592         struct alc_spec *spec = codec->spec;
2593         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2594 }
2595
2596 /*
2597  * Analog capture
2598  */
2599 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2600                                       struct hda_codec *codec,
2601                                       unsigned int stream_tag,
2602                                       unsigned int format,
2603                                       struct snd_pcm_substream *substream)
2604 {
2605         struct alc_spec *spec = codec->spec;
2606
2607         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2608                                    stream_tag, 0, format);
2609         return 0;
2610 }
2611
2612 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2613                                       struct hda_codec *codec,
2614                                       struct snd_pcm_substream *substream)
2615 {
2616         struct alc_spec *spec = codec->spec;
2617
2618         snd_hda_codec_cleanup_stream(codec,
2619                                      spec->adc_nids[substream->number + 1]);
2620         return 0;
2621 }
2622
2623
2624 /*
2625  */
2626 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2627         .substreams = 1,
2628         .channels_min = 2,
2629         .channels_max = 8,
2630         /* NID is set in alc_build_pcms */
2631         .ops = {
2632                 .open = alc880_playback_pcm_open,
2633                 .prepare = alc880_playback_pcm_prepare,
2634                 .cleanup = alc880_playback_pcm_cleanup
2635         },
2636 };
2637
2638 static struct hda_pcm_stream alc880_pcm_analog_capture = {
2639         .substreams = 1,
2640         .channels_min = 2,
2641         .channels_max = 2,
2642         /* NID is set in alc_build_pcms */
2643 };
2644
2645 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
2646         .substreams = 1,
2647         .channels_min = 2,
2648         .channels_max = 2,
2649         /* NID is set in alc_build_pcms */
2650 };
2651
2652 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
2653         .substreams = 2, /* can be overridden */
2654         .channels_min = 2,
2655         .channels_max = 2,
2656         /* NID is set in alc_build_pcms */
2657         .ops = {
2658                 .prepare = alc880_alt_capture_pcm_prepare,
2659                 .cleanup = alc880_alt_capture_pcm_cleanup
2660         },
2661 };
2662
2663 static struct hda_pcm_stream alc880_pcm_digital_playback = {
2664         .substreams = 1,
2665         .channels_min = 2,
2666         .channels_max = 2,
2667         /* NID is set in alc_build_pcms */
2668         .ops = {
2669                 .open = alc880_dig_playback_pcm_open,
2670                 .close = alc880_dig_playback_pcm_close,
2671                 .prepare = alc880_dig_playback_pcm_prepare
2672         },
2673 };
2674
2675 static struct hda_pcm_stream alc880_pcm_digital_capture = {
2676         .substreams = 1,
2677         .channels_min = 2,
2678         .channels_max = 2,
2679         /* NID is set in alc_build_pcms */
2680 };
2681
2682 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2683 static struct hda_pcm_stream alc_pcm_null_stream = {
2684         .substreams = 0,
2685         .channels_min = 0,
2686         .channels_max = 0,
2687 };
2688
2689 static int alc_build_pcms(struct hda_codec *codec)
2690 {
2691         struct alc_spec *spec = codec->spec;
2692         struct hda_pcm *info = spec->pcm_rec;
2693         int i;
2694
2695         codec->num_pcms = 1;
2696         codec->pcm_info = info;
2697
2698         info->name = spec->stream_name_analog;
2699         if (spec->stream_analog_playback) {
2700                 if (snd_BUG_ON(!spec->multiout.dac_nids))
2701                         return -EINVAL;
2702                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
2703                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2704         }
2705         if (spec->stream_analog_capture) {
2706                 if (snd_BUG_ON(!spec->adc_nids))
2707                         return -EINVAL;
2708                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
2709                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2710         }
2711
2712         if (spec->channel_mode) {
2713                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2714                 for (i = 0; i < spec->num_channel_mode; i++) {
2715                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2716                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2717                         }
2718                 }
2719         }
2720
2721         /* SPDIF for stream index #1 */
2722         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2723                 codec->num_pcms = 2;
2724                 info = spec->pcm_rec + 1;
2725                 info->name = spec->stream_name_digital;
2726                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2727                 if (spec->multiout.dig_out_nid &&
2728                     spec->stream_digital_playback) {
2729                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
2730                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2731                 }
2732                 if (spec->dig_in_nid &&
2733                     spec->stream_digital_capture) {
2734                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
2735                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2736                 }
2737                 /* FIXME: do we need this for all Realtek codec models? */
2738                 codec->spdif_status_reset = 1;
2739         }
2740
2741         /* If the use of more than one ADC is requested for the current
2742          * model, configure a second analog capture-only PCM.
2743          */
2744         /* Additional Analaog capture for index #2 */
2745         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
2746             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
2747                 codec->num_pcms = 3;
2748                 info = spec->pcm_rec + 2;
2749                 info->name = spec->stream_name_analog;
2750                 if (spec->alt_dac_nid) {
2751                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2752                                 *spec->stream_analog_alt_playback;
2753                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2754                                 spec->alt_dac_nid;
2755                 } else {
2756                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2757                                 alc_pcm_null_stream;
2758                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2759                 }
2760                 if (spec->num_adc_nids > 1) {
2761                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2762                                 *spec->stream_analog_alt_capture;
2763                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2764                                 spec->adc_nids[1];
2765                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2766                                 spec->num_adc_nids - 1;
2767                 } else {
2768                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2769                                 alc_pcm_null_stream;
2770                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2771                 }
2772         }
2773
2774         return 0;
2775 }
2776
2777 static void alc_free(struct hda_codec *codec)
2778 {
2779         struct alc_spec *spec = codec->spec;
2780         unsigned int i;
2781
2782         if (!spec)
2783                 return;
2784
2785         if (spec->kctl_alloc) {
2786                 for (i = 0; i < spec->num_kctl_used; i++)
2787                         kfree(spec->kctl_alloc[i].name);
2788                 kfree(spec->kctl_alloc);
2789         }
2790         kfree(spec);
2791         codec->spec = NULL; /* to be sure */
2792 }
2793
2794 #ifdef SND_HDA_NEEDS_RESUME
2795 static void store_pin_configs(struct hda_codec *codec)
2796 {
2797         struct alc_spec *spec = codec->spec;
2798         hda_nid_t nid, end_nid;
2799
2800         end_nid = codec->start_nid + codec->num_nodes;
2801         for (nid = codec->start_nid; nid < end_nid; nid++) {
2802                 unsigned int wid_caps = get_wcaps(codec, nid);
2803                 unsigned int wid_type =
2804                         (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
2805                 if (wid_type != AC_WID_PIN)
2806                         continue;
2807                 if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
2808                         break;
2809                 spec->pin_nids[spec->num_pins] = nid;
2810                 spec->pin_cfgs[spec->num_pins] =
2811                         snd_hda_codec_read(codec, nid, 0,
2812                                            AC_VERB_GET_CONFIG_DEFAULT, 0);
2813                 spec->num_pins++;
2814         }
2815 }
2816
2817 static void resume_pin_configs(struct hda_codec *codec)
2818 {
2819         struct alc_spec *spec = codec->spec;
2820         int i;
2821
2822         for (i = 0; i < spec->num_pins; i++) {
2823                 hda_nid_t pin_nid = spec->pin_nids[i];
2824                 unsigned int pin_config = spec->pin_cfgs[i];
2825                 snd_hda_codec_write(codec, pin_nid, 0,
2826                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
2827                                     pin_config & 0x000000ff);
2828                 snd_hda_codec_write(codec, pin_nid, 0,
2829                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
2830                                     (pin_config & 0x0000ff00) >> 8);
2831                 snd_hda_codec_write(codec, pin_nid, 0,
2832                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
2833                                     (pin_config & 0x00ff0000) >> 16);
2834                 snd_hda_codec_write(codec, pin_nid, 0,
2835                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
2836                                     pin_config >> 24);
2837         }
2838 }
2839
2840 static int alc_resume(struct hda_codec *codec)
2841 {
2842         resume_pin_configs(codec);
2843         codec->patch_ops.init(codec);
2844         snd_hda_codec_resume_amp(codec);
2845         snd_hda_codec_resume_cache(codec);
2846         return 0;
2847 }
2848 #else
2849 #define store_pin_configs(codec)
2850 #endif
2851
2852 /*
2853  */
2854 static struct hda_codec_ops alc_patch_ops = {
2855         .build_controls = alc_build_controls,
2856         .build_pcms = alc_build_pcms,
2857         .init = alc_init,
2858         .free = alc_free,
2859         .unsol_event = alc_unsol_event,
2860 #ifdef SND_HDA_NEEDS_RESUME
2861         .resume = alc_resume,
2862 #endif
2863 #ifdef CONFIG_SND_HDA_POWER_SAVE
2864         .check_power_status = alc_check_power_status,
2865 #endif
2866 };
2867
2868
2869 /*
2870  * Test configuration for debugging
2871  *
2872  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
2873  * enum controls.
2874  */
2875 #ifdef CONFIG_SND_DEBUG
2876 static hda_nid_t alc880_test_dac_nids[4] = {
2877         0x02, 0x03, 0x04, 0x05
2878 };
2879
2880 static struct hda_input_mux alc880_test_capture_source = {
2881         .num_items = 7,
2882         .items = {
2883                 { "In-1", 0x0 },
2884                 { "In-2", 0x1 },
2885                 { "In-3", 0x2 },
2886                 { "In-4", 0x3 },
2887                 { "CD", 0x4 },
2888                 { "Front", 0x5 },
2889                 { "Surround", 0x6 },
2890         },
2891 };
2892
2893 static struct hda_channel_mode alc880_test_modes[4] = {
2894         { 2, NULL },
2895         { 4, NULL },
2896         { 6, NULL },
2897         { 8, NULL },
2898 };
2899
2900 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
2901                                  struct snd_ctl_elem_info *uinfo)
2902 {
2903         static char *texts[] = {
2904                 "N/A", "Line Out", "HP Out",
2905                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
2906         };
2907         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2908         uinfo->count = 1;
2909         uinfo->value.enumerated.items = 8;
2910         if (uinfo->value.enumerated.item >= 8)
2911                 uinfo->value.enumerated.item = 7;
2912         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2913         return 0;
2914 }
2915
2916 static int alc_test_pin_ctl_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 pin_ctl, item = 0;
2922
2923         pin_ctl = snd_hda_codec_read(codec, nid, 0,
2924                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2925         if (pin_ctl & AC_PINCTL_OUT_EN) {
2926                 if (pin_ctl & AC_PINCTL_HP_EN)
2927                         item = 2;
2928                 else
2929                         item = 1;
2930         } else if (pin_ctl & AC_PINCTL_IN_EN) {
2931                 switch (pin_ctl & AC_PINCTL_VREFEN) {
2932                 case AC_PINCTL_VREF_HIZ: item = 3; break;
2933                 case AC_PINCTL_VREF_50:  item = 4; break;
2934                 case AC_PINCTL_VREF_GRD: item = 5; break;
2935                 case AC_PINCTL_VREF_80:  item = 6; break;
2936                 case AC_PINCTL_VREF_100: item = 7; break;
2937                 }
2938         }
2939         ucontrol->value.enumerated.item[0] = item;
2940         return 0;
2941 }
2942
2943 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
2944                                 struct snd_ctl_elem_value *ucontrol)
2945 {
2946         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2947         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2948         static unsigned int ctls[] = {
2949                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
2950                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
2951                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
2952                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
2953                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
2954                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
2955         };
2956         unsigned int old_ctl, new_ctl;
2957
2958         old_ctl = snd_hda_codec_read(codec, nid, 0,
2959                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
2960         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
2961         if (old_ctl != new_ctl) {
2962                 int val;
2963                 snd_hda_codec_write_cache(codec, nid, 0,
2964                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
2965                                           new_ctl);
2966                 val = ucontrol->value.enumerated.item[0] >= 3 ?
2967                         HDA_AMP_MUTE : 0;
2968                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
2969                                          HDA_AMP_MUTE, val);
2970                 return 1;
2971         }
2972         return 0;
2973 }
2974
2975 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
2976                                  struct snd_ctl_elem_info *uinfo)
2977 {
2978         static char *texts[] = {
2979                 "Front", "Surround", "CLFE", "Side"
2980         };
2981         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2982         uinfo->count = 1;
2983         uinfo->value.enumerated.items = 4;
2984         if (uinfo->value.enumerated.item >= 4)
2985                 uinfo->value.enumerated.item = 3;
2986         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2987         return 0;
2988 }
2989
2990 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
2991                                 struct snd_ctl_elem_value *ucontrol)
2992 {
2993         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2994         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
2995         unsigned int sel;
2996
2997         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
2998         ucontrol->value.enumerated.item[0] = sel & 3;
2999         return 0;
3000 }
3001
3002 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3003                                 struct snd_ctl_elem_value *ucontrol)
3004 {
3005         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3006         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3007         unsigned int sel;
3008
3009         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3010         if (ucontrol->value.enumerated.item[0] != sel) {
3011                 sel = ucontrol->value.enumerated.item[0] & 3;
3012                 snd_hda_codec_write_cache(codec, nid, 0,
3013                                           AC_VERB_SET_CONNECT_SEL, sel);
3014                 return 1;
3015         }
3016         return 0;
3017 }
3018
3019 #define PIN_CTL_TEST(xname,nid) {                       \
3020                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3021                         .name = xname,                 \
3022                         .info = alc_test_pin_ctl_info, \
3023                         .get = alc_test_pin_ctl_get,   \
3024                         .put = alc_test_pin_ctl_put,   \
3025                         .private_value = nid           \
3026                         }
3027
3028 #define PIN_SRC_TEST(xname,nid) {                       \
3029                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3030                         .name = xname,                 \
3031                         .info = alc_test_pin_src_info, \
3032                         .get = alc_test_pin_src_get,   \
3033                         .put = alc_test_pin_src_put,   \
3034                         .private_value = nid           \
3035                         }
3036
3037 static struct snd_kcontrol_new alc880_test_mixer[] = {
3038         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3039         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3040         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3041         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3042         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3043         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3044         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3045         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3046         PIN_CTL_TEST("Front Pin Mode", 0x14),
3047         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3048         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3049         PIN_CTL_TEST("Side Pin Mode", 0x17),
3050         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3051         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3052         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3053         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3054         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3055         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3056         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3057         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3058         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3059         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3060         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3061         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3062         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3063         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3064         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3065         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3066         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3067         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3068         {
3069                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3070                 .name = "Channel Mode",
3071                 .info = alc_ch_mode_info,
3072                 .get = alc_ch_mode_get,
3073                 .put = alc_ch_mode_put,
3074         },
3075         { } /* end */
3076 };
3077
3078 static struct hda_verb alc880_test_init_verbs[] = {
3079         /* Unmute inputs of 0x0c - 0x0f */
3080         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3081         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3082         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3083         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3084         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3085         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3086         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3087         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3088         /* Vol output for 0x0c-0x0f */
3089         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3090         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3091         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3092         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3093         /* Set output pins 0x14-0x17 */
3094         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3095         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3096         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3097         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3098         /* Unmute output pins 0x14-0x17 */
3099         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3100         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3101         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3102         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3103         /* Set input pins 0x18-0x1c */
3104         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3105         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3106         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3107         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3108         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3109         /* Mute input pins 0x18-0x1b */
3110         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3111         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3112         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3113         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3114         /* ADC set up */
3115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3116         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3117         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3118         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3119         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3120         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3121         /* Analog input/passthru */
3122         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3123         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3124         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3125         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3126         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3127         { }
3128 };
3129 #endif
3130
3131 /*
3132  */
3133
3134 static const char *alc880_models[ALC880_MODEL_LAST] = {
3135         [ALC880_3ST]            = "3stack",
3136         [ALC880_TCL_S700]       = "tcl",
3137         [ALC880_3ST_DIG]        = "3stack-digout",
3138         [ALC880_CLEVO]          = "clevo",
3139         [ALC880_5ST]            = "5stack",
3140         [ALC880_5ST_DIG]        = "5stack-digout",
3141         [ALC880_W810]           = "w810",
3142         [ALC880_Z71V]           = "z71v",
3143         [ALC880_6ST]            = "6stack",
3144         [ALC880_6ST_DIG]        = "6stack-digout",
3145         [ALC880_ASUS]           = "asus",
3146         [ALC880_ASUS_W1V]       = "asus-w1v",
3147         [ALC880_ASUS_DIG]       = "asus-dig",
3148         [ALC880_ASUS_DIG2]      = "asus-dig2",
3149         [ALC880_UNIWILL_DIG]    = "uniwill",
3150         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3151         [ALC880_FUJITSU]        = "fujitsu",
3152         [ALC880_F1734]          = "F1734",
3153         [ALC880_LG]             = "lg",
3154         [ALC880_LG_LW]          = "lg-lw",
3155         [ALC880_MEDION_RIM]     = "medion",
3156 #ifdef CONFIG_SND_DEBUG
3157         [ALC880_TEST]           = "test",
3158 #endif
3159         [ALC880_AUTO]           = "auto",
3160 };
3161
3162 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3163         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3164         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3165         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3166         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3167         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3168         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3169         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3170         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3171         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3172         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3173         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3174         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3175         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3176         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3177         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3178         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3179         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3180         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3181         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3182         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3183         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3184         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3185         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3186         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3187         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3188         SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3189         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3190         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3191         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3192         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3193         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3194         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3195         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3196         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3197         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3198         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3199         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3200         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3201         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3202         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3203         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3204         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3205         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3206         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3207         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3208         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3209         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3210         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3211         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3212         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3213         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3214         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3215         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3216         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3217         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3218         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3219         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3220         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3221         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3222         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3223         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3224         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3225         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3226         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3227         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3228         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3229         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3230         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3231         SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3232         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3233         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3234         {}
3235 };
3236
3237 /*
3238  * ALC880 codec presets
3239  */
3240 static struct alc_config_preset alc880_presets[] = {
3241         [ALC880_3ST] = {
3242                 .mixers = { alc880_three_stack_mixer },
3243                 .init_verbs = { alc880_volume_init_verbs,
3244                                 alc880_pin_3stack_init_verbs },
3245                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3246                 .dac_nids = alc880_dac_nids,
3247                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3248                 .channel_mode = alc880_threestack_modes,
3249                 .need_dac_fix = 1,
3250                 .input_mux = &alc880_capture_source,
3251         },
3252         [ALC880_3ST_DIG] = {
3253                 .mixers = { alc880_three_stack_mixer },
3254                 .init_verbs = { alc880_volume_init_verbs,
3255                                 alc880_pin_3stack_init_verbs },
3256                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3257                 .dac_nids = alc880_dac_nids,
3258                 .dig_out_nid = ALC880_DIGOUT_NID,
3259                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3260                 .channel_mode = alc880_threestack_modes,
3261                 .need_dac_fix = 1,
3262                 .input_mux = &alc880_capture_source,
3263         },
3264         [ALC880_TCL_S700] = {
3265                 .mixers = { alc880_tcl_s700_mixer },
3266                 .init_verbs = { alc880_volume_init_verbs,
3267                                 alc880_pin_tcl_S700_init_verbs,
3268                                 alc880_gpio2_init_verbs },
3269                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3270                 .dac_nids = alc880_dac_nids,
3271                 .hp_nid = 0x03,
3272                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3273                 .channel_mode = alc880_2_jack_modes,
3274                 .input_mux = &alc880_capture_source,
3275         },
3276         [ALC880_5ST] = {
3277                 .mixers = { alc880_three_stack_mixer,
3278                             alc880_five_stack_mixer},
3279                 .init_verbs = { alc880_volume_init_verbs,
3280                                 alc880_pin_5stack_init_verbs },
3281                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3282                 .dac_nids = alc880_dac_nids,
3283                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3284                 .channel_mode = alc880_fivestack_modes,
3285                 .input_mux = &alc880_capture_source,
3286         },
3287         [ALC880_5ST_DIG] = {
3288                 .mixers = { alc880_three_stack_mixer,
3289                             alc880_five_stack_mixer },
3290                 .init_verbs = { alc880_volume_init_verbs,
3291                                 alc880_pin_5stack_init_verbs },
3292                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3293                 .dac_nids = alc880_dac_nids,
3294                 .dig_out_nid = ALC880_DIGOUT_NID,
3295                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3296                 .channel_mode = alc880_fivestack_modes,
3297                 .input_mux = &alc880_capture_source,
3298         },
3299         [ALC880_6ST] = {
3300                 .mixers = { alc880_six_stack_mixer },
3301                 .init_verbs = { alc880_volume_init_verbs,
3302                                 alc880_pin_6stack_init_verbs },
3303                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3304                 .dac_nids = alc880_6st_dac_nids,
3305                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3306                 .channel_mode = alc880_sixstack_modes,
3307                 .input_mux = &alc880_6stack_capture_source,
3308         },
3309         [ALC880_6ST_DIG] = {
3310                 .mixers = { alc880_six_stack_mixer },
3311                 .init_verbs = { alc880_volume_init_verbs,
3312                                 alc880_pin_6stack_init_verbs },
3313                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3314                 .dac_nids = alc880_6st_dac_nids,
3315                 .dig_out_nid = ALC880_DIGOUT_NID,
3316                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3317                 .channel_mode = alc880_sixstack_modes,
3318                 .input_mux = &alc880_6stack_capture_source,
3319         },
3320         [ALC880_W810] = {
3321                 .mixers = { alc880_w810_base_mixer },
3322                 .init_verbs = { alc880_volume_init_verbs,
3323                                 alc880_pin_w810_init_verbs,
3324                                 alc880_gpio2_init_verbs },
3325                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3326                 .dac_nids = alc880_w810_dac_nids,
3327                 .dig_out_nid = ALC880_DIGOUT_NID,
3328                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3329                 .channel_mode = alc880_w810_modes,
3330                 .input_mux = &alc880_capture_source,
3331         },
3332         [ALC880_Z71V] = {
3333                 .mixers = { alc880_z71v_mixer },
3334                 .init_verbs = { alc880_volume_init_verbs,
3335                                 alc880_pin_z71v_init_verbs },
3336                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3337                 .dac_nids = alc880_z71v_dac_nids,
3338                 .dig_out_nid = ALC880_DIGOUT_NID,
3339                 .hp_nid = 0x03,
3340                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3341                 .channel_mode = alc880_2_jack_modes,
3342                 .input_mux = &alc880_capture_source,
3343         },
3344         [ALC880_F1734] = {
3345                 .mixers = { alc880_f1734_mixer },
3346                 .init_verbs = { alc880_volume_init_verbs,
3347                                 alc880_pin_f1734_init_verbs },
3348                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3349                 .dac_nids = alc880_f1734_dac_nids,
3350                 .hp_nid = 0x02,
3351                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3352                 .channel_mode = alc880_2_jack_modes,
3353                 .input_mux = &alc880_f1734_capture_source,
3354                 .unsol_event = alc880_uniwill_p53_unsol_event,
3355                 .init_hook = alc880_uniwill_p53_hp_automute,
3356         },
3357         [ALC880_ASUS] = {
3358                 .mixers = { alc880_asus_mixer },
3359                 .init_verbs = { alc880_volume_init_verbs,
3360                                 alc880_pin_asus_init_verbs,
3361                                 alc880_gpio1_init_verbs },
3362                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3363                 .dac_nids = alc880_asus_dac_nids,
3364                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3365                 .channel_mode = alc880_asus_modes,
3366                 .need_dac_fix = 1,
3367                 .input_mux = &alc880_capture_source,
3368         },
3369         [ALC880_ASUS_DIG] = {
3370                 .mixers = { alc880_asus_mixer },
3371                 .init_verbs = { alc880_volume_init_verbs,
3372                                 alc880_pin_asus_init_verbs,
3373                                 alc880_gpio1_init_verbs },
3374                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3375                 .dac_nids = alc880_asus_dac_nids,
3376                 .dig_out_nid = ALC880_DIGOUT_NID,
3377                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3378                 .channel_mode = alc880_asus_modes,
3379                 .need_dac_fix = 1,
3380                 .input_mux = &alc880_capture_source,
3381         },
3382         [ALC880_ASUS_DIG2] = {
3383                 .mixers = { alc880_asus_mixer },
3384                 .init_verbs = { alc880_volume_init_verbs,
3385                                 alc880_pin_asus_init_verbs,
3386                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3387                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3388                 .dac_nids = alc880_asus_dac_nids,
3389                 .dig_out_nid = ALC880_DIGOUT_NID,
3390                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3391                 .channel_mode = alc880_asus_modes,
3392                 .need_dac_fix = 1,
3393                 .input_mux = &alc880_capture_source,
3394         },
3395         [ALC880_ASUS_W1V] = {
3396                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3397                 .init_verbs = { alc880_volume_init_verbs,
3398                                 alc880_pin_asus_init_verbs,
3399                                 alc880_gpio1_init_verbs },
3400                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3401                 .dac_nids = alc880_asus_dac_nids,
3402                 .dig_out_nid = ALC880_DIGOUT_NID,
3403                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3404                 .channel_mode = alc880_asus_modes,
3405                 .need_dac_fix = 1,
3406                 .input_mux = &alc880_capture_source,
3407         },
3408         [ALC880_UNIWILL_DIG] = {
3409                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3410                 .init_verbs = { alc880_volume_init_verbs,
3411                                 alc880_pin_asus_init_verbs },
3412                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3413                 .dac_nids = alc880_asus_dac_nids,
3414                 .dig_out_nid = ALC880_DIGOUT_NID,
3415                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3416                 .channel_mode = alc880_asus_modes,
3417                 .need_dac_fix = 1,
3418                 .input_mux = &alc880_capture_source,
3419         },
3420         [ALC880_UNIWILL] = {
3421                 .mixers = { alc880_uniwill_mixer },
3422                 .init_verbs = { alc880_volume_init_verbs,
3423                                 alc880_uniwill_init_verbs },
3424                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3425                 .dac_nids = alc880_asus_dac_nids,
3426                 .dig_out_nid = ALC880_DIGOUT_NID,
3427                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3428                 .channel_mode = alc880_threestack_modes,
3429                 .need_dac_fix = 1,
3430                 .input_mux = &alc880_capture_source,
3431                 .unsol_event = alc880_uniwill_unsol_event,
3432                 .init_hook = alc880_uniwill_automute,
3433         },
3434         [ALC880_UNIWILL_P53] = {
3435                 .mixers = { alc880_uniwill_p53_mixer },
3436                 .init_verbs = { alc880_volume_init_verbs,
3437                                 alc880_uniwill_p53_init_verbs },
3438                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3439                 .dac_nids = alc880_asus_dac_nids,
3440                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3441                 .channel_mode = alc880_threestack_modes,
3442                 .input_mux = &alc880_capture_source,
3443                 .unsol_event = alc880_uniwill_p53_unsol_event,
3444                 .init_hook = alc880_uniwill_p53_hp_automute,
3445         },
3446         [ALC880_FUJITSU] = {
3447                 .mixers = { alc880_fujitsu_mixer,
3448                             alc880_pcbeep_mixer, },
3449                 .init_verbs = { alc880_volume_init_verbs,
3450                                 alc880_uniwill_p53_init_verbs,
3451                                 alc880_beep_init_verbs },
3452                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3453                 .dac_nids = alc880_dac_nids,
3454                 .dig_out_nid = ALC880_DIGOUT_NID,
3455                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3456                 .channel_mode = alc880_2_jack_modes,
3457                 .input_mux = &alc880_capture_source,
3458                 .unsol_event = alc880_uniwill_p53_unsol_event,
3459                 .init_hook = alc880_uniwill_p53_hp_automute,
3460         },
3461         [ALC880_CLEVO] = {
3462                 .mixers = { alc880_three_stack_mixer },
3463                 .init_verbs = { alc880_volume_init_verbs,
3464                                 alc880_pin_clevo_init_verbs },
3465                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3466                 .dac_nids = alc880_dac_nids,
3467                 .hp_nid = 0x03,
3468                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3469                 .channel_mode = alc880_threestack_modes,
3470                 .need_dac_fix = 1,
3471                 .input_mux = &alc880_capture_source,
3472         },
3473         [ALC880_LG] = {
3474                 .mixers = { alc880_lg_mixer },
3475                 .init_verbs = { alc880_volume_init_verbs,
3476                                 alc880_lg_init_verbs },
3477                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3478                 .dac_nids = alc880_lg_dac_nids,
3479                 .dig_out_nid = ALC880_DIGOUT_NID,
3480                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3481                 .channel_mode = alc880_lg_ch_modes,
3482                 .need_dac_fix = 1,
3483                 .input_mux = &alc880_lg_capture_source,
3484                 .unsol_event = alc880_lg_unsol_event,
3485                 .init_hook = alc880_lg_automute,
3486 #ifdef CONFIG_SND_HDA_POWER_SAVE
3487                 .loopbacks = alc880_lg_loopbacks,
3488 #endif
3489         },
3490         [ALC880_LG_LW] = {
3491                 .mixers = { alc880_lg_lw_mixer },
3492                 .init_verbs = { alc880_volume_init_verbs,
3493                                 alc880_lg_lw_init_verbs },
3494                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3495                 .dac_nids = alc880_dac_nids,
3496                 .dig_out_nid = ALC880_DIGOUT_NID,
3497                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3498                 .channel_mode = alc880_lg_lw_modes,
3499                 .input_mux = &alc880_lg_lw_capture_source,
3500                 .unsol_event = alc880_lg_lw_unsol_event,
3501                 .init_hook = alc880_lg_lw_automute,
3502         },
3503         [ALC880_MEDION_RIM] = {
3504                 .mixers = { alc880_medion_rim_mixer },
3505                 .init_verbs = { alc880_volume_init_verbs,
3506                                 alc880_medion_rim_init_verbs,
3507                                 alc_gpio2_init_verbs },
3508                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3509                 .dac_nids = alc880_dac_nids,
3510                 .dig_out_nid = ALC880_DIGOUT_NID,
3511                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3512                 .channel_mode = alc880_2_jack_modes,
3513                 .input_mux = &alc880_medion_rim_capture_source,
3514                 .unsol_event = alc880_medion_rim_unsol_event,
3515                 .init_hook = alc880_medion_rim_automute,
3516         },
3517 #ifdef CONFIG_SND_DEBUG
3518         [ALC880_TEST] = {
3519                 .mixers = { alc880_test_mixer },
3520                 .init_verbs = { alc880_test_init_verbs },
3521                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3522                 .dac_nids = alc880_test_dac_nids,
3523                 .dig_out_nid = ALC880_DIGOUT_NID,
3524                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3525                 .channel_mode = alc880_test_modes,
3526                 .input_mux = &alc880_test_capture_source,
3527         },
3528 #endif
3529 };
3530
3531 /*
3532  * Automatic parse of I/O pins from the BIOS configuration
3533  */
3534
3535 #define NUM_CONTROL_ALLOC       32
3536 #define NUM_VERB_ALLOC          32
3537
3538 enum {
3539         ALC_CTL_WIDGET_VOL,
3540         ALC_CTL_WIDGET_MUTE,
3541         ALC_CTL_BIND_MUTE,
3542 };
3543 static struct snd_kcontrol_new alc880_control_templates[] = {
3544         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3545         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3546         HDA_BIND_MUTE(NULL, 0, 0, 0),
3547 };
3548
3549 /* add dynamic controls */
3550 static int add_control(struct alc_spec *spec, int type, const char *name,
3551                        unsigned long val)
3552 {
3553         struct snd_kcontrol_new *knew;
3554
3555         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
3556                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
3557
3558                 /* array + terminator */
3559                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
3560                 if (!knew)
3561                         return -ENOMEM;
3562                 if (spec->kctl_alloc) {
3563                         memcpy(knew, spec->kctl_alloc,
3564                                sizeof(*knew) * spec->num_kctl_alloc);
3565                         kfree(spec->kctl_alloc);
3566                 }
3567                 spec->kctl_alloc = knew;
3568                 spec->num_kctl_alloc = num;
3569         }
3570
3571         knew = &spec->kctl_alloc[spec->num_kctl_used];
3572         *knew = alc880_control_templates[type];
3573         knew->name = kstrdup(name, GFP_KERNEL);
3574         if (!knew->name)
3575                 return -ENOMEM;
3576         knew->private_value = val;
3577         spec->num_kctl_used++;
3578         return 0;
3579 }
3580
3581 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3582 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3583 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3584 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3585 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3586 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3587 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3588 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3589 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3590 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3591 #define ALC880_PIN_CD_NID               0x1c
3592
3593 /* fill in the dac_nids table from the parsed pin configuration */
3594 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3595                                      const struct auto_pin_cfg *cfg)
3596 {
3597         hda_nid_t nid;
3598         int assigned[4];
3599         int i, j;
3600
3601         memset(assigned, 0, sizeof(assigned));
3602         spec->multiout.dac_nids = spec->private_dac_nids;
3603
3604         /* check the pins hardwired to audio widget */
3605         for (i = 0; i < cfg->line_outs; i++) {
3606                 nid = cfg->line_out_pins[i];
3607                 if (alc880_is_fixed_pin(nid)) {
3608                         int idx = alc880_fixed_pin_idx(nid);
3609                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3610                         assigned[idx] = 1;
3611                 }
3612         }
3613         /* left pins can be connect to any audio widget */
3614         for (i = 0; i < cfg->line_outs; i++) {
3615                 nid = cfg->line_out_pins[i];
3616                 if (alc880_is_fixed_pin(nid))
3617                         continue;
3618                 /* search for an empty channel */
3619                 for (j = 0; j < cfg->line_outs; j++) {
3620                         if (!assigned[j]) {
3621                                 spec->multiout.dac_nids[i] =
3622                                         alc880_idx_to_dac(j);
3623                                 assigned[j] = 1;
3624                                 break;
3625                         }
3626                 }
3627         }
3628         spec->multiout.num_dacs = cfg->line_outs;
3629         return 0;
3630 }
3631
3632 /* add playback controls from the parsed DAC table */
3633 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3634                                              const struct auto_pin_cfg *cfg)
3635 {
3636         char name[32];
3637         static const char *chname[4] = {
3638                 "Front", "Surround", NULL /*CLFE*/, "Side"
3639         };
3640         hda_nid_t nid;
3641         int i, err;
3642
3643         for (i = 0; i < cfg->line_outs; i++) {
3644                 if (!spec->multiout.dac_nids[i])
3645                         continue;
3646                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3647                 if (i == 2) {
3648                         /* Center/LFE */
3649                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3650                                           "Center Playback Volume",
3651                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3652                                                               HDA_OUTPUT));
3653                         if (err < 0)
3654                                 return err;
3655                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3656                                           "LFE Playback Volume",
3657                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
3658                                                               HDA_OUTPUT));
3659                         if (err < 0)
3660                                 return err;
3661                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3662                                           "Center Playback Switch",
3663                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
3664                                                               HDA_INPUT));
3665                         if (err < 0)
3666                                 return err;
3667                         err = add_control(spec, ALC_CTL_BIND_MUTE,
3668                                           "LFE Playback Switch",
3669                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
3670                                                               HDA_INPUT));
3671                         if (err < 0)
3672                                 return err;
3673                 } else {
3674                         sprintf(name, "%s Playback Volume", chname[i]);
3675                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3676                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3677                                                               HDA_OUTPUT));
3678                         if (err < 0)
3679                                 return err;
3680                         sprintf(name, "%s Playback Switch", chname[i]);
3681                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3682                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
3683                                                               HDA_INPUT));
3684                         if (err < 0)
3685                                 return err;
3686                 }
3687         }
3688         return 0;
3689 }
3690
3691 /* add playback controls for speaker and HP outputs */
3692 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
3693                                         const char *pfx)
3694 {
3695         hda_nid_t nid;
3696         int err;
3697         char name[32];
3698
3699         if (!pin)
3700                 return 0;
3701
3702         if (alc880_is_fixed_pin(pin)) {
3703                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
3704                 /* specify the DAC as the extra output */
3705                 if (!spec->multiout.hp_nid)
3706                         spec->multiout.hp_nid = nid;
3707                 else
3708                         spec->multiout.extra_out_nid[0] = nid;
3709                 /* control HP volume/switch on the output mixer amp */
3710                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
3711                 sprintf(name, "%s Playback Volume", pfx);
3712                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3713                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
3714                 if (err < 0)
3715                         return err;
3716                 sprintf(name, "%s Playback Switch", pfx);
3717                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
3718                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
3719                 if (err < 0)
3720                         return err;
3721         } else if (alc880_is_multi_pin(pin)) {
3722                 /* set manual connection */
3723                 /* we have only a switch on HP-out PIN */
3724                 sprintf(name, "%s Playback Switch", pfx);
3725                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3726                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3727                 if (err < 0)
3728                         return err;
3729         }
3730         return 0;
3731 }
3732
3733 /* create input playback/capture controls for the given pin */
3734 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
3735                             const char *ctlname,
3736                             int idx, hda_nid_t mix_nid)
3737 {
3738         char name[32];
3739         int err;
3740
3741         sprintf(name, "%s Playback Volume", ctlname);
3742         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
3743                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3744         if (err < 0)
3745                 return err;
3746         sprintf(name, "%s Playback Switch", ctlname);
3747         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
3748                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
3749         if (err < 0)
3750                 return err;
3751         return 0;
3752 }
3753
3754 /* create playback/capture controls for input pins */
3755 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
3756                                                 const struct auto_pin_cfg *cfg)
3757 {
3758         struct hda_input_mux *imux = &spec->private_imux;
3759         int i, err, idx;
3760
3761         for (i = 0; i < AUTO_PIN_LAST; i++) {
3762                 if (alc880_is_input_pin(cfg->input_pins[i])) {
3763                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
3764                         err = new_analog_input(spec, cfg->input_pins[i],
3765                                                auto_pin_cfg_labels[i],
3766                                                idx, 0x0b);
3767                         if (err < 0)
3768                                 return err;
3769                         imux->items[imux->num_items].label =
3770                                 auto_pin_cfg_labels[i];
3771                         imux->items[imux->num_items].index =
3772                                 alc880_input_pin_idx(cfg->input_pins[i]);
3773                         imux->num_items++;
3774                 }
3775         }
3776         return 0;
3777 }
3778
3779 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
3780                                unsigned int pin_type)
3781 {
3782         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3783                             pin_type);
3784         /* unmute pin */
3785         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3786                             AMP_OUT_UNMUTE);
3787 }
3788
3789 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
3790                                               hda_nid_t nid, int pin_type,
3791                                               int dac_idx)
3792 {
3793         alc_set_pin_output(codec, nid, pin_type);
3794         /* need the manual connection? */
3795         if (alc880_is_multi_pin(nid)) {
3796                 struct alc_spec *spec = codec->spec;
3797                 int idx = alc880_multi_pin_idx(nid);
3798                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
3799                                     AC_VERB_SET_CONNECT_SEL,
3800                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
3801         }
3802 }
3803
3804 static int get_pin_type(int line_out_type)
3805 {
3806         if (line_out_type == AUTO_PIN_HP_OUT)
3807                 return PIN_HP;
3808         else
3809                 return PIN_OUT;
3810 }
3811
3812 static void alc880_auto_init_multi_out(struct hda_codec *codec)
3813 {
3814         struct alc_spec *spec = codec->spec;
3815         int i;
3816
3817         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
3818         for (i = 0; i < spec->autocfg.line_outs; i++) {
3819                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3820                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3821                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
3822         }
3823 }
3824
3825 static void alc880_auto_init_extra_out(struct hda_codec *codec)
3826 {
3827         struct alc_spec *spec = codec->spec;
3828         hda_nid_t pin;
3829
3830         pin = spec->autocfg.speaker_pins[0];
3831         if (pin) /* connect to front */
3832                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
3833         pin = spec->autocfg.hp_pins[0];
3834         if (pin) /* connect to front */
3835                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
3836 }
3837
3838 static void alc880_auto_init_analog_input(struct hda_codec *codec)
3839 {
3840         struct alc_spec *spec = codec->spec;
3841         int i;
3842
3843         for (i = 0; i < AUTO_PIN_LAST; i++) {
3844                 hda_nid_t nid = spec->autocfg.input_pins[i];
3845                 if (alc880_is_input_pin(nid)) {
3846                         snd_hda_codec_write(codec, nid, 0,
3847                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
3848                                             i <= AUTO_PIN_FRONT_MIC ?
3849                                             PIN_VREF80 : PIN_IN);
3850                         if (nid != ALC880_PIN_CD_NID)
3851                                 snd_hda_codec_write(codec, nid, 0,
3852                                                     AC_VERB_SET_AMP_GAIN_MUTE,
3853                                                     AMP_OUT_MUTE);
3854                 }
3855         }
3856 }
3857
3858 /* parse the BIOS configuration and set up the alc_spec */
3859 /* return 1 if successful, 0 if the proper config is not found,
3860  * or a negative error code
3861  */
3862 static int alc880_parse_auto_config(struct hda_codec *codec)
3863 {
3864         struct alc_spec *spec = codec->spec;
3865         int err;
3866         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3867
3868         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3869                                            alc880_ignore);
3870         if (err < 0)
3871                 return err;
3872         if (!spec->autocfg.line_outs)
3873                 return 0; /* can't find valid BIOS pin config */
3874
3875         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
3876         if (err < 0)
3877                 return err;
3878         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
3879         if (err < 0)
3880                 return err;
3881         err = alc880_auto_create_extra_out(spec,
3882                                            spec->autocfg.speaker_pins[0],
3883                                            "Speaker");
3884         if (err < 0)
3885                 return err;
3886         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
3887                                            "Headphone");
3888         if (err < 0)
3889                 return err;
3890         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
3891         if (err < 0)
3892                 return err;
3893
3894         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3895
3896         if (spec->autocfg.dig_out_pin)
3897                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
3898         if (spec->autocfg.dig_in_pin)
3899                 spec->dig_in_nid = ALC880_DIGIN_NID;
3900
3901         if (spec->kctl_alloc)
3902                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3903
3904         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
3905
3906         spec->num_mux_defs = 1;
3907         spec->input_mux = &spec->private_imux;
3908
3909         store_pin_configs(codec);
3910         return 1;
3911 }
3912
3913 /* additional initialization for auto-configuration model */
3914 static void alc880_auto_init(struct hda_codec *codec)
3915 {
3916         struct alc_spec *spec = codec->spec;
3917         alc880_auto_init_multi_out(codec);
3918         alc880_auto_init_extra_out(codec);
3919         alc880_auto_init_analog_input(codec);
3920         if (spec->unsol_event)
3921                 alc_inithook(codec);
3922 }
3923
3924 /*
3925  * OK, here we have finally the patch for ALC880
3926  */
3927
3928 static int patch_alc880(struct hda_codec *codec)
3929 {
3930         struct alc_spec *spec;
3931         int board_config;
3932         int err;
3933
3934         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3935         if (spec == NULL)
3936                 return -ENOMEM;
3937
3938         codec->spec = spec;
3939
3940         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
3941                                                   alc880_models,
3942                                                   alc880_cfg_tbl);
3943         if (board_config < 0) {
3944                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
3945                        "trying auto-probe from BIOS...\n");
3946                 board_config = ALC880_AUTO;
3947         }
3948
3949         if (board_config == ALC880_AUTO) {
3950                 /* automatic parse from the BIOS config */
3951                 err = alc880_parse_auto_config(codec);
3952                 if (err < 0) {
3953                         alc_free(codec);
3954                         return err;
3955                 } else if (!err) {
3956                         printk(KERN_INFO
3957                                "hda_codec: Cannot set up configuration "
3958                                "from BIOS.  Using 3-stack mode...\n");
3959                         board_config = ALC880_3ST;
3960                 }
3961         }
3962
3963         if (board_config != ALC880_AUTO)
3964                 setup_preset(spec, &alc880_presets[board_config]);
3965
3966         spec->stream_name_analog = "ALC880 Analog";
3967         spec->stream_analog_playback = &alc880_pcm_analog_playback;
3968         spec->stream_analog_capture = &alc880_pcm_analog_capture;
3969         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
3970
3971         spec->stream_name_digital = "ALC880 Digital";
3972         spec->stream_digital_playback = &alc880_pcm_digital_playback;
3973         spec->stream_digital_capture = &alc880_pcm_digital_capture;
3974
3975         if (!spec->adc_nids && spec->input_mux) {
3976                 /* check whether NID 0x07 is valid */
3977                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
3978                 /* get type */
3979                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3980                 if (wcap != AC_WID_AUD_IN) {
3981                         spec->adc_nids = alc880_adc_nids_alt;
3982                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
3983                         spec->mixers[spec->num_mixers] =
3984                                 alc880_capture_alt_mixer;
3985                         spec->num_mixers++;
3986                 } else {
3987                         spec->adc_nids = alc880_adc_nids;
3988                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
3989                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
3990                         spec->num_mixers++;
3991                 }
3992         }
3993
3994         spec->vmaster_nid = 0x0c;
3995
3996         codec->patch_ops = alc_patch_ops;
3997         if (board_config == ALC880_AUTO)
3998                 spec->init_hook = alc880_auto_init;
3999 #ifdef CONFIG_SND_HDA_POWER_SAVE
4000         if (!spec->loopback.amplist)
4001                 spec->loopback.amplist = alc880_loopbacks;
4002 #endif
4003
4004         return 0;
4005 }
4006
4007
4008 /*
4009  * ALC260 support
4010  */
4011
4012 static hda_nid_t alc260_dac_nids[1] = {
4013         /* front */
4014         0x02,
4015 };
4016
4017 static hda_nid_t alc260_adc_nids[1] = {
4018         /* ADC0 */
4019         0x04,
4020 };
4021
4022 static hda_nid_t alc260_adc_nids_alt[1] = {
4023         /* ADC1 */
4024         0x05,
4025 };
4026
4027 static hda_nid_t alc260_hp_adc_nids[2] = {
4028         /* ADC1, 0 */
4029         0x05, 0x04
4030 };
4031
4032 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4033  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4034  */
4035 static hda_nid_t alc260_dual_adc_nids[2] = {
4036         /* ADC0, ADC1 */
4037         0x04, 0x05
4038 };
4039
4040 #define ALC260_DIGOUT_NID       0x03
4041 #define ALC260_DIGIN_NID        0x06
4042
4043 static struct hda_input_mux alc260_capture_source = {
4044         .num_items = 4,
4045         .items = {
4046                 { "Mic", 0x0 },
4047                 { "Front Mic", 0x1 },
4048                 { "Line", 0x2 },
4049                 { "CD", 0x4 },
4050         },
4051 };
4052
4053 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4054  * headphone jack and the internal CD lines since these are the only pins at
4055  * which audio can appear.  For flexibility, also allow the option of
4056  * recording the mixer output on the second ADC (ADC0 doesn't have a
4057  * connection to the mixer output).
4058  */
4059 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4060         {
4061                 .num_items = 3,
4062                 .items = {
4063                         { "Mic/Line", 0x0 },
4064                         { "CD", 0x4 },
4065                         { "Headphone", 0x2 },
4066                 },
4067         },
4068         {
4069                 .num_items = 4,
4070                 .items = {
4071                         { "Mic/Line", 0x0 },
4072                         { "CD", 0x4 },
4073                         { "Headphone", 0x2 },
4074                         { "Mixer", 0x5 },
4075                 },
4076         },
4077
4078 };
4079
4080 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4081  * the Fujitsu S702x, but jacks are marked differently.
4082  */
4083 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4084         {
4085                 .num_items = 4,
4086                 .items = {
4087                         { "Mic", 0x0 },
4088                         { "Line", 0x2 },
4089                         { "CD", 0x4 },
4090                         { "Headphone", 0x5 },
4091                 },
4092         },
4093         {
4094                 .num_items = 5,
4095                 .items = {
4096                         { "Mic", 0x0 },
4097                         { "Line", 0x2 },
4098                         { "CD", 0x4 },
4099                         { "Headphone", 0x6 },
4100                         { "Mixer", 0x5 },
4101                 },
4102         },
4103 };
4104 /*
4105  * This is just place-holder, so there's something for alc_build_pcms to look
4106  * at when it calculates the maximum number of channels. ALC260 has no mixer
4107  * element which allows changing the channel mode, so the verb list is
4108  * never used.
4109  */
4110 static struct hda_channel_mode alc260_modes[1] = {
4111         { 2, NULL },
4112 };
4113
4114
4115 /* Mixer combinations
4116  *
4117  * basic: base_output + input + pc_beep + capture
4118  * HP: base_output + input + capture_alt
4119  * HP_3013: hp_3013 + input + capture
4120  * fujitsu: fujitsu + capture
4121  * acer: acer + capture
4122  */
4123
4124 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4125         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4126         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4127         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4128         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4129         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4130         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4131         { } /* end */
4132 };
4133
4134 static struct snd_kcontrol_new alc260_input_mixer[] = {
4135         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4136         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4137         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4138         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4139         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4140         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4141         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4142         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4143         { } /* end */
4144 };
4145
4146 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4147         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4148         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4149         { } /* end */
4150 };
4151
4152 /* update HP, line and mono out pins according to the master switch */
4153 static void alc260_hp_master_update(struct hda_codec *codec,
4154                                     hda_nid_t hp, hda_nid_t line,
4155                                     hda_nid_t mono)
4156 {
4157         struct alc_spec *spec = codec->spec;
4158         unsigned int val = spec->master_sw ? PIN_HP : 0;
4159         /* change HP and line-out pins */
4160         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4161                             val);
4162         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4163                             val);
4164         /* mono (speaker) depending on the HP jack sense */
4165         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4166         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4167                             val);
4168 }
4169
4170 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4171                                    struct snd_ctl_elem_value *ucontrol)
4172 {
4173         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4174         struct alc_spec *spec = codec->spec;
4175         *ucontrol->value.integer.value = spec->master_sw;
4176         return 0;
4177 }
4178
4179 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4180                                    struct snd_ctl_elem_value *ucontrol)
4181 {
4182         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4183         struct alc_spec *spec = codec->spec;
4184         int val = !!*ucontrol->value.integer.value;
4185         hda_nid_t hp, line, mono;
4186
4187         if (val == spec->master_sw)
4188                 return 0;
4189         spec->master_sw = val;
4190         hp = (kcontrol->private_value >> 16) & 0xff;
4191         line = (kcontrol->private_value >> 8) & 0xff;
4192         mono = kcontrol->private_value & 0xff;
4193         alc260_hp_master_update(codec, hp, line, mono);
4194         return 1;
4195 }
4196
4197 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4198         {
4199                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4200                 .name = "Master Playback Switch",
4201                 .info = snd_ctl_boolean_mono_info,
4202                 .get = alc260_hp_master_sw_get,
4203                 .put = alc260_hp_master_sw_put,
4204                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4205         },
4206         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4207         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4208         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4209         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4210         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4211                               HDA_OUTPUT),
4212         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4213         { } /* end */
4214 };
4215
4216 static struct hda_verb alc260_hp_unsol_verbs[] = {
4217         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4218         {},
4219 };
4220
4221 static void alc260_hp_automute(struct hda_codec *codec)
4222 {
4223         struct alc_spec *spec = codec->spec;
4224         unsigned int present;
4225
4226         present = snd_hda_codec_read(codec, 0x10, 0,
4227                                      AC_VERB_GET_PIN_SENSE, 0);
4228         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4229         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4230 }
4231
4232 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4233 {
4234         if ((res >> 26) == ALC880_HP_EVENT)
4235                 alc260_hp_automute(codec);
4236 }
4237
4238 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4239         {
4240                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4241                 .name = "Master Playback Switch",
4242                 .info = snd_ctl_boolean_mono_info,
4243                 .get = alc260_hp_master_sw_get,
4244                 .put = alc260_hp_master_sw_put,
4245                 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
4246         },
4247         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4248         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4249         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4250         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4251         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4252         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4253         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4254         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4255         { } /* end */
4256 };
4257
4258 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4259         .ops = &snd_hda_bind_vol,
4260         .values = {
4261                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4262                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4263                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4264                 0
4265         },
4266 };
4267
4268 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4269         .ops = &snd_hda_bind_sw,
4270         .values = {
4271                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4272                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4273                 0
4274         },
4275 };
4276
4277 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4278         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4279         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4280         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4281         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4282         { } /* end */
4283 };
4284
4285 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4286         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4287         {},
4288 };
4289
4290 static void alc260_hp_3013_automute(struct hda_codec *codec)
4291 {
4292         struct alc_spec *spec = codec->spec;
4293         unsigned int present;
4294
4295         present = snd_hda_codec_read(codec, 0x15, 0,
4296                                      AC_VERB_GET_PIN_SENSE, 0);
4297         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4298         alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
4299 }
4300
4301 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4302                                        unsigned int res)
4303 {
4304         if ((res >> 26) == ALC880_HP_EVENT)
4305                 alc260_hp_3013_automute(codec);
4306 }
4307
4308 static void alc260_hp_3012_automute(struct hda_codec *codec)
4309 {
4310         unsigned int present, bits;
4311
4312         present = snd_hda_codec_read(codec, 0x10, 0,
4313                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4314
4315         bits = present ? 0 : PIN_OUT;
4316         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4317                             bits);
4318         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4319                             bits);
4320         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4321                             bits);
4322 }
4323
4324 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4325                                        unsigned int res)
4326 {
4327         if ((res >> 26) == ALC880_HP_EVENT)
4328                 alc260_hp_3012_automute(codec);
4329 }
4330
4331 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4332  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4333  */
4334 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4335         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4336         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4337         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4338         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4339         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4340         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4341         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4342         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4343         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4344         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4345         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4346         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4347         { } /* end */
4348 };
4349
4350 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4351  * versions of the ALC260 don't act on requests to enable mic bias from NID
4352  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4353  * datasheet doesn't mention this restriction.  At this stage it's not clear
4354  * whether this behaviour is intentional or is a hardware bug in chip
4355  * revisions available in early 2006.  Therefore for now allow the
4356  * "Headphone Jack Mode" control to span all choices, but if it turns out
4357  * that the lack of mic bias for this NID is intentional we could change the
4358  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4359  *
4360  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4361  * don't appear to make the mic bias available from the "line" jack, even
4362  * though the NID used for this jack (0x14) can supply it.  The theory is
4363  * that perhaps Acer have included blocking capacitors between the ALC260
4364  * and the output jack.  If this turns out to be the case for all such
4365  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4366  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4367  *
4368  * The C20x Tablet series have a mono internal speaker which is controlled
4369  * via the chip's Mono sum widget and pin complex, so include the necessary
4370  * controls for such models.  On models without a "mono speaker" the control
4371  * won't do anything.
4372  */
4373 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4374         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4375         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4376         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4377         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4378                               HDA_OUTPUT),
4379         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4380                            HDA_INPUT),
4381         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4382         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4383         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4384         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4385         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4386         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4387         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4388         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4389         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4390         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4391         { } /* end */
4392 };
4393
4394 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4395  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4396  */
4397 static struct snd_kcontrol_new alc260_will_mixer[] = {
4398         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4399         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4400         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4401         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4402         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4403         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4404         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4405         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4406         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4407         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4408         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4409         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4410         { } /* end */
4411 };
4412
4413 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4414  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4415  */
4416 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4417         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4418         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4420         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4421         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4422         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4423         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4424         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4425         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4426         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4427         { } /* end */
4428 };
4429
4430 /* capture mixer elements */
4431 static struct snd_kcontrol_new alc260_capture_mixer[] = {
4432         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
4433         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
4434         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
4435         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
4436         {
4437                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4438                 /* The multiple "Capture Source" controls confuse alsamixer
4439                  * So call somewhat different..
4440                  */
4441                 /* .name = "Capture Source", */
4442                 .name = "Input Source",
4443                 .count = 2,
4444                 .info = alc_mux_enum_info,
4445                 .get = alc_mux_enum_get,
4446                 .put = alc_mux_enum_put,
4447         },
4448         { } /* end */
4449 };
4450
4451 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
4452         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
4453         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
4454         {
4455                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4456                 /* The multiple "Capture Source" controls confuse alsamixer
4457                  * So call somewhat different..
4458                  */
4459                 /* .name = "Capture Source", */
4460                 .name = "Input Source",
4461                 .count = 1,
4462                 .info = alc_mux_enum_info,
4463                 .get = alc_mux_enum_get,
4464                 .put = alc_mux_enum_put,
4465         },
4466         { } /* end */
4467 };
4468
4469 /*
4470  * initialization verbs
4471  */
4472 static struct hda_verb alc260_init_verbs[] = {
4473         /* Line In pin widget for input */
4474         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4475         /* CD pin widget for input */
4476         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4477         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4478         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4479         /* Mic2 (front panel) pin widget for input and vref at 80% */
4480         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4481         /* LINE-2 is used for line-out in rear */
4482         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4483         /* select line-out */
4484         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4485         /* LINE-OUT pin */
4486         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4487         /* enable HP */
4488         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4489         /* enable Mono */
4490         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4491         /* mute capture amp left and right */
4492         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4493         /* set connection select to line in (default select for this ADC) */
4494         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4495         /* mute capture amp left and right */
4496         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4497         /* set connection select to line in (default select for this ADC) */
4498         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4499         /* set vol=0 Line-Out mixer amp left and right */
4500         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4501         /* unmute pin widget amp left and right (no gain on this amp) */
4502         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4503         /* set vol=0 HP mixer amp left and right */
4504         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4505         /* unmute pin widget amp left and right (no gain on this amp) */
4506         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4507         /* set vol=0 Mono mixer amp left and right */
4508         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4509         /* unmute pin widget amp left and right (no gain on this amp) */
4510         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4511         /* unmute LINE-2 out pin */
4512         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4513         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4514          * Line In 2 = 0x03
4515          */
4516         /* mute analog inputs */
4517         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4518         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4519         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4520         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4521         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4522         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4523         /* mute Front out path */
4524         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4525         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4526         /* mute Headphone out path */
4527         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4528         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4529         /* mute Mono out path */
4530         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4531         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4532         { }
4533 };
4534
4535 #if 0 /* should be identical with alc260_init_verbs? */
4536 static struct hda_verb alc260_hp_init_verbs[] = {
4537         /* Headphone and output */
4538         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4539         /* mono output */
4540         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4541         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4542         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4543         /* Mic2 (front panel) pin widget for input and vref at 80% */
4544         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4545         /* Line In pin widget for input */
4546         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4547         /* Line-2 pin widget for output */
4548         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4549         /* CD pin widget for input */
4550         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4551         /* unmute amp left and right */
4552         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4553         /* set connection select to line in (default select for this ADC) */
4554         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4555         /* unmute Line-Out mixer amp left and right (volume = 0) */
4556         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4557         /* mute pin widget amp left and right (no gain on this amp) */
4558         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4559         /* unmute HP mixer amp left and right (volume = 0) */
4560         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4561         /* mute pin widget amp left and right (no gain on this amp) */
4562         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4563         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4564          * Line In 2 = 0x03
4565          */
4566         /* mute analog inputs */
4567         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4568         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4569         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4570         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4571         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4572         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4573         /* Unmute Front out path */
4574         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4575         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4576         /* Unmute Headphone out path */
4577         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4578         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4579         /* Unmute Mono out path */
4580         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4581         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4582         { }
4583 };
4584 #endif
4585
4586 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4587         /* Line out and output */
4588         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4589         /* mono output */
4590         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4591         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4592         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4593         /* Mic2 (front panel) pin widget for input and vref at 80% */
4594         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4595         /* Line In pin widget for input */
4596         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4597         /* Headphone pin widget for output */
4598         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4599         /* CD pin widget for input */
4600         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4601         /* unmute amp left and right */
4602         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4603         /* set connection select to line in (default select for this ADC) */
4604         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4605         /* unmute Line-Out mixer amp left and right (volume = 0) */
4606         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4607         /* mute pin widget amp left and right (no gain on this amp) */
4608         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4609         /* unmute HP mixer amp left and right (volume = 0) */
4610         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4611         /* mute pin widget amp left and right (no gain on this amp) */
4612         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4613         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4614          * Line In 2 = 0x03
4615          */
4616         /* mute analog inputs */
4617         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4618         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4619         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4620         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4621         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4622         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4623         /* Unmute Front out path */
4624         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4625         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4626         /* Unmute Headphone out path */
4627         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4628         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4629         /* Unmute Mono out path */
4630         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4631         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4632         { }
4633 };
4634
4635 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4636  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4637  * audio = 0x16, internal speaker = 0x10.
4638  */
4639 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4640         /* Disable all GPIOs */
4641         {0x01, AC_VERB_SET_GPIO_MASK, 0},
4642         /* Internal speaker is connected to headphone pin */
4643         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4644         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4645         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4646         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4647         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4648         /* Ensure all other unused pins are disabled and muted. */
4649         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4650         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4651         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4652         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4653         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4654         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4655         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4656         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4657
4658         /* Disable digital (SPDIF) pins */
4659         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4660         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4661
4662         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4663          * when acting as an output.
4664          */
4665         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4666
4667         /* Start with output sum widgets muted and their output gains at min */
4668         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4669         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4670         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4671         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4672         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4673         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4674         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4675         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4676         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4677
4678         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4679         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4680         /* Unmute Line1 pin widget output buffer since it starts as an output.
4681          * If the pin mode is changed by the user the pin mode control will
4682          * take care of enabling the pin's input/output buffers as needed.
4683          * Therefore there's no need to enable the input buffer at this
4684          * stage.
4685          */
4686         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4687         /* Unmute input buffer of pin widget used for Line-in (no equiv
4688          * mixer ctrl)
4689          */
4690         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4691
4692         /* Mute capture amp left and right */
4693         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4694         /* Set ADC connection select to match default mixer setting - line
4695          * in (on mic1 pin)
4696          */
4697         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4698
4699         /* Do the same for the second ADC: mute capture input amp and
4700          * set ADC connection to line in (on mic1 pin)
4701          */
4702         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4703         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4704
4705         /* Mute all inputs to mixer widget (even unconnected ones) */
4706         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4707         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4708         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4709         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4710         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4711         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4712         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4713         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4714
4715         { }
4716 };
4717
4718 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
4719  * similar laptops (adapted from Fujitsu init verbs).
4720  */
4721 static struct hda_verb alc260_acer_init_verbs[] = {
4722         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
4723          * the headphone jack.  Turn this on and rely on the standard mute
4724          * methods whenever the user wants to turn these outputs off.
4725          */
4726         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4727         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4728         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4729         /* Internal speaker/Headphone jack is connected to Line-out pin */
4730         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4731         /* Internal microphone/Mic jack is connected to Mic1 pin */
4732         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
4733         /* Line In jack is connected to Line1 pin */
4734         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4735         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
4736         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4737         /* Ensure all other unused pins are disabled and muted. */
4738         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4739         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4740         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4741         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4742         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4743         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4744         /* Disable digital (SPDIF) pins */
4745         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4746         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4747
4748         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
4749          * bus when acting as outputs.
4750          */
4751         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
4752         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4753
4754         /* Start with output sum widgets muted and their output gains at min */
4755         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4756         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4757         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4758         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4759         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4760         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4761         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4762         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4763         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4764
4765         /* Unmute Line-out pin widget amp left and right
4766          * (no equiv mixer ctrl)
4767          */
4768         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4769         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
4770         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4771         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
4772          * inputs. If the pin mode is changed by the user the pin mode control
4773          * will take care of enabling the pin's input/output buffers as needed.
4774          * Therefore there's no need to enable the input buffer at this
4775          * stage.
4776          */
4777         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4778         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4779
4780         /* Mute capture amp left and right */
4781         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4782         /* Set ADC connection select to match default mixer setting - mic
4783          * (on mic1 pin)
4784          */
4785         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
4786
4787         /* Do similar with the second ADC: mute capture input amp and
4788          * set ADC connection to mic to match ALSA's default state.
4789          */
4790         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4791         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
4792
4793         /* Mute all inputs to mixer widget (even unconnected ones) */
4794         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
4795         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
4796         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
4797         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
4798         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
4799         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
4800         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
4801         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
4802
4803         { }
4804 };
4805
4806 static struct hda_verb alc260_will_verbs[] = {
4807         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4808         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
4809         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
4810         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4811         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4812         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
4813         {}
4814 };
4815
4816 static struct hda_verb alc260_replacer_672v_verbs[] = {
4817         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
4818         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
4819         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
4820
4821         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
4822         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4823         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4824
4825         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4826         {}
4827 };
4828
4829 /* toggle speaker-output according to the hp-jack state */
4830 static void alc260_replacer_672v_automute(struct hda_codec *codec)
4831 {
4832         unsigned int present;
4833
4834         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
4835         present = snd_hda_codec_read(codec, 0x0f, 0,
4836                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
4837         if (present) {
4838                 snd_hda_codec_write_cache(codec, 0x01, 0,
4839                                           AC_VERB_SET_GPIO_DATA, 1);
4840                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4841                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4842                                           PIN_HP);
4843         } else {
4844                 snd_hda_codec_write_cache(codec, 0x01, 0,
4845                                           AC_VERB_SET_GPIO_DATA, 0);
4846                 snd_hda_codec_write_cache(codec, 0x0f, 0,
4847                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4848                                           PIN_OUT);
4849         }
4850 }
4851
4852 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
4853                                        unsigned int res)
4854 {
4855         if ((res >> 26) == ALC880_HP_EVENT)
4856                 alc260_replacer_672v_automute(codec);
4857 }
4858
4859 static struct hda_verb alc260_hp_dc7600_verbs[] = {
4860         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
4861         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
4862         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4863         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4864         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4865         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4866         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4867         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4868         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4869         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4870         {}
4871 };
4872
4873 /* Test configuration for debugging, modelled after the ALC880 test
4874  * configuration.
4875  */
4876 #ifdef CONFIG_SND_DEBUG
4877 static hda_nid_t alc260_test_dac_nids[1] = {
4878         0x02,
4879 };
4880 static hda_nid_t alc260_test_adc_nids[2] = {
4881         0x04, 0x05,
4882 };
4883 /* For testing the ALC260, each input MUX needs its own definition since
4884  * the signal assignments are different.  This assumes that the first ADC
4885  * is NID 0x04.
4886  */
4887 static struct hda_input_mux alc260_test_capture_sources[2] = {
4888         {
4889                 .num_items = 7,
4890                 .items = {
4891                         { "MIC1 pin", 0x0 },
4892                         { "MIC2 pin", 0x1 },
4893                         { "LINE1 pin", 0x2 },
4894                         { "LINE2 pin", 0x3 },
4895                         { "CD pin", 0x4 },
4896                         { "LINE-OUT pin", 0x5 },
4897                         { "HP-OUT pin", 0x6 },
4898                 },
4899         },
4900         {
4901                 .num_items = 8,
4902                 .items = {
4903                         { "MIC1 pin", 0x0 },
4904                         { "MIC2 pin", 0x1 },
4905                         { "LINE1 pin", 0x2 },
4906                         { "LINE2 pin", 0x3 },
4907                         { "CD pin", 0x4 },
4908                         { "Mixer", 0x5 },
4909                         { "LINE-OUT pin", 0x6 },
4910                         { "HP-OUT pin", 0x7 },
4911                 },
4912         },
4913 };
4914 static struct snd_kcontrol_new alc260_test_mixer[] = {
4915         /* Output driver widgets */
4916         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4917         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4918         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4919         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
4920         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4921         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
4922
4923         /* Modes for retasking pin widgets
4924          * Note: the ALC260 doesn't seem to act on requests to enable mic
4925          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
4926          * mention this restriction.  At this stage it's not clear whether
4927          * this behaviour is intentional or is a hardware bug in chip
4928          * revisions available at least up until early 2006.  Therefore for
4929          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
4930          * choices, but if it turns out that the lack of mic bias for these
4931          * NIDs is intentional we could change their modes from
4932          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4933          */
4934         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
4935         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
4936         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
4937         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
4938         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
4939         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
4940
4941         /* Loopback mixer controls */
4942         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
4943         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
4944         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
4945         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
4946         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
4947         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
4948         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
4949         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
4950         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4951         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4952         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4953         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4954         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
4955         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
4956         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
4957         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
4958
4959         /* Controls for GPIO pins, assuming they are configured as outputs */
4960         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
4961         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
4962         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
4963         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
4964
4965         /* Switches to allow the digital IO pins to be enabled.  The datasheet
4966          * is ambigious as to which NID is which; testing on laptops which
4967          * make this output available should provide clarification.
4968          */
4969         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
4970         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
4971
4972         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
4973          * this output to turn on an external amplifier.
4974          */
4975         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
4976         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
4977
4978         { } /* end */
4979 };
4980 static struct hda_verb alc260_test_init_verbs[] = {
4981         /* Enable all GPIOs as outputs with an initial value of 0 */
4982         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
4983         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4984         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
4985
4986         /* Enable retasking pins as output, initially without power amp */
4987         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4988         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4989         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4990         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4991         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4992         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4993
4994         /* Disable digital (SPDIF) pins initially, but users can enable
4995          * them via a mixer switch.  In the case of SPDIF-out, this initverb
4996          * payload also sets the generation to 0, output to be in "consumer"
4997          * PCM format, copyright asserted, no pre-emphasis and no validity
4998          * control.
4999          */
5000         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5001         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5002
5003         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5004          * OUT1 sum bus when acting as an output.
5005          */
5006         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5007         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5008         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5009         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5010
5011         /* Start with output sum widgets muted and their output gains at min */
5012         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5013         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5014         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5015         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5016         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5017         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5018         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5019         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5020         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5021
5022         /* Unmute retasking pin widget output buffers since the default
5023          * state appears to be output.  As the pin mode is changed by the
5024          * user the pin mode control will take care of enabling the pin's
5025          * input/output buffers as needed.
5026          */
5027         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5028         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5029         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5030         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5031         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5032         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5033         /* Also unmute the mono-out pin widget */
5034         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5035
5036         /* Mute capture amp left and right */
5037         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5038         /* Set ADC connection select to match default mixer setting (mic1
5039          * pin)
5040          */
5041         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5042
5043         /* Do the same for the second ADC: mute capture input amp and
5044          * set ADC connection to mic1 pin
5045          */
5046         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5047         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5048
5049         /* Mute all inputs to mixer widget (even unconnected ones) */
5050         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5051         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5052         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5053         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5054         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5055         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5056         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5057         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5058
5059         { }
5060 };
5061 #endif
5062
5063 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5064 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5065
5066 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5067 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5068
5069 /*
5070  * for BIOS auto-configuration
5071  */
5072
5073 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5074                                         const char *pfx, int *vol_bits)
5075 {
5076         hda_nid_t nid_vol;
5077         unsigned long vol_val, sw_val;
5078         char name[32];
5079         int err;
5080
5081         if (nid >= 0x0f && nid < 0x11) {
5082                 nid_vol = nid - 0x7;
5083                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5084                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5085         } else if (nid == 0x11) {
5086                 nid_vol = nid - 0x7;
5087                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5088                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5089         } else if (nid >= 0x12 && nid <= 0x15) {
5090                 nid_vol = 0x08;
5091                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5092                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5093         } else
5094                 return 0; /* N/A */
5095
5096         if (!(*vol_bits & (1 << nid_vol))) {
5097                 /* first control for the volume widget */
5098                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5099                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5100                 if (err < 0)
5101                         return err;
5102                 *vol_bits |= (1 << nid_vol);
5103         }
5104         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5105         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5106         if (err < 0)
5107                 return err;
5108         return 1;
5109 }
5110
5111 /* add playback controls from the parsed DAC table */
5112 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5113                                              const struct auto_pin_cfg *cfg)
5114 {
5115         hda_nid_t nid;
5116         int err;
5117         int vols = 0;
5118
5119         spec->multiout.num_dacs = 1;
5120         spec->multiout.dac_nids = spec->private_dac_nids;
5121         spec->multiout.dac_nids[0] = 0x02;
5122
5123         nid = cfg->line_out_pins[0];
5124         if (nid) {
5125                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5126                 if (err < 0)
5127                         return err;
5128         }
5129
5130         nid = cfg->speaker_pins[0];
5131         if (nid) {
5132                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5133                 if (err < 0)
5134                         return err;
5135         }
5136
5137         nid = cfg->hp_pins[0];
5138         if (nid) {
5139                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5140                                                    &vols);
5141                 if (err < 0)
5142                         return err;
5143         }
5144         return 0;
5145 }
5146
5147 /* create playback/capture controls for input pins */
5148 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5149                                                 const struct auto_pin_cfg *cfg)
5150 {
5151         struct hda_input_mux *imux = &spec->private_imux;
5152         int i, err, idx;
5153
5154         for (i = 0; i < AUTO_PIN_LAST; i++) {
5155                 if (cfg->input_pins[i] >= 0x12) {
5156                         idx = cfg->input_pins[i] - 0x12;
5157                         err = new_analog_input(spec, cfg->input_pins[i],
5158                                                auto_pin_cfg_labels[i], idx,
5159                                                0x07);
5160                         if (err < 0)
5161                                 return err;
5162                         imux->items[imux->num_items].label =
5163                                 auto_pin_cfg_labels[i];
5164                         imux->items[imux->num_items].index = idx;
5165                         imux->num_items++;
5166                 }
5167                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5168                         idx = cfg->input_pins[i] - 0x09;
5169                         err = new_analog_input(spec, cfg->input_pins[i],
5170                                                auto_pin_cfg_labels[i], idx,
5171                                                0x07);
5172                         if (err < 0)
5173                                 return err;
5174                         imux->items[imux->num_items].label =
5175                                 auto_pin_cfg_labels[i];
5176                         imux->items[imux->num_items].index = idx;
5177                         imux->num_items++;
5178                 }
5179         }
5180         return 0;
5181 }
5182
5183 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5184                                               hda_nid_t nid, int pin_type,
5185                                               int sel_idx)
5186 {
5187         alc_set_pin_output(codec, nid, pin_type);
5188         /* need the manual connection? */
5189         if (nid >= 0x12) {
5190                 int idx = nid - 0x12;
5191                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5192                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5193         }
5194 }
5195
5196 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5197 {
5198         struct alc_spec *spec = codec->spec;
5199         hda_nid_t nid;
5200
5201         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5202         nid = spec->autocfg.line_out_pins[0];
5203         if (nid) {
5204                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5205                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5206         }
5207
5208         nid = spec->autocfg.speaker_pins[0];
5209         if (nid)
5210                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5211
5212         nid = spec->autocfg.hp_pins[0];
5213         if (nid)
5214                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5215 }
5216
5217 #define ALC260_PIN_CD_NID               0x16
5218 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5219 {
5220         struct alc_spec *spec = codec->spec;
5221         int i;
5222
5223         for (i = 0; i < AUTO_PIN_LAST; i++) {
5224                 hda_nid_t nid = spec->autocfg.input_pins[i];
5225                 if (nid >= 0x12) {
5226                         snd_hda_codec_write(codec, nid, 0,
5227                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
5228                                             i <= AUTO_PIN_FRONT_MIC ?
5229                                             PIN_VREF80 : PIN_IN);
5230                         if (nid != ALC260_PIN_CD_NID)
5231                                 snd_hda_codec_write(codec, nid, 0,
5232                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5233                                                     AMP_OUT_MUTE);
5234                 }
5235         }
5236 }
5237
5238 /*
5239  * generic initialization of ADC, input mixers and output mixers
5240  */
5241 static struct hda_verb alc260_volume_init_verbs[] = {
5242         /*
5243          * Unmute ADC0-1 and set the default input to mic-in
5244          */
5245         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5246         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5247         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5248         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5249
5250         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5251          * mixer widget
5252          * Note: PASD motherboards uses the Line In 2 as the input for
5253          * front panel mic (mic 2)
5254          */
5255         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5256         /* mute analog inputs */
5257         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5258         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5259         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5260         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5261         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5262
5263         /*
5264          * Set up output mixers (0x08 - 0x0a)
5265          */
5266         /* set vol=0 to output mixers */
5267         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5268         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5269         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5270         /* set up input amps for analog loopback */
5271         /* Amp Indices: DAC = 0, mixer = 1 */
5272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5273         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5274         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5275         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5276         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5277         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5278
5279         { }
5280 };
5281
5282 static int alc260_parse_auto_config(struct hda_codec *codec)
5283 {
5284         struct alc_spec *spec = codec->spec;
5285         unsigned int wcap;
5286         int err;
5287         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5288
5289         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5290                                            alc260_ignore);
5291         if (err < 0)
5292                 return err;
5293         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5294         if (err < 0)
5295                 return err;
5296         if (!spec->kctl_alloc)
5297                 return 0; /* can't find valid BIOS pin config */
5298         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5299         if (err < 0)
5300                 return err;
5301
5302         spec->multiout.max_channels = 2;
5303
5304         if (spec->autocfg.dig_out_pin)
5305                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5306         if (spec->kctl_alloc)
5307                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
5308
5309         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
5310
5311         spec->num_mux_defs = 1;
5312         spec->input_mux = &spec->private_imux;
5313
5314         /* check whether NID 0x04 is valid */
5315         wcap = get_wcaps(codec, 0x04);
5316         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
5317         if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5318                 spec->adc_nids = alc260_adc_nids_alt;
5319                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5320                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
5321         } else {
5322                 spec->adc_nids = alc260_adc_nids;
5323                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5324                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
5325         }
5326         spec->num_mixers++;
5327
5328         store_pin_configs(codec);
5329         return 1;
5330 }
5331
5332 /* additional initialization for auto-configuration model */
5333 static void alc260_auto_init(struct hda_codec *codec)
5334 {
5335         struct alc_spec *spec = codec->spec;
5336         alc260_auto_init_multi_out(codec);
5337         alc260_auto_init_analog_input(codec);
5338         if (spec->unsol_event)
5339                 alc_inithook(codec);
5340 }
5341
5342 #ifdef CONFIG_SND_HDA_POWER_SAVE
5343 static struct hda_amp_list alc260_loopbacks[] = {
5344         { 0x07, HDA_INPUT, 0 },
5345         { 0x07, HDA_INPUT, 1 },
5346         { 0x07, HDA_INPUT, 2 },
5347         { 0x07, HDA_INPUT, 3 },
5348         { 0x07, HDA_INPUT, 4 },
5349         { } /* end */
5350 };
5351 #endif
5352
5353 /*
5354  * ALC260 configurations
5355  */
5356 static const char *alc260_models[ALC260_MODEL_LAST] = {
5357         [ALC260_BASIC]          = "basic",
5358         [ALC260_HP]             = "hp",
5359         [ALC260_HP_3013]        = "hp-3013",
5360         [ALC260_HP_DC7600]      = "hp-dc7600",
5361         [ALC260_FUJITSU_S702X]  = "fujitsu",
5362         [ALC260_ACER]           = "acer",
5363         [ALC260_WILL]           = "will",
5364         [ALC260_REPLACER_672V]  = "replacer",
5365 #ifdef CONFIG_SND_DEBUG
5366         [ALC260_TEST]           = "test",
5367 #endif
5368         [ALC260_AUTO]           = "auto",
5369 };
5370
5371 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5372         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5373         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5374         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5375         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5376         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5377         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5378         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5379         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5380         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5381         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5382         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5383         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5384         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5385         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5386         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5387         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5388         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5389         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5390         {}
5391 };
5392
5393 static struct alc_config_preset alc260_presets[] = {
5394         [ALC260_BASIC] = {
5395                 .mixers = { alc260_base_output_mixer,
5396                             alc260_input_mixer,
5397                             alc260_pc_beep_mixer,
5398                             alc260_capture_mixer },
5399                 .init_verbs = { alc260_init_verbs },
5400                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5401                 .dac_nids = alc260_dac_nids,
5402                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5403                 .adc_nids = alc260_adc_nids,
5404                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5405                 .channel_mode = alc260_modes,
5406                 .input_mux = &alc260_capture_source,
5407         },
5408         [ALC260_HP] = {
5409                 .mixers = { alc260_hp_output_mixer,
5410                             alc260_input_mixer,
5411                             alc260_capture_alt_mixer },
5412                 .init_verbs = { alc260_init_verbs,
5413                                 alc260_hp_unsol_verbs },
5414                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5415                 .dac_nids = alc260_dac_nids,
5416                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5417                 .adc_nids = alc260_hp_adc_nids,
5418                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5419                 .channel_mode = alc260_modes,
5420                 .input_mux = &alc260_capture_source,
5421                 .unsol_event = alc260_hp_unsol_event,
5422                 .init_hook = alc260_hp_automute,
5423         },
5424         [ALC260_HP_DC7600] = {
5425                 .mixers = { alc260_hp_dc7600_mixer,
5426                             alc260_input_mixer,
5427                             alc260_capture_alt_mixer },
5428                 .init_verbs = { alc260_init_verbs,
5429                                 alc260_hp_dc7600_verbs },
5430                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5431                 .dac_nids = alc260_dac_nids,
5432                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5433                 .adc_nids = alc260_hp_adc_nids,
5434                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5435                 .channel_mode = alc260_modes,
5436                 .input_mux = &alc260_capture_source,
5437                 .unsol_event = alc260_hp_3012_unsol_event,
5438                 .init_hook = alc260_hp_3012_automute,
5439         },
5440         [ALC260_HP_3013] = {
5441                 .mixers = { alc260_hp_3013_mixer,
5442                             alc260_input_mixer,
5443                             alc260_capture_alt_mixer },
5444                 .init_verbs = { alc260_hp_3013_init_verbs,
5445                                 alc260_hp_3013_unsol_verbs },
5446                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5447                 .dac_nids = alc260_dac_nids,
5448                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
5449                 .adc_nids = alc260_hp_adc_nids,
5450                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5451                 .channel_mode = alc260_modes,
5452                 .input_mux = &alc260_capture_source,
5453                 .unsol_event = alc260_hp_3013_unsol_event,
5454                 .init_hook = alc260_hp_3013_automute,
5455         },
5456         [ALC260_FUJITSU_S702X] = {
5457                 .mixers = { alc260_fujitsu_mixer,
5458                             alc260_capture_mixer },
5459                 .init_verbs = { alc260_fujitsu_init_verbs },
5460                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5461                 .dac_nids = alc260_dac_nids,
5462                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5463                 .adc_nids = alc260_dual_adc_nids,
5464                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5465                 .channel_mode = alc260_modes,
5466                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5467                 .input_mux = alc260_fujitsu_capture_sources,
5468         },
5469         [ALC260_ACER] = {
5470                 .mixers = { alc260_acer_mixer,
5471                             alc260_capture_mixer },
5472                 .init_verbs = { alc260_acer_init_verbs },
5473                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5474                 .dac_nids = alc260_dac_nids,
5475                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5476                 .adc_nids = alc260_dual_adc_nids,
5477                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5478                 .channel_mode = alc260_modes,
5479                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5480                 .input_mux = alc260_acer_capture_sources,
5481         },
5482         [ALC260_WILL] = {
5483                 .mixers = { alc260_will_mixer,
5484                             alc260_capture_mixer },
5485                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5486                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5487                 .dac_nids = alc260_dac_nids,
5488                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5489                 .adc_nids = alc260_adc_nids,
5490                 .dig_out_nid = ALC260_DIGOUT_NID,
5491                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5492                 .channel_mode = alc260_modes,
5493                 .input_mux = &alc260_capture_source,
5494         },
5495         [ALC260_REPLACER_672V] = {
5496                 .mixers = { alc260_replacer_672v_mixer,
5497                             alc260_capture_mixer },
5498                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5499                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5500                 .dac_nids = alc260_dac_nids,
5501                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5502                 .adc_nids = alc260_adc_nids,
5503                 .dig_out_nid = ALC260_DIGOUT_NID,
5504                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5505                 .channel_mode = alc260_modes,
5506                 .input_mux = &alc260_capture_source,
5507                 .unsol_event = alc260_replacer_672v_unsol_event,
5508                 .init_hook = alc260_replacer_672v_automute,
5509         },
5510 #ifdef CONFIG_SND_DEBUG
5511         [ALC260_TEST] = {
5512                 .mixers = { alc260_test_mixer,
5513                             alc260_capture_mixer },
5514                 .init_verbs = { alc260_test_init_verbs },
5515                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5516                 .dac_nids = alc260_test_dac_nids,
5517                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5518                 .adc_nids = alc260_test_adc_nids,
5519                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5520                 .channel_mode = alc260_modes,
5521                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5522                 .input_mux = alc260_test_capture_sources,
5523         },
5524 #endif
5525 };
5526
5527 static int patch_alc260(struct hda_codec *codec)
5528 {
5529         struct alc_spec *spec;
5530         int err, board_config;
5531
5532         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5533         if (spec == NULL)
5534                 return -ENOMEM;
5535
5536         codec->spec = spec;
5537
5538         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5539                                                   alc260_models,
5540                                                   alc260_cfg_tbl);
5541         if (board_config < 0) {
5542                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5543                            "trying auto-probe from BIOS...\n");
5544                 board_config = ALC260_AUTO;
5545         }
5546
5547         if (board_config == ALC260_AUTO) {
5548                 /* automatic parse from the BIOS config */
5549                 err = alc260_parse_auto_config(codec);
5550                 if (err < 0) {
5551                         alc_free(codec);
5552                         return err;
5553                 } else if (!err) {
5554                         printk(KERN_INFO
5555                                "hda_codec: Cannot set up configuration "
5556                                "from BIOS.  Using base mode...\n");
5557                         board_config = ALC260_BASIC;
5558                 }
5559         }
5560
5561         if (board_config != ALC260_AUTO)
5562                 setup_preset(spec, &alc260_presets[board_config]);
5563
5564         spec->stream_name_analog = "ALC260 Analog";
5565         spec->stream_analog_playback = &alc260_pcm_analog_playback;
5566         spec->stream_analog_capture = &alc260_pcm_analog_capture;
5567
5568         spec->stream_name_digital = "ALC260 Digital";
5569         spec->stream_digital_playback = &alc260_pcm_digital_playback;
5570         spec->stream_digital_capture = &alc260_pcm_digital_capture;
5571
5572         spec->vmaster_nid = 0x08;
5573
5574         codec->patch_ops = alc_patch_ops;
5575         if (board_config == ALC260_AUTO)
5576                 spec->init_hook = alc260_auto_init;
5577 #ifdef CONFIG_SND_HDA_POWER_SAVE
5578         if (!spec->loopback.amplist)
5579                 spec->loopback.amplist = alc260_loopbacks;
5580 #endif
5581
5582         return 0;
5583 }
5584
5585
5586 /*
5587  * ALC882 support
5588  *
5589  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5590  * configuration.  Each pin widget can choose any input DACs and a mixer.
5591  * Each ADC is connected from a mixer of all inputs.  This makes possible
5592  * 6-channel independent captures.
5593  *
5594  * In addition, an independent DAC for the multi-playback (not used in this
5595  * driver yet).
5596  */
5597 #define ALC882_DIGOUT_NID       0x06
5598 #define ALC882_DIGIN_NID        0x0a
5599
5600 static struct hda_channel_mode alc882_ch_modes[1] = {
5601         { 8, NULL }
5602 };
5603
5604 static hda_nid_t alc882_dac_nids[4] = {
5605         /* front, rear, clfe, rear_surr */
5606         0x02, 0x03, 0x04, 0x05
5607 };
5608
5609 /* identical with ALC880 */
5610 #define alc882_adc_nids         alc880_adc_nids
5611 #define alc882_adc_nids_alt     alc880_adc_nids_alt
5612
5613 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5614 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5615
5616 /* input MUX */
5617 /* FIXME: should be a matrix-type input source selection */
5618
5619 static struct hda_input_mux alc882_capture_source = {
5620         .num_items = 4,
5621         .items = {
5622                 { "Mic", 0x0 },
5623                 { "Front Mic", 0x1 },
5624                 { "Line", 0x2 },
5625                 { "CD", 0x4 },
5626         },
5627 };
5628 #define alc882_mux_enum_info alc_mux_enum_info
5629 #define alc882_mux_enum_get alc_mux_enum_get
5630
5631 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
5632                                struct snd_ctl_elem_value *ucontrol)
5633 {
5634         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5635         struct alc_spec *spec = codec->spec;
5636         const struct hda_input_mux *imux = spec->input_mux;
5637         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5638         hda_nid_t nid = spec->capsrc_nids ?
5639                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
5640         unsigned int *cur_val = &spec->cur_mux[adc_idx];
5641         unsigned int i, idx;
5642
5643         idx = ucontrol->value.enumerated.item[0];
5644         if (idx >= imux->num_items)
5645                 idx = imux->num_items - 1;
5646         if (*cur_val == idx)
5647                 return 0;
5648         for (i = 0; i < imux->num_items; i++) {
5649                 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
5650                 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
5651                                          imux->items[i].index,
5652                                          HDA_AMP_MUTE, v);
5653         }
5654         *cur_val = idx;
5655         return 1;
5656 }
5657
5658 /*
5659  * 2ch mode
5660  */
5661 static struct hda_verb alc882_3ST_ch2_init[] = {
5662         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5663         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5664         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5665         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5666         { } /* end */
5667 };
5668
5669 /*
5670  * 6ch mode
5671  */
5672 static struct hda_verb alc882_3ST_ch6_init[] = {
5673         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5674         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5675         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5676         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5677         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5678         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5679         { } /* end */
5680 };
5681
5682 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5683         { 2, alc882_3ST_ch2_init },
5684         { 6, alc882_3ST_ch6_init },
5685 };
5686
5687 /*
5688  * 6ch mode
5689  */
5690 static struct hda_verb alc882_sixstack_ch6_init[] = {
5691         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5692         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5693         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5694         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5695         { } /* end */
5696 };
5697
5698 /*
5699  * 8ch mode
5700  */
5701 static struct hda_verb alc882_sixstack_ch8_init[] = {
5702         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5703         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5704         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5705         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5706         { } /* end */
5707 };
5708
5709 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5710         { 6, alc882_sixstack_ch6_init },
5711         { 8, alc882_sixstack_ch8_init },
5712 };
5713
5714 /*
5715  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
5716  */
5717
5718 /*
5719  * 2ch mode
5720  */
5721 static struct hda_verb alc885_mbp_ch2_init[] = {
5722         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5723         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5724         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5725         { } /* end */
5726 };
5727
5728 /*
5729  * 6ch mode
5730  */
5731 static struct hda_verb alc885_mbp_ch6_init[] = {
5732         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5733         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5734         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5735         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5736         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5737         { } /* end */
5738 };
5739
5740 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
5741         { 2, alc885_mbp_ch2_init },
5742         { 6, alc885_mbp_ch6_init },
5743 };
5744
5745
5746 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
5747  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
5748  */
5749 static struct snd_kcontrol_new alc882_base_mixer[] = {
5750         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5751         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5752         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
5753         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
5754         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
5755         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
5756         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
5757         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
5758         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
5759         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
5760         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5761         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5762         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5763         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5764         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5765         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5766         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5767         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5768         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5769         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5770         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5771         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5772         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5773         { } /* end */
5774 };
5775
5776 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
5777         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
5778         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
5779         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
5780         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
5781         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5782         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5783         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
5784         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
5785         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
5786         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
5787         { } /* end */
5788 };
5789 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
5790         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5791         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5792         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5793         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5794         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5795         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5797         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5798         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5799         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5800         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5801         { } /* end */
5802 };
5803
5804 static struct snd_kcontrol_new alc882_targa_mixer[] = {
5805         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5806         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5807         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
5808         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5809         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5810         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5811         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5812         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5813         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5814         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5815         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
5816         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
5817         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
5818         { } /* end */
5819 };
5820
5821 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
5822  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
5823  */
5824 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
5825         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5826         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
5827         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5828         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
5829         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5830         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5831         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5832         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5833         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
5834         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
5835         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5836         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5837         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5838         { } /* end */
5839 };
5840
5841 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
5842         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5843         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5844         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5845         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
5846         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
5847         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
5848         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
5849         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
5850         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
5851         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
5852         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
5853         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
5854         { } /* end */
5855 };
5856
5857 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
5858         {
5859                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5860                 .name = "Channel Mode",
5861                 .info = alc_ch_mode_info,
5862                 .get = alc_ch_mode_get,
5863                 .put = alc_ch_mode_put,
5864         },
5865         { } /* end */
5866 };
5867
5868 static struct hda_verb alc882_init_verbs[] = {
5869         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5870         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5871         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5872         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5873         /* Rear mixer */
5874         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5875         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5876         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5877         /* CLFE mixer */
5878         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5879         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5880         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5881         /* Side mixer */
5882         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5883         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5884         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5885
5886         /* Front Pin: output 0 (0x0c) */
5887         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5888         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5889         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
5890         /* Rear Pin: output 1 (0x0d) */
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, 0x01},
5894         /* CLFE Pin: output 2 (0x0e) */
5895         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5896         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5897         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
5898         /* Side Pin: output 3 (0x0f) */
5899         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5900         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5901         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
5902         /* Mic (rear) pin: input vref at 80% */
5903         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5904         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5905         /* Front Mic pin: input vref at 80% */
5906         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5907         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5908         /* Line In pin: input */
5909         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5910         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5911         /* Line-2 In: Headphone output (output 0 - 0x0c) */
5912         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5913         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5914         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
5915         /* CD pin widget for input */
5916         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5917
5918         /* FIXME: use matrix-type input source selection */
5919         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5920         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5921         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5922         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5923         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5924         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5925         /* Input mixer2 */
5926         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5927         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5928         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5929         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5930         /* Input mixer3 */
5931         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5932         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5933         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5934         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5935         /* ADC1: mute amp left and right */
5936         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5937         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
5938         /* ADC2: mute amp left and right */
5939         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5940         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
5941         /* ADC3: mute amp left and right */
5942         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5943         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
5944
5945         { }
5946 };
5947
5948 static struct hda_verb alc882_eapd_verbs[] = {
5949         /* change to EAPD mode */
5950         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
5951         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
5952         { }
5953 };
5954
5955 /* Mac Pro test */
5956 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
5957         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
5958         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
5959         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
5960         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
5961         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
5962         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
5963         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
5964         { } /* end */
5965 };
5966
5967 static struct hda_verb alc882_macpro_init_verbs[] = {
5968         /* Front mixer: unmute input/output amp left and right (volume = 0) */
5969         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5970         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5971         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5972         /* Front Pin: output 0 (0x0c) */
5973         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5974         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5975         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
5976         /* Front Mic pin: input vref at 80% */
5977         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5978         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
5979         /* Speaker:  output */
5980         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5981         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5982         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
5983         /* Headphone output (output 0 - 0x0c) */
5984         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5985         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5986         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
5987
5988         /* FIXME: use matrix-type input source selection */
5989         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
5990         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
5991         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5992         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5993         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5994         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5995         /* Input mixer2 */
5996         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5997         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5998         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5999         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6000         /* Input mixer3 */
6001         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6002         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6003         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6004         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6005         /* ADC1: mute amp left and right */
6006         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6007         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6008         /* ADC2: mute amp left and right */
6009         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6010         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6011         /* ADC3: mute amp left and right */
6012         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6013         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6014
6015         { }
6016 };
6017
6018 /* Macbook Pro rev3 */
6019 static struct hda_verb alc885_mbp3_init_verbs[] = {
6020         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6021         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6022         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6023         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6024         /* Rear mixer */
6025         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6026         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6027         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6028         /* Front Pin: output 0 (0x0c) */
6029         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6030         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6031         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6032         /* HP Pin: output 0 (0x0d) */
6033         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6034         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6035         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6036         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6037         /* Mic (rear) pin: input vref at 80% */
6038         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6039         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6040         /* Front Mic pin: input vref at 80% */
6041         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6042         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6043         /* Line In pin: use output 1 when in LineOut mode */
6044         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6045         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6046         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6047
6048         /* FIXME: use matrix-type input source selection */
6049         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6050         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6051         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6052         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6053         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6054         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6055         /* Input mixer2 */
6056         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6057         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6058         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6059         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6060         /* Input mixer3 */
6061         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6062         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6063         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6064         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6065         /* ADC1: mute amp left and right */
6066         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6067         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6068         /* ADC2: mute amp left and right */
6069         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6070         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6071         /* ADC3: mute amp left and right */
6072         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6073         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6074
6075         { }
6076 };
6077
6078 /* iMac 24 mixer. */
6079 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6080         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6081         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6082         { } /* end */
6083 };
6084
6085 /* iMac 24 init verbs. */
6086 static struct hda_verb alc885_imac24_init_verbs[] = {
6087         /* Internal speakers: output 0 (0x0c) */
6088         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6089         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6090         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6091         /* Internal speakers: output 0 (0x0c) */
6092         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6093         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6094         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6095         /* Headphone: output 0 (0x0c) */
6096         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6097         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6098         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6099         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6100         /* Front Mic: input vref at 80% */
6101         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6102         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6103         { }
6104 };
6105
6106 /* Toggle speaker-output according to the hp-jack state */
6107 static void alc885_imac24_automute(struct hda_codec *codec)
6108 {
6109         unsigned int present;
6110
6111         present = snd_hda_codec_read(codec, 0x14, 0,
6112                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6113         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6114                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6115         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6116                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6117 }
6118
6119 /* Processes unsolicited events. */
6120 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6121                                       unsigned int res)
6122 {
6123         /* Headphone insertion or removal. */
6124         if ((res >> 26) == ALC880_HP_EVENT)
6125                 alc885_imac24_automute(codec);
6126 }
6127
6128 static void alc885_mbp3_automute(struct hda_codec *codec)
6129 {
6130         unsigned int present;
6131
6132         present = snd_hda_codec_read(codec, 0x15, 0,
6133                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6134         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6135                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6136         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6137                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6138
6139 }
6140 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6141                                     unsigned int res)
6142 {
6143         /* Headphone insertion or removal. */
6144         if ((res >> 26) == ALC880_HP_EVENT)
6145                 alc885_mbp3_automute(codec);
6146 }
6147
6148
6149 static struct hda_verb alc882_targa_verbs[] = {
6150         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6151         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6152
6153         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6154         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6155
6156         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6157         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6158         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6159
6160         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6161         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6162         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6163         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6164         { } /* end */
6165 };
6166
6167 /* toggle speaker-output according to the hp-jack state */
6168 static void alc882_targa_automute(struct hda_codec *codec)
6169 {
6170         unsigned int present;
6171
6172         present = snd_hda_codec_read(codec, 0x14, 0,
6173                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6174         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6175                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6176         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6177                                   present ? 1 : 3);
6178 }
6179
6180 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6181 {
6182         /* Looks like the unsol event is incompatible with the standard
6183          * definition.  4bit tag is placed at 26 bit!
6184          */
6185         if (((res >> 26) == ALC880_HP_EVENT)) {
6186                 alc882_targa_automute(codec);
6187         }
6188 }
6189
6190 static struct hda_verb alc882_asus_a7j_verbs[] = {
6191         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6192         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6193
6194         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6195         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6196         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6197
6198         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6199         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6200         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6201
6202         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6203         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6204         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6205         { } /* end */
6206 };
6207
6208 static struct hda_verb alc882_asus_a7m_verbs[] = {
6209         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6210         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6211
6212         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6213         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6214         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6215
6216         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6217         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6218         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6219
6220         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6221         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6222         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6223         { } /* end */
6224 };
6225
6226 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6227 {
6228         unsigned int gpiostate, gpiomask, gpiodir;
6229
6230         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6231                                        AC_VERB_GET_GPIO_DATA, 0);
6232
6233         if (!muted)
6234                 gpiostate |= (1 << pin);
6235         else
6236                 gpiostate &= ~(1 << pin);
6237
6238         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6239                                       AC_VERB_GET_GPIO_MASK, 0);
6240         gpiomask |= (1 << pin);
6241
6242         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6243                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6244         gpiodir |= (1 << pin);
6245
6246
6247         snd_hda_codec_write(codec, codec->afg, 0,
6248                             AC_VERB_SET_GPIO_MASK, gpiomask);
6249         snd_hda_codec_write(codec, codec->afg, 0,
6250                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6251
6252         msleep(1);
6253
6254         snd_hda_codec_write(codec, codec->afg, 0,
6255                             AC_VERB_SET_GPIO_DATA, gpiostate);
6256 }
6257
6258 /* set up GPIO at initialization */
6259 static void alc885_macpro_init_hook(struct hda_codec *codec)
6260 {
6261         alc882_gpio_mute(codec, 0, 0);
6262         alc882_gpio_mute(codec, 1, 0);
6263 }
6264
6265 /* set up GPIO and update auto-muting at initialization */
6266 static void alc885_imac24_init_hook(struct hda_codec *codec)
6267 {
6268         alc885_macpro_init_hook(codec);
6269         alc885_imac24_automute(codec);
6270 }
6271
6272 /*
6273  * generic initialization of ADC, input mixers and output mixers
6274  */
6275 static struct hda_verb alc882_auto_init_verbs[] = {
6276         /*
6277          * Unmute ADC0-2 and set the default input to mic-in
6278          */
6279         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6281         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6282         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6283         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6284         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6285
6286         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6287          * mixer widget
6288          * Note: PASD motherboards uses the Line In 2 as the input for
6289          * front panel mic (mic 2)
6290          */
6291         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6292         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6293         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6294         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6295         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6296         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6297
6298         /*
6299          * Set up output mixers (0x0c - 0x0f)
6300          */
6301         /* set vol=0 to output mixers */
6302         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6303         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6304         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6305         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6306         /* set up input amps for analog loopback */
6307         /* Amp Indices: DAC = 0, mixer = 1 */
6308         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6310         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6311         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6312         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6313         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6314         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6315         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6316         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6317         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6318
6319         /* FIXME: use matrix-type input source selection */
6320         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6321         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6322         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6323         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6326         /* Input mixer2 */
6327         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6328         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6329         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6330         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6331         /* Input mixer3 */
6332         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6333         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6334         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6335         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6336
6337         { }
6338 };
6339
6340 /* capture mixer elements */
6341 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
6342         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
6343         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
6344         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
6345         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
6346         {
6347                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6348                 /* The multiple "Capture Source" controls confuse alsamixer
6349                  * So call somewhat different..
6350                  */
6351                 /* .name = "Capture Source", */
6352                 .name = "Input Source",
6353                 .count = 2,
6354                 .info = alc882_mux_enum_info,
6355                 .get = alc882_mux_enum_get,
6356                 .put = alc882_mux_enum_put,
6357         },
6358         { } /* end */
6359 };
6360
6361 static struct snd_kcontrol_new alc882_capture_mixer[] = {
6362         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
6363         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
6364         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
6365         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
6366         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
6367         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
6368         {
6369                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6370                 /* The multiple "Capture Source" controls confuse alsamixer
6371                  * So call somewhat different..
6372                  */
6373                 /* .name = "Capture Source", */
6374                 .name = "Input Source",
6375                 .count = 3,
6376                 .info = alc882_mux_enum_info,
6377                 .get = alc882_mux_enum_get,
6378                 .put = alc882_mux_enum_put,
6379         },
6380         { } /* end */
6381 };
6382
6383 #ifdef CONFIG_SND_HDA_POWER_SAVE
6384 #define alc882_loopbacks        alc880_loopbacks
6385 #endif
6386
6387 /* pcm configuration: identiacal with ALC880 */
6388 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6389 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6390 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6391 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6392
6393 /*
6394  * configuration and preset
6395  */
6396 static const char *alc882_models[ALC882_MODEL_LAST] = {
6397         [ALC882_3ST_DIG]        = "3stack-dig",
6398         [ALC882_6ST_DIG]        = "6stack-dig",
6399         [ALC882_ARIMA]          = "arima",
6400         [ALC882_W2JC]           = "w2jc",
6401         [ALC882_TARGA]          = "targa",
6402         [ALC882_ASUS_A7J]       = "asus-a7j",
6403         [ALC882_ASUS_A7M]       = "asus-a7m",
6404         [ALC885_MACPRO]         = "macpro",
6405         [ALC885_MBP3]           = "mbp3",
6406         [ALC885_IMAC24]         = "imac24",
6407         [ALC882_AUTO]           = "auto",
6408 };
6409
6410 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6411         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6412         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6413         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6414         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6415         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6416         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6417         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6418         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6419         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6420         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6421         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6422         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6423         {}
6424 };
6425
6426 static struct alc_config_preset alc882_presets[] = {
6427         [ALC882_3ST_DIG] = {
6428                 .mixers = { alc882_base_mixer },
6429                 .init_verbs = { alc882_init_verbs },
6430                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6431                 .dac_nids = alc882_dac_nids,
6432                 .dig_out_nid = ALC882_DIGOUT_NID,
6433                 .dig_in_nid = ALC882_DIGIN_NID,
6434                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6435                 .channel_mode = alc882_ch_modes,
6436                 .need_dac_fix = 1,
6437                 .input_mux = &alc882_capture_source,
6438         },
6439         [ALC882_6ST_DIG] = {
6440                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6441                 .init_verbs = { alc882_init_verbs },
6442                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6443                 .dac_nids = alc882_dac_nids,
6444                 .dig_out_nid = ALC882_DIGOUT_NID,
6445                 .dig_in_nid = ALC882_DIGIN_NID,
6446                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6447                 .channel_mode = alc882_sixstack_modes,
6448                 .input_mux = &alc882_capture_source,
6449         },
6450         [ALC882_ARIMA] = {
6451                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6452                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6453                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6454                 .dac_nids = alc882_dac_nids,
6455                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6456                 .channel_mode = alc882_sixstack_modes,
6457                 .input_mux = &alc882_capture_source,
6458         },
6459         [ALC882_W2JC] = {
6460                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6461                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6462                                 alc880_gpio1_init_verbs },
6463                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6464                 .dac_nids = alc882_dac_nids,
6465                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6466                 .channel_mode = alc880_threestack_modes,
6467                 .need_dac_fix = 1,
6468                 .input_mux = &alc882_capture_source,
6469                 .dig_out_nid = ALC882_DIGOUT_NID,
6470         },
6471         [ALC885_MBP3] = {
6472                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6473                 .init_verbs = { alc885_mbp3_init_verbs,
6474                                 alc880_gpio1_init_verbs },
6475                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6476                 .dac_nids = alc882_dac_nids,
6477                 .channel_mode = alc885_mbp_6ch_modes,
6478                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6479                 .input_mux = &alc882_capture_source,
6480                 .dig_out_nid = ALC882_DIGOUT_NID,
6481                 .dig_in_nid = ALC882_DIGIN_NID,
6482                 .unsol_event = alc885_mbp3_unsol_event,
6483                 .init_hook = alc885_mbp3_automute,
6484         },
6485         [ALC885_MACPRO] = {
6486                 .mixers = { alc882_macpro_mixer },
6487                 .init_verbs = { alc882_macpro_init_verbs },
6488                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6489                 .dac_nids = alc882_dac_nids,
6490                 .dig_out_nid = ALC882_DIGOUT_NID,
6491                 .dig_in_nid = ALC882_DIGIN_NID,
6492                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6493                 .channel_mode = alc882_ch_modes,
6494                 .input_mux = &alc882_capture_source,
6495                 .init_hook = alc885_macpro_init_hook,
6496         },
6497         [ALC885_IMAC24] = {
6498                 .mixers = { alc885_imac24_mixer },
6499                 .init_verbs = { alc885_imac24_init_verbs },
6500                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6501                 .dac_nids = alc882_dac_nids,
6502                 .dig_out_nid = ALC882_DIGOUT_NID,
6503                 .dig_in_nid = ALC882_DIGIN_NID,
6504                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6505                 .channel_mode = alc882_ch_modes,
6506                 .input_mux = &alc882_capture_source,
6507                 .unsol_event = alc885_imac24_unsol_event,
6508                 .init_hook = alc885_imac24_init_hook,
6509         },
6510         [ALC882_TARGA] = {
6511                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
6512                             alc882_capture_mixer },
6513                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6514                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6515                 .dac_nids = alc882_dac_nids,
6516                 .dig_out_nid = ALC882_DIGOUT_NID,
6517                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6518                 .adc_nids = alc882_adc_nids,
6519                 .capsrc_nids = alc882_capsrc_nids,
6520                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6521                 .channel_mode = alc882_3ST_6ch_modes,
6522                 .need_dac_fix = 1,
6523                 .input_mux = &alc882_capture_source,
6524                 .unsol_event = alc882_targa_unsol_event,
6525                 .init_hook = alc882_targa_automute,
6526         },
6527         [ALC882_ASUS_A7J] = {
6528                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
6529                             alc882_capture_mixer },
6530                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6531                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6532                 .dac_nids = alc882_dac_nids,
6533                 .dig_out_nid = ALC882_DIGOUT_NID,
6534                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6535                 .adc_nids = alc882_adc_nids,
6536                 .capsrc_nids = alc882_capsrc_nids,
6537                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6538                 .channel_mode = alc882_3ST_6ch_modes,
6539                 .need_dac_fix = 1,
6540                 .input_mux = &alc882_capture_source,
6541         },
6542         [ALC882_ASUS_A7M] = {
6543                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6544                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6545                                 alc880_gpio1_init_verbs,
6546                                 alc882_asus_a7m_verbs },
6547                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6548                 .dac_nids = alc882_dac_nids,
6549                 .dig_out_nid = ALC882_DIGOUT_NID,
6550                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6551                 .channel_mode = alc880_threestack_modes,
6552                 .need_dac_fix = 1,
6553                 .input_mux = &alc882_capture_source,
6554         },
6555 };
6556
6557
6558 /*
6559  * Pin config fixes
6560  */
6561 enum {
6562         PINFIX_ABIT_AW9D_MAX
6563 };
6564
6565 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6566         { 0x15, 0x01080104 }, /* side */
6567         { 0x16, 0x01011012 }, /* rear */
6568         { 0x17, 0x01016011 }, /* clfe */
6569         { }
6570 };
6571
6572 static const struct alc_pincfg *alc882_pin_fixes[] = {
6573         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6574 };
6575
6576 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6577         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6578         {}
6579 };
6580
6581 /*
6582  * BIOS auto configuration
6583  */
6584 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6585                                               hda_nid_t nid, int pin_type,
6586                                               int dac_idx)
6587 {
6588         /* set as output */
6589         struct alc_spec *spec = codec->spec;
6590         int idx;
6591
6592         alc_set_pin_output(codec, nid, pin_type);
6593         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6594                 idx = 4;
6595         else
6596                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6597         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6598
6599 }
6600
6601 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6602 {
6603         struct alc_spec *spec = codec->spec;
6604         int i;
6605
6606         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6607         for (i = 0; i <= HDA_SIDE; i++) {
6608                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6609                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6610                 if (nid)
6611                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6612                                                           i);
6613         }
6614 }
6615
6616 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6617 {
6618         struct alc_spec *spec = codec->spec;
6619         hda_nid_t pin;
6620
6621         pin = spec->autocfg.hp_pins[0];
6622         if (pin) /* connect to front */
6623                 /* use dac 0 */
6624                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6625         pin = spec->autocfg.speaker_pins[0];
6626         if (pin)
6627                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6628 }
6629
6630 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
6631 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
6632
6633 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6634 {
6635         struct alc_spec *spec = codec->spec;
6636         int i;
6637
6638         for (i = 0; i < AUTO_PIN_LAST; i++) {
6639                 hda_nid_t nid = spec->autocfg.input_pins[i];
6640                 unsigned int vref;
6641                 if (!nid)
6642                         continue;
6643                 vref = PIN_IN;
6644                 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6645                         unsigned int pincap;
6646                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6647                         if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6648                             AC_PINCAP_VREF_80)
6649                                 vref = PIN_VREF80;
6650                 }
6651                 snd_hda_codec_write(codec, nid, 0,
6652                                     AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6653                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6654                         snd_hda_codec_write(codec, nid, 0,
6655                                             AC_VERB_SET_AMP_GAIN_MUTE,
6656                                             AMP_OUT_MUTE);
6657         }
6658 }
6659
6660 static void alc882_auto_init_input_src(struct hda_codec *codec)
6661 {
6662         struct alc_spec *spec = codec->spec;
6663         const struct hda_input_mux *imux = spec->input_mux;
6664         int c;
6665
6666         for (c = 0; c < spec->num_adc_nids; c++) {
6667                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
6668                 hda_nid_t nid = spec->capsrc_nids[c];
6669                 int conns, mute, idx, item;
6670
6671                 conns = snd_hda_get_connections(codec, nid, conn_list,
6672                                                 ARRAY_SIZE(conn_list));
6673                 if (conns < 0)
6674                         continue;
6675                 for (idx = 0; idx < conns; idx++) {
6676                         /* if the current connection is the selected one,
6677                          * unmute it as default - otherwise mute it
6678                          */
6679                         mute = AMP_IN_MUTE(idx);
6680                         for (item = 0; item < imux->num_items; item++) {
6681                                 if (imux->items[item].index == idx) {
6682                                         if (spec->cur_mux[c] == item)
6683                                                 mute = AMP_IN_UNMUTE(idx);
6684                                         break;
6685                                 }
6686                         }
6687                         snd_hda_codec_write(codec, nid, 0,
6688                                             AC_VERB_SET_AMP_GAIN_MUTE, mute);
6689                 }
6690         }
6691 }
6692
6693 /* add mic boosts if needed */
6694 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6695 {
6696         struct alc_spec *spec = codec->spec;
6697         int err;
6698         hda_nid_t nid;
6699
6700         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6701         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6702                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6703                                   "Mic Boost",
6704                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6705                 if (err < 0)
6706                         return err;
6707         }
6708         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6709         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6710                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6711                                   "Front Mic Boost",
6712                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6713                 if (err < 0)
6714                         return err;
6715         }
6716         return 0;
6717 }
6718
6719 /* almost identical with ALC880 parser... */
6720 static int alc882_parse_auto_config(struct hda_codec *codec)
6721 {
6722         struct alc_spec *spec = codec->spec;
6723         int err = alc880_parse_auto_config(codec);
6724
6725         if (err < 0)
6726                 return err;
6727         else if (!err)
6728                 return 0; /* no config found */
6729
6730         err = alc_auto_add_mic_boost(codec);
6731         if (err < 0)
6732                 return err;
6733
6734         /* hack - override the init verbs */
6735         spec->init_verbs[0] = alc882_auto_init_verbs;
6736
6737         return 1; /* config found */
6738 }
6739
6740 /* additional initialization for auto-configuration model */
6741 static void alc882_auto_init(struct hda_codec *codec)
6742 {
6743         struct alc_spec *spec = codec->spec;
6744         alc882_auto_init_multi_out(codec);
6745         alc882_auto_init_hp_out(codec);
6746         alc882_auto_init_analog_input(codec);
6747         alc882_auto_init_input_src(codec);
6748         if (spec->unsol_event)
6749                 alc_inithook(codec);
6750 }
6751
6752 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
6753
6754 static int patch_alc882(struct hda_codec *codec)
6755 {
6756         struct alc_spec *spec;
6757         int err, board_config;
6758
6759         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6760         if (spec == NULL)
6761                 return -ENOMEM;
6762
6763         codec->spec = spec;
6764
6765         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
6766                                                   alc882_models,
6767                                                   alc882_cfg_tbl);
6768
6769         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
6770                 /* Pick up systems that don't supply PCI SSID */
6771                 switch (codec->subsystem_id) {
6772                 case 0x106b0c00: /* Mac Pro */
6773                         board_config = ALC885_MACPRO;
6774                         break;
6775                 case 0x106b1000: /* iMac 24 */
6776                 case 0x106b2800: /* AppleTV */
6777                         board_config = ALC885_IMAC24;
6778                         break;
6779                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
6780                 case 0x106b00a4: /* MacbookPro4,1 */
6781                 case 0x106b2c00: /* Macbook Pro rev3 */
6782                 case 0x106b3600: /* Macbook 3.1 */
6783                         board_config = ALC885_MBP3;
6784                         break;
6785                 default:
6786                         /* ALC889A is handled better as ALC888-compatible */
6787                         if (codec->revision_id == 0x100101 ||
6788                             codec->revision_id == 0x100103) {
6789                                 alc_free(codec);
6790                                 return patch_alc883(codec);
6791                         }
6792                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
6793                                          "trying auto-probe from BIOS...\n");
6794                         board_config = ALC882_AUTO;
6795                 }
6796         }
6797
6798         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
6799
6800         if (board_config == ALC882_AUTO) {
6801                 /* automatic parse from the BIOS config */
6802                 err = alc882_parse_auto_config(codec);
6803                 if (err < 0) {
6804                         alc_free(codec);
6805                         return err;
6806                 } else if (!err) {
6807                         printk(KERN_INFO
6808                                "hda_codec: Cannot set up configuration "
6809                                "from BIOS.  Using base mode...\n");
6810                         board_config = ALC882_3ST_DIG;
6811                 }
6812         }
6813
6814         if (board_config != ALC882_AUTO)
6815                 setup_preset(spec, &alc882_presets[board_config]);
6816
6817         if (codec->vendor_id == 0x10ec0885) {
6818                 spec->stream_name_analog = "ALC885 Analog";
6819                 spec->stream_name_digital = "ALC885 Digital";
6820         } else {
6821                 spec->stream_name_analog = "ALC882 Analog";
6822                 spec->stream_name_digital = "ALC882 Digital";
6823         }
6824
6825         spec->stream_analog_playback = &alc882_pcm_analog_playback;
6826         spec->stream_analog_capture = &alc882_pcm_analog_capture;
6827         /* FIXME: setup DAC5 */
6828         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
6829         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
6830
6831         spec->stream_digital_playback = &alc882_pcm_digital_playback;
6832         spec->stream_digital_capture = &alc882_pcm_digital_capture;
6833
6834         if (!spec->adc_nids && spec->input_mux) {
6835                 /* check whether NID 0x07 is valid */
6836                 unsigned int wcap = get_wcaps(codec, 0x07);
6837                 /* get type */
6838                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6839                 if (wcap != AC_WID_AUD_IN) {
6840                         spec->adc_nids = alc882_adc_nids_alt;
6841                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
6842                         spec->capsrc_nids = alc882_capsrc_nids_alt;
6843                         spec->mixers[spec->num_mixers] =
6844                                 alc882_capture_alt_mixer;
6845                         spec->num_mixers++;
6846                 } else {
6847                         spec->adc_nids = alc882_adc_nids;
6848                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
6849                         spec->capsrc_nids = alc882_capsrc_nids;
6850                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
6851                         spec->num_mixers++;
6852                 }
6853         }
6854
6855         spec->vmaster_nid = 0x0c;
6856
6857         codec->patch_ops = alc_patch_ops;
6858         if (board_config == ALC882_AUTO)
6859                 spec->init_hook = alc882_auto_init;
6860 #ifdef CONFIG_SND_HDA_POWER_SAVE
6861         if (!spec->loopback.amplist)
6862                 spec->loopback.amplist = alc882_loopbacks;
6863 #endif
6864
6865         return 0;
6866 }
6867
6868 /*
6869  * ALC883 support
6870  *
6871  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
6872  * configuration.  Each pin widget can choose any input DACs and a mixer.
6873  * Each ADC is connected from a mixer of all inputs.  This makes possible
6874  * 6-channel independent captures.
6875  *
6876  * In addition, an independent DAC for the multi-playback (not used in this
6877  * driver yet).
6878  */
6879 #define ALC883_DIGOUT_NID       0x06
6880 #define ALC883_DIGIN_NID        0x0a
6881
6882 static hda_nid_t alc883_dac_nids[4] = {
6883         /* front, rear, clfe, rear_surr */
6884         0x02, 0x03, 0x04, 0x05
6885 };
6886
6887 static hda_nid_t alc883_adc_nids[2] = {
6888         /* ADC1-2 */
6889         0x08, 0x09,
6890 };
6891
6892 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
6893
6894 /* input MUX */
6895 /* FIXME: should be a matrix-type input source selection */
6896
6897 static struct hda_input_mux alc883_capture_source = {
6898         .num_items = 4,
6899         .items = {
6900                 { "Mic", 0x0 },
6901                 { "Front Mic", 0x1 },
6902                 { "Line", 0x2 },
6903                 { "CD", 0x4 },
6904         },
6905 };
6906
6907 static struct hda_input_mux alc883_3stack_6ch_intel = {
6908         .num_items = 4,
6909         .items = {
6910                 { "Mic", 0x1 },
6911                 { "Front Mic", 0x0 },
6912                 { "Line", 0x2 },
6913                 { "CD", 0x4 },
6914         },
6915 };
6916
6917 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6918         .num_items = 2,
6919         .items = {
6920                 { "Mic", 0x1 },
6921                 { "Line", 0x2 },
6922         },
6923 };
6924
6925 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6926         .num_items = 4,
6927         .items = {
6928                 { "Mic", 0x0 },
6929                 { "iMic", 0x1 },
6930                 { "Line", 0x2 },
6931                 { "CD", 0x4 },
6932         },
6933 };
6934
6935 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6936         .num_items = 2,
6937         .items = {
6938                 { "Mic", 0x0 },
6939                 { "Int Mic", 0x1 },
6940         },
6941 };
6942
6943 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6944         .num_items = 3,
6945         .items = {
6946                 { "Mic", 0x0 },
6947                 { "Front Mic", 0x1 },
6948                 { "Line", 0x4 },
6949         },
6950 };
6951
6952 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6953         .num_items = 2,
6954         .items = {
6955                 { "Mic", 0x0 },
6956                 { "Line", 0x2 },
6957         },
6958 };
6959
6960 #define alc883_mux_enum_info alc_mux_enum_info
6961 #define alc883_mux_enum_get alc_mux_enum_get
6962 /* ALC883 has the ALC882-type input selection */
6963 #define alc883_mux_enum_put alc882_mux_enum_put
6964
6965 /*
6966  * 2ch mode
6967  */
6968 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6969         { 2, NULL }
6970 };
6971
6972 /*
6973  * 2ch mode
6974  */
6975 static struct hda_verb alc883_3ST_ch2_init[] = {
6976         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6977         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6978         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6979         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6980         { } /* end */
6981 };
6982
6983 /*
6984  * 4ch mode
6985  */
6986 static struct hda_verb alc883_3ST_ch4_init[] = {
6987         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6988         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6989         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6990         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6991         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6992         { } /* end */
6993 };
6994
6995 /*
6996  * 6ch mode
6997  */
6998 static struct hda_verb alc883_3ST_ch6_init[] = {
6999         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7000         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7001         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7002         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7003         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7004         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7005         { } /* end */
7006 };
7007
7008 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7009         { 2, alc883_3ST_ch2_init },
7010         { 4, alc883_3ST_ch4_init },
7011         { 6, alc883_3ST_ch6_init },
7012 };
7013
7014 /*
7015  * 2ch mode
7016  */
7017 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7018         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7019         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7020         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7021         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7022         { } /* end */
7023 };
7024
7025 /*
7026  * 4ch mode
7027  */
7028 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7029         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7030         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7031         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7032         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7033         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7034         { } /* end */
7035 };
7036
7037 /*
7038  * 6ch mode
7039  */
7040 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7041         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7042         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7043         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7044         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7045         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7046         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7047         { } /* end */
7048 };
7049
7050 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7051         { 2, alc883_3ST_ch2_intel_init },
7052         { 4, alc883_3ST_ch4_intel_init },
7053         { 6, alc883_3ST_ch6_intel_init },
7054 };
7055
7056 /*
7057  * 6ch mode
7058  */
7059 static struct hda_verb alc883_sixstack_ch6_init[] = {
7060         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7061         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7062         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7063         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7064         { } /* end */
7065 };
7066
7067 /*
7068  * 8ch mode
7069  */
7070 static struct hda_verb alc883_sixstack_ch8_init[] = {
7071         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7072         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7073         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7074         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7075         { } /* end */
7076 };
7077
7078 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7079         { 6, alc883_sixstack_ch6_init },
7080         { 8, alc883_sixstack_ch8_init },
7081 };
7082
7083 static struct hda_verb alc883_medion_eapd_verbs[] = {
7084         /* eanable EAPD on medion laptop */
7085         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7086         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7087         { }
7088 };
7089
7090 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7091  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7092  */
7093
7094 static struct snd_kcontrol_new alc883_base_mixer[] = {
7095         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7096         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7097         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7098         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7099         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7100         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7101         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7102         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7103         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7104         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7105         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7108         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7109         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7110         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7111         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7112         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7113         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7114         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7115         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7116         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7117         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7118         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7119         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7120         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7121         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7122         {
7123                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7124                 /* .name = "Capture Source", */
7125                 .name = "Input Source",
7126                 .count = 2,
7127                 .info = alc883_mux_enum_info,
7128                 .get = alc883_mux_enum_get,
7129                 .put = alc883_mux_enum_put,
7130         },
7131         { } /* end */
7132 };
7133
7134 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7135         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7136         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7137         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7138         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7139         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7140         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7141         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7142         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7143         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7144         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7145         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7146         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7147         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7148         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7149         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7150         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7151         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7152         {
7153                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7154                 /* .name = "Capture Source", */
7155                 .name = "Input Source",
7156                 .count = 2,
7157                 .info = alc883_mux_enum_info,
7158                 .get = alc883_mux_enum_get,
7159                 .put = alc883_mux_enum_put,
7160         },
7161         { } /* end */
7162 };
7163
7164 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7165         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7166         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7167         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7168         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7169         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7170         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7171         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7172         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7173         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7174         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7175         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7176         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7177         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7178         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7179         {
7180                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7181                 /* .name = "Capture Source", */
7182                 .name = "Input Source",
7183                 .count = 2,
7184                 .info = alc883_mux_enum_info,
7185                 .get = alc883_mux_enum_get,
7186                 .put = alc883_mux_enum_put,
7187         },
7188         { } /* end */
7189 };
7190
7191 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7192         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7193         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7194         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7195         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7196         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7197         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7198         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7199         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7200         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7201         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7202         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7203         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7204         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7205         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7206         {
7207                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7208                 /* .name = "Capture Source", */
7209                 .name = "Input Source",
7210                 .count = 2,
7211                 .info = alc883_mux_enum_info,
7212                 .get = alc883_mux_enum_get,
7213                 .put = alc883_mux_enum_put,
7214         },
7215         { } /* end */
7216 };
7217
7218 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7219         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7220         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7221         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7222         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7223         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7224         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7225         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7226         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7227         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7228         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7229         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7230         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7231         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7232         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7233         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7234         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7235         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7236         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7237         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7238         {
7239                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7240                 /* .name = "Capture Source", */
7241                 .name = "Input Source",
7242                 .count = 2,
7243                 .info = alc883_mux_enum_info,
7244                 .get = alc883_mux_enum_get,
7245                 .put = alc883_mux_enum_put,
7246         },
7247         { } /* end */
7248 };
7249
7250 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7251         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7252         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7253         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7254         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7255         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7256         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7257         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7258         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7259         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7260         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7261         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7262         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7263         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7264         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7265         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7266         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7267         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7268         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7269         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7270         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7271         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7272         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7273         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7274         {
7275                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7276                 /* .name = "Capture Source", */
7277                 .name = "Input Source",
7278                 .count = 1,
7279                 .info = alc883_mux_enum_info,
7280                 .get = alc883_mux_enum_get,
7281                 .put = alc883_mux_enum_put,
7282         },
7283         { } /* end */
7284 };
7285
7286 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7287         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7288         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7289         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7290         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7291         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7292                               HDA_OUTPUT),
7293         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7294         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7295         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7296         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7297         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7298         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7299         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7300         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7301         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7302         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7303         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7304         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7305         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7306         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7307         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7308         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7309         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7310         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7311         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7312         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7313         {
7314                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7315                 /* .name = "Capture Source", */
7316                 .name = "Input Source",
7317                 .count = 2,
7318                 .info = alc883_mux_enum_info,
7319                 .get = alc883_mux_enum_get,
7320                 .put = alc883_mux_enum_put,
7321         },
7322         { } /* end */
7323 };
7324
7325 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7326         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7327         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7328         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7329         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7330         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7331         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7332         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7333         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7334         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7335         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7336         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7337         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7338         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7339         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7340         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7341         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7342         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7343         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7344         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7345         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
7346         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
7347         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7348         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7349
7350         {
7351                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7352                 /* .name = "Capture Source", */
7353                 .name = "Input Source",
7354                 .count = 1,
7355                 .info = alc883_mux_enum_info,
7356                 .get = alc883_mux_enum_get,
7357                 .put = alc883_mux_enum_put,
7358         },
7359         { } /* end */
7360 };
7361
7362 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7363         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7364         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7365         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7366         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7367         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7368         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7369         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7370         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7371         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7372         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7373         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7374         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7375         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7376         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7377         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7378         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7379         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7380         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7381         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7382         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7383         {
7384                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7385                 /* .name = "Capture Source", */
7386                 .name = "Input Source",
7387                 .count = 2,
7388                 .info = alc883_mux_enum_info,
7389                 .get = alc883_mux_enum_get,
7390                 .put = alc883_mux_enum_put,
7391         },
7392         { } /* end */
7393 };
7394
7395 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7396         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7397         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7398         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7399         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7400         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7401         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7402         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7403         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7404         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7405         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7406         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7407         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7408         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7409         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7410         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7411         {
7412                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7413                 /* .name = "Capture Source", */
7414                 .name = "Input Source",
7415                 .count = 2,
7416                 .info = alc883_mux_enum_info,
7417                 .get = alc883_mux_enum_get,
7418                 .put = alc883_mux_enum_put,
7419         },
7420         { } /* end */
7421 };
7422
7423 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7424         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7425         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7426         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7427         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7428         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7429         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7430         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7431         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7432         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7433         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7434         {
7435                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7436                 /* .name = "Capture Source", */
7437                 .name = "Input Source",
7438                 .count = 1,
7439                 .info = alc883_mux_enum_info,
7440                 .get = alc883_mux_enum_get,
7441                 .put = alc883_mux_enum_put,
7442         },
7443         { } /* end */
7444 };
7445
7446 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7447         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7448         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7449         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7450         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7451         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7452         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7453         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7454         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7455         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7456         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7457         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7458         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7459         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7460         {
7461                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7462                 /* .name = "Capture Source", */
7463                 .name = "Input Source",
7464                 .count = 2,
7465                 .info = alc883_mux_enum_info,
7466                 .get = alc883_mux_enum_get,
7467                 .put = alc883_mux_enum_put,
7468         },
7469         { } /* end */
7470 };
7471
7472 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7473         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7474         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7475         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7476         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7477         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7478         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7479         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7480         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7481         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7482         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7483         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7484         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7485         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7486         {
7487                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7488                 /* .name = "Capture Source", */
7489                 .name = "Input Source",
7490                 .count = 2,
7491                 .info = alc883_mux_enum_info,
7492                 .get = alc883_mux_enum_get,
7493                 .put = alc883_mux_enum_put,
7494         },
7495         { } /* end */
7496 };
7497
7498 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7499         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7500         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7501         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7502         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7503         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7504         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7505         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7506         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7507         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7508         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7509         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7510         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7511         {
7512                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7513                 /* .name = "Capture Source", */
7514                 .name = "Input Source",
7515                 .count = 2,
7516                 .info = alc883_mux_enum_info,
7517                 .get = alc883_mux_enum_get,
7518                 .put = alc883_mux_enum_put,
7519         },
7520         { } /* end */
7521 };
7522
7523 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7524         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7525         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7526         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7527         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7528         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7529                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7530         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7531         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7532         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7533         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7534         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7535         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7536         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7537         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7538         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7539         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7540         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7541         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7542         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7543         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7544         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7545         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7546         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7547         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
7548         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
7549         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
7550         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
7551         {
7552                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7553                 /* .name = "Capture Source", */
7554                 .name = "Input Source",
7555                 .count = 2,
7556                 .info = alc883_mux_enum_info,
7557                 .get = alc883_mux_enum_get,
7558                 .put = alc883_mux_enum_put,
7559         },
7560         { } /* end */
7561 };
7562
7563 static struct hda_bind_ctls alc883_bind_cap_vol = {
7564         .ops = &snd_hda_bind_vol,
7565         .values = {
7566                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7567                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7568                 0
7569         },
7570 };
7571
7572 static struct hda_bind_ctls alc883_bind_cap_switch = {
7573         .ops = &snd_hda_bind_sw,
7574         .values = {
7575                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7576                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7577                 0
7578         },
7579 };
7580
7581 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7582         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7583         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7584         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7585         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7586         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7587         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7588         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7589         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7590         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7591         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7592         {
7593                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7594                 /* .name = "Capture Source", */
7595                 .name = "Input Source",
7596                 .count = 1,
7597                 .info = alc883_mux_enum_info,
7598                 .get = alc883_mux_enum_get,
7599                 .put = alc883_mux_enum_put,
7600         },
7601         { } /* end */
7602 };
7603
7604 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7605         {
7606                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7607                 .name = "Channel Mode",
7608                 .info = alc_ch_mode_info,
7609                 .get = alc_ch_mode_get,
7610                 .put = alc_ch_mode_put,
7611         },
7612         { } /* end */
7613 };
7614
7615 static struct hda_verb alc883_init_verbs[] = {
7616         /* ADC1: mute amp left and right */
7617         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7618         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7619         /* ADC2: mute amp left and right */
7620         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7621         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7622         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7623         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7624         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7625         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7626         /* Rear mixer */
7627         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7628         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7629         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7630         /* CLFE mixer */
7631         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7632         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7633         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7634         /* Side mixer */
7635         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7636         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7637         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7638
7639         /* mute analog input loopbacks */
7640         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7641         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7642         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7643         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7644         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7645
7646         /* Front Pin: output 0 (0x0c) */
7647         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7648         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7649         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7650         /* Rear Pin: output 1 (0x0d) */
7651         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7652         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7653         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7654         /* CLFE Pin: output 2 (0x0e) */
7655         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7656         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7657         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7658         /* Side Pin: output 3 (0x0f) */
7659         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7660         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7661         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7662         /* Mic (rear) pin: input vref at 80% */
7663         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7664         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7665         /* Front Mic pin: input vref at 80% */
7666         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7667         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7668         /* Line In pin: input */
7669         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7670         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7671         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7672         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7673         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7674         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7675         /* CD pin widget for input */
7676         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7677
7678         /* FIXME: use matrix-type input source selection */
7679         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7680         /* Input mixer2 */
7681         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7682         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7683         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7684         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7685         /* Input mixer3 */
7686         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7687         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7688         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7689         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7690         { }
7691 };
7692
7693 /* toggle speaker-output according to the hp-jack state */
7694 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7695 {
7696         unsigned int present;
7697
7698         present = snd_hda_codec_read(codec, 0x15, 0,
7699                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7700         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7701                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7702         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7703                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7704 }
7705
7706 /* auto-toggle front mic */
7707 /*
7708 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7709 {
7710         unsigned int present;
7711         unsigned char bits;
7712
7713         present = snd_hda_codec_read(codec, 0x18, 0,
7714                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7715         bits = present ? HDA_AMP_MUTE : 0;
7716         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7717 }
7718 */
7719
7720 static void alc883_mitac_automute(struct hda_codec *codec)
7721 {
7722         alc883_mitac_hp_automute(codec);
7723         /* alc883_mitac_mic_automute(codec); */
7724 }
7725
7726 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7727                                            unsigned int res)
7728 {
7729         switch (res >> 26) {
7730         case ALC880_HP_EVENT:
7731                 alc883_mitac_hp_automute(codec);
7732                 break;
7733         case ALC880_MIC_EVENT:
7734                 /* alc883_mitac_mic_automute(codec); */
7735                 break;
7736         }
7737 }
7738
7739 static struct hda_verb alc883_mitac_verbs[] = {
7740         /* HP */
7741         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7742         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7743         /* Subwoofer */
7744         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7745         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7746
7747         /* enable unsolicited event */
7748         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7749         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7750
7751         { } /* end */
7752 };
7753
7754 static struct hda_verb alc883_clevo_m720_verbs[] = {
7755         /* HP */
7756         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7757         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7758         /* Int speaker */
7759         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7760         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7761
7762         /* enable unsolicited event */
7763         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7764         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7765
7766         { } /* end */
7767 };
7768
7769 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7770         /* HP */
7771         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7772         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7773         /* Subwoofer */
7774         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7775         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7776
7777         /* enable unsolicited event */
7778         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7779
7780         { } /* end */
7781 };
7782
7783 static struct hda_verb alc883_tagra_verbs[] = {
7784         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7785         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7786
7787         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7788         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7789
7790         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7791         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7792         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7793
7794         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7795         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7796         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7797         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7798
7799         { } /* end */
7800 };
7801
7802 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7803         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7804         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7805         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7806         { } /* end */
7807 };
7808
7809 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7810         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7811         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7812         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7813         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7814         { } /* end */
7815 };
7816
7817 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7818         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7819         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7820         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7821         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7822         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7823         { } /* end */
7824 };
7825
7826 static struct hda_verb alc883_haier_w66_verbs[] = {
7827         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7828         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7829
7830         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7831
7832         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7833         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7834         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7835         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7836         { } /* end */
7837 };
7838
7839 static struct hda_verb alc888_lenovo_sky_verbs[] = {
7840         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7841         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7842         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7843         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7844         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7845         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7846         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7847         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7848         { } /* end */
7849 };
7850
7851 static struct hda_verb alc888_3st_hp_verbs[] = {
7852         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7853         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7854         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7855         { }
7856 };
7857
7858 static struct hda_verb alc888_6st_dell_verbs[] = {
7859         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7860         { }
7861 };
7862
7863 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7864         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7865         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7866         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7867         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7868         { }
7869 };
7870
7871 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7872         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7873         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7874         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7875         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7876         { }
7877 };
7878
7879 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7880         { 2, alc888_3st_hp_2ch_init },
7881         { 6, alc888_3st_hp_6ch_init },
7882 };
7883
7884 /* toggle front-jack and RCA according to the hp-jack state */
7885 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7886 {
7887         unsigned int present;
7888
7889         present = snd_hda_codec_read(codec, 0x1b, 0,
7890                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7891         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7892                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7893         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7894                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7895 }
7896
7897 /* toggle RCA according to the front-jack state */
7898 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7899 {
7900         unsigned int present;
7901
7902         present = snd_hda_codec_read(codec, 0x14, 0,
7903                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7904         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7905                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7906 }
7907
7908 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7909                                              unsigned int res)
7910 {
7911         if ((res >> 26) == ALC880_HP_EVENT)
7912                 alc888_lenovo_ms7195_front_automute(codec);
7913         if ((res >> 26) == ALC880_FRONT_EVENT)
7914                 alc888_lenovo_ms7195_rca_automute(codec);
7915 }
7916
7917 static struct hda_verb alc883_medion_md2_verbs[] = {
7918         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7919         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7920
7921         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7922
7923         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7924         { } /* end */
7925 };
7926
7927 /* toggle speaker-output according to the hp-jack state */
7928 static void alc883_medion_md2_automute(struct hda_codec *codec)
7929 {
7930         unsigned int present;
7931
7932         present = snd_hda_codec_read(codec, 0x14, 0,
7933                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7934         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7935                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7936 }
7937
7938 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
7939                                           unsigned int res)
7940 {
7941         if ((res >> 26) == ALC880_HP_EVENT)
7942                 alc883_medion_md2_automute(codec);
7943 }
7944
7945 /* toggle speaker-output according to the hp-jack state */
7946 static void alc883_tagra_automute(struct hda_codec *codec)
7947 {
7948         unsigned int present;
7949         unsigned char bits;
7950
7951         present = snd_hda_codec_read(codec, 0x14, 0,
7952                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7953         bits = present ? HDA_AMP_MUTE : 0;
7954         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
7955                                  HDA_AMP_MUTE, bits);
7956         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7957                                   present ? 1 : 3);
7958 }
7959
7960 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
7961 {
7962         if ((res >> 26) == ALC880_HP_EVENT)
7963                 alc883_tagra_automute(codec);
7964 }
7965
7966 /* toggle speaker-output according to the hp-jack state */
7967 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
7968 {
7969         unsigned int present;
7970         unsigned char bits;
7971
7972         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
7973                 & AC_PINSENSE_PRESENCE;
7974         bits = present ? HDA_AMP_MUTE : 0;
7975         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7976                                  HDA_AMP_MUTE, bits);
7977 }
7978
7979 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
7980 {
7981         unsigned int present;
7982
7983         present = snd_hda_codec_read(codec, 0x18, 0,
7984                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7985         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
7986                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7987 }
7988
7989 static void alc883_clevo_m720_automute(struct hda_codec *codec)
7990 {
7991         alc883_clevo_m720_hp_automute(codec);
7992         alc883_clevo_m720_mic_automute(codec);
7993 }
7994
7995 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
7996                                            unsigned int res)
7997 {
7998         switch (res >> 26) {
7999         case ALC880_HP_EVENT:
8000                 alc883_clevo_m720_hp_automute(codec);
8001                 break;
8002         case ALC880_MIC_EVENT:
8003                 alc883_clevo_m720_mic_automute(codec);
8004                 break;
8005         }
8006 }
8007
8008 /* toggle speaker-output according to the hp-jack state */
8009 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8010 {
8011         unsigned int present;
8012         unsigned char bits;
8013
8014         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8015                 & AC_PINSENSE_PRESENCE;
8016         bits = present ? HDA_AMP_MUTE : 0;
8017         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8018                                  HDA_AMP_MUTE, bits);
8019 }
8020
8021 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8022                                                   unsigned int res)
8023 {
8024         if ((res >> 26) == ALC880_HP_EVENT)
8025                 alc883_2ch_fujitsu_pi2515_automute(codec);
8026 }
8027
8028 static void alc883_haier_w66_automute(struct hda_codec *codec)
8029 {
8030         unsigned int present;
8031         unsigned char bits;
8032
8033         present = snd_hda_codec_read(codec, 0x1b, 0,
8034                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8035         bits = present ? 0x80 : 0;
8036         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8037                                  0x80, bits);
8038 }
8039
8040 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8041                                          unsigned int res)
8042 {
8043         if ((res >> 26) == ALC880_HP_EVENT)
8044                 alc883_haier_w66_automute(codec);
8045 }
8046
8047 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8048 {
8049         unsigned int present;
8050         unsigned char bits;
8051
8052         present = snd_hda_codec_read(codec, 0x14, 0,
8053                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8054         bits = present ? HDA_AMP_MUTE : 0;
8055         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8056                                  HDA_AMP_MUTE, bits);
8057 }
8058
8059 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8060 {
8061         unsigned int present;
8062         unsigned char bits;
8063
8064         present = snd_hda_codec_read(codec, 0x1b, 0,
8065                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8066         bits = present ? HDA_AMP_MUTE : 0;
8067         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8068                                  HDA_AMP_MUTE, bits);
8069         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8070                                  HDA_AMP_MUTE, bits);
8071 }
8072
8073 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8074                                            unsigned int res)
8075 {
8076         if ((res >> 26) == ALC880_HP_EVENT)
8077                 alc883_lenovo_101e_all_automute(codec);
8078         if ((res >> 26) == ALC880_FRONT_EVENT)
8079                 alc883_lenovo_101e_ispeaker_automute(codec);
8080 }
8081
8082 /* toggle speaker-output according to the hp-jack state */
8083 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8084 {
8085         unsigned int present;
8086
8087         present = snd_hda_codec_read(codec, 0x14, 0,
8088                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8089         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8090                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8091         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8092                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8093 }
8094
8095 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8096                                            unsigned int res)
8097 {
8098         if ((res >> 26) == ALC880_HP_EVENT)
8099                 alc883_acer_aspire_automute(codec);
8100 }
8101
8102 static struct hda_verb alc883_acer_eapd_verbs[] = {
8103         /* HP Pin: output 0 (0x0c) */
8104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8106         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8107         /* Front Pin: output 0 (0x0c) */
8108         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8109         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8110         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8111         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8112         /* eanable EAPD on medion laptop */
8113         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8114         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8115         /* enable unsolicited event */
8116         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8117         { }
8118 };
8119
8120 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8121 {
8122         unsigned int present;
8123
8124         present = snd_hda_codec_read(codec, 0x1b, 0,
8125                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8126         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8127                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8128         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8129                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8130         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8131                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8132         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8133                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8134 }
8135
8136 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8137                                              unsigned int res)
8138 {
8139         switch (res >> 26) {
8140         case ALC880_HP_EVENT:
8141                 printk("hp_event\n");
8142                 alc888_6st_dell_front_automute(codec);
8143                 break;
8144         }
8145 }
8146
8147 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8148 {
8149         unsigned int mute;
8150         unsigned int present;
8151
8152         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8153         present = snd_hda_codec_read(codec, 0x1b, 0,
8154                                      AC_VERB_GET_PIN_SENSE, 0);
8155         present = (present & 0x80000000) != 0;
8156         if (present) {
8157                 /* mute internal speaker */
8158                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8159                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8160                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8161                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8162                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8163                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8164                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8165                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8166                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8167                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8168         } else {
8169                 /* unmute internal speaker if necessary */
8170                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8171                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8172                                          HDA_AMP_MUTE, mute);
8173                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8174                                          HDA_AMP_MUTE, mute);
8175                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8176                                          HDA_AMP_MUTE, mute);
8177                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8178                                          HDA_AMP_MUTE, mute);
8179                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8180                                          HDA_AMP_MUTE, mute);
8181         }
8182 }
8183
8184 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8185                                              unsigned int res)
8186 {
8187         if ((res >> 26) == ALC880_HP_EVENT)
8188                 alc888_lenovo_sky_front_automute(codec);
8189 }
8190
8191 /*
8192  * generic initialization of ADC, input mixers and output mixers
8193  */
8194 static struct hda_verb alc883_auto_init_verbs[] = {
8195         /*
8196          * Unmute ADC0-2 and set the default input to mic-in
8197          */
8198         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8199         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8200         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8201         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8202
8203         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8204          * mixer widget
8205          * Note: PASD motherboards uses the Line In 2 as the input for
8206          * front panel mic (mic 2)
8207          */
8208         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8209         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8210         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8211         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8212         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8213         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8214
8215         /*
8216          * Set up output mixers (0x0c - 0x0f)
8217          */
8218         /* set vol=0 to output mixers */
8219         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8220         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8221         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8222         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8223         /* set up input amps for analog loopback */
8224         /* Amp Indices: DAC = 0, mixer = 1 */
8225         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8226         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8227         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8228         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8229         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8230         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8231         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8232         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8233         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8234         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8235
8236         /* FIXME: use matrix-type input source selection */
8237         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8238         /* Input mixer1 */
8239         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8240         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8241         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8242         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8243         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8244         /* Input mixer2 */
8245         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8246         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8247         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8248         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8249         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8250
8251         { }
8252 };
8253
8254 /* capture mixer elements */
8255 static struct snd_kcontrol_new alc883_capture_mixer[] = {
8256         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
8257         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
8258         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
8259         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
8260         {
8261                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8262                 /* The multiple "Capture Source" controls confuse alsamixer
8263                  * So call somewhat different..
8264                  */
8265                 /* .name = "Capture Source", */
8266                 .name = "Input Source",
8267                 .count = 2,
8268                 .info = alc882_mux_enum_info,
8269                 .get = alc882_mux_enum_get,
8270                 .put = alc882_mux_enum_put,
8271         },
8272         { } /* end */
8273 };
8274
8275 static struct hda_verb alc888_asus_m90v_verbs[] = {
8276         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8277         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8278         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8279         /* enable unsolicited event */
8280         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8281         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8282         { } /* end */
8283 };
8284
8285 static void alc883_nb_mic_automute(struct hda_codec *codec)
8286 {
8287         unsigned int present;
8288
8289         present = snd_hda_codec_read(codec, 0x18, 0,
8290                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8291         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8292                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8293         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8294                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8295 }
8296
8297 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8298 {
8299         unsigned int present;
8300         unsigned char bits;
8301
8302         present = snd_hda_codec_read(codec, 0x1b, 0,
8303                                      AC_VERB_GET_PIN_SENSE, 0)
8304                 & AC_PINSENSE_PRESENCE;
8305         bits = present ? 0 : PIN_OUT;
8306         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8307                             bits);
8308         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8309                             bits);
8310         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8311                             bits);
8312 }
8313
8314 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8315                                            unsigned int res)
8316 {
8317         switch (res >> 26) {
8318         case ALC880_HP_EVENT:
8319                 alc883_M90V_speaker_automute(codec);
8320                 break;
8321         case ALC880_MIC_EVENT:
8322                 alc883_nb_mic_automute(codec);
8323                 break;
8324         }
8325 }
8326
8327 static void alc883_mode2_inithook(struct hda_codec *codec)
8328 {
8329         alc883_M90V_speaker_automute(codec);
8330         alc883_nb_mic_automute(codec);
8331 }
8332
8333 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8334         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8335         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8336         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8337         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8338         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8339         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8340         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8341         /* enable unsolicited event */
8342         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8343         { } /* end */
8344 };
8345
8346 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8347 {
8348         unsigned int present;
8349         unsigned char bits;
8350
8351         present = snd_hda_codec_read(codec, 0x14, 0,
8352                                      AC_VERB_GET_PIN_SENSE, 0)
8353                 & AC_PINSENSE_PRESENCE;
8354         bits = present ? 0 : PIN_OUT;
8355         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8356                             bits);
8357 }
8358
8359 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8360                                            unsigned int res)
8361 {
8362         switch (res >> 26) {
8363         case ALC880_HP_EVENT:
8364                 alc883_eee1601_speaker_automute(codec);
8365                 break;
8366         }
8367 }
8368
8369 static void alc883_eee1601_inithook(struct hda_codec *codec)
8370 {
8371         alc883_eee1601_speaker_automute(codec);
8372 }
8373
8374 #ifdef CONFIG_SND_HDA_POWER_SAVE
8375 #define alc883_loopbacks        alc880_loopbacks
8376 #endif
8377
8378 /* pcm configuration: identiacal with ALC880 */
8379 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8380 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8381 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8382 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8383 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8384
8385 /*
8386  * configuration and preset
8387  */
8388 static const char *alc883_models[ALC883_MODEL_LAST] = {
8389         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8390         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8391         [ALC883_3ST_6ch]        = "3stack-6ch",
8392         [ALC883_6ST_DIG]        = "6stack-dig",
8393         [ALC883_TARGA_DIG]      = "targa-dig",
8394         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8395         [ALC883_ACER]           = "acer",
8396         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8397         [ALC883_MEDION]         = "medion",
8398         [ALC883_MEDION_MD2]     = "medion-md2",
8399         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8400         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8401         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8402         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8403         [ALC888_LENOVO_SKY] = "lenovo-sky",
8404         [ALC883_HAIER_W66]      = "haier-w66",
8405         [ALC888_3ST_HP]         = "3stack-hp",
8406         [ALC888_6ST_DELL]       = "6stack-dell",
8407         [ALC883_MITAC]          = "mitac",
8408         [ALC883_CLEVO_M720]     = "clevo-m720",
8409         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8410         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8411         [ALC883_AUTO]           = "auto",
8412 };
8413
8414 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8415         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8416         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8417         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8418         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8419         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8420         SND_PCI_QUIRK(0x1025, 0, "Acer laptop", ALC883_ACER), /* default Acer */
8421         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8422         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8423         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8424         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8425         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8426         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8427         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8428         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8429         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8430         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8431         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8432         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8433         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8434         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8435         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8436         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8437         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8438         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8439         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8440         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8441         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8442         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8443         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8444         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8445         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8446         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8447         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8448         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8449         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8450         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8451         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8452         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8453         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8454         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8455         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8456         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8457         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8458         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8459         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8460         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8461         SND_PCI_QUIRK(0x1558, 0, "Clevo laptop", ALC883_LAPTOP_EAPD),
8462         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8463         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8464         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8465         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8466         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8467         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8468         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8469         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8470         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8471         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8472         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8473         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8474         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8475         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8476         {}
8477 };
8478
8479 static struct alc_config_preset alc883_presets[] = {
8480         [ALC883_3ST_2ch_DIG] = {
8481                 .mixers = { alc883_3ST_2ch_mixer },
8482                 .init_verbs = { alc883_init_verbs },
8483                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8484                 .dac_nids = alc883_dac_nids,
8485                 .dig_out_nid = ALC883_DIGOUT_NID,
8486                 .dig_in_nid = ALC883_DIGIN_NID,
8487                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8488                 .channel_mode = alc883_3ST_2ch_modes,
8489                 .input_mux = &alc883_capture_source,
8490         },
8491         [ALC883_3ST_6ch_DIG] = {
8492                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8493                 .init_verbs = { alc883_init_verbs },
8494                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8495                 .dac_nids = alc883_dac_nids,
8496                 .dig_out_nid = ALC883_DIGOUT_NID,
8497                 .dig_in_nid = ALC883_DIGIN_NID,
8498                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8499                 .channel_mode = alc883_3ST_6ch_modes,
8500                 .need_dac_fix = 1,
8501                 .input_mux = &alc883_capture_source,
8502         },
8503         [ALC883_3ST_6ch] = {
8504                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8505                 .init_verbs = { alc883_init_verbs },
8506                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8507                 .dac_nids = alc883_dac_nids,
8508                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8509                 .channel_mode = alc883_3ST_6ch_modes,
8510                 .need_dac_fix = 1,
8511                 .input_mux = &alc883_capture_source,
8512         },
8513         [ALC883_3ST_6ch_INTEL] = {
8514                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8515                 .init_verbs = { alc883_init_verbs },
8516                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8517                 .dac_nids = alc883_dac_nids,
8518                 .dig_out_nid = ALC883_DIGOUT_NID,
8519                 .dig_in_nid = ALC883_DIGIN_NID,
8520                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8521                 .channel_mode = alc883_3ST_6ch_intel_modes,
8522                 .need_dac_fix = 1,
8523                 .input_mux = &alc883_3stack_6ch_intel,
8524         },
8525         [ALC883_6ST_DIG] = {
8526                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8527                 .init_verbs = { alc883_init_verbs },
8528                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8529                 .dac_nids = alc883_dac_nids,
8530                 .dig_out_nid = ALC883_DIGOUT_NID,
8531                 .dig_in_nid = ALC883_DIGIN_NID,
8532                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8533                 .channel_mode = alc883_sixstack_modes,
8534                 .input_mux = &alc883_capture_source,
8535         },
8536         [ALC883_TARGA_DIG] = {
8537                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8538                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8539                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8540                 .dac_nids = alc883_dac_nids,
8541                 .dig_out_nid = ALC883_DIGOUT_NID,
8542                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8543                 .channel_mode = alc883_3ST_6ch_modes,
8544                 .need_dac_fix = 1,
8545                 .input_mux = &alc883_capture_source,
8546                 .unsol_event = alc883_tagra_unsol_event,
8547                 .init_hook = alc883_tagra_automute,
8548         },
8549         [ALC883_TARGA_2ch_DIG] = {
8550                 .mixers = { alc883_tagra_2ch_mixer},
8551                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8552                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8553                 .dac_nids = alc883_dac_nids,
8554                 .dig_out_nid = ALC883_DIGOUT_NID,
8555                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8556                 .channel_mode = alc883_3ST_2ch_modes,
8557                 .input_mux = &alc883_capture_source,
8558                 .unsol_event = alc883_tagra_unsol_event,
8559                 .init_hook = alc883_tagra_automute,
8560         },
8561         [ALC883_ACER] = {
8562                 .mixers = { alc883_base_mixer },
8563                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8564                  * and the headphone jack.  Turn this on and rely on the
8565                  * standard mute methods whenever the user wants to turn
8566                  * these outputs off.
8567                  */
8568                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8569                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8570                 .dac_nids = alc883_dac_nids,
8571                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8572                 .channel_mode = alc883_3ST_2ch_modes,
8573                 .input_mux = &alc883_capture_source,
8574         },
8575         [ALC883_ACER_ASPIRE] = {
8576                 .mixers = { alc883_acer_aspire_mixer },
8577                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8578                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8579                 .dac_nids = alc883_dac_nids,
8580                 .dig_out_nid = ALC883_DIGOUT_NID,
8581                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8582                 .channel_mode = alc883_3ST_2ch_modes,
8583                 .input_mux = &alc883_capture_source,
8584                 .unsol_event = alc883_acer_aspire_unsol_event,
8585                 .init_hook = alc883_acer_aspire_automute,
8586         },
8587         [ALC883_MEDION] = {
8588                 .mixers = { alc883_fivestack_mixer,
8589                             alc883_chmode_mixer },
8590                 .init_verbs = { alc883_init_verbs,
8591                                 alc883_medion_eapd_verbs },
8592                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8593                 .dac_nids = alc883_dac_nids,
8594                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8595                 .channel_mode = alc883_sixstack_modes,
8596                 .input_mux = &alc883_capture_source,
8597         },
8598         [ALC883_MEDION_MD2] = {
8599                 .mixers = { alc883_medion_md2_mixer},
8600                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8601                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8602                 .dac_nids = alc883_dac_nids,
8603                 .dig_out_nid = ALC883_DIGOUT_NID,
8604                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8605                 .channel_mode = alc883_3ST_2ch_modes,
8606                 .input_mux = &alc883_capture_source,
8607                 .unsol_event = alc883_medion_md2_unsol_event,
8608                 .init_hook = alc883_medion_md2_automute,
8609         },
8610         [ALC883_LAPTOP_EAPD] = {
8611                 .mixers = { alc883_base_mixer },
8612                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8613                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8614                 .dac_nids = alc883_dac_nids,
8615                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8616                 .channel_mode = alc883_3ST_2ch_modes,
8617                 .input_mux = &alc883_capture_source,
8618         },
8619         [ALC883_CLEVO_M720] = {
8620                 .mixers = { alc883_clevo_m720_mixer },
8621                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8622                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8623                 .dac_nids = alc883_dac_nids,
8624                 .dig_out_nid = ALC883_DIGOUT_NID,
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_clevo_m720_unsol_event,
8629                 .init_hook = alc883_clevo_m720_automute,
8630         },
8631         [ALC883_LENOVO_101E_2ch] = {
8632                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8633                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8634                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8635                 .dac_nids = alc883_dac_nids,
8636                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8637                 .channel_mode = alc883_3ST_2ch_modes,
8638                 .input_mux = &alc883_lenovo_101e_capture_source,
8639                 .unsol_event = alc883_lenovo_101e_unsol_event,
8640                 .init_hook = alc883_lenovo_101e_all_automute,
8641         },
8642         [ALC883_LENOVO_NB0763] = {
8643                 .mixers = { alc883_lenovo_nb0763_mixer },
8644                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8645                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8646                 .dac_nids = alc883_dac_nids,
8647                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8648                 .channel_mode = alc883_3ST_2ch_modes,
8649                 .need_dac_fix = 1,
8650                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8651                 .unsol_event = alc883_medion_md2_unsol_event,
8652                 .init_hook = alc883_medion_md2_automute,
8653         },
8654         [ALC888_LENOVO_MS7195_DIG] = {
8655                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8656                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8657                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8658                 .dac_nids = alc883_dac_nids,
8659                 .dig_out_nid = ALC883_DIGOUT_NID,
8660                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8661                 .channel_mode = alc883_3ST_6ch_modes,
8662                 .need_dac_fix = 1,
8663                 .input_mux = &alc883_capture_source,
8664                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8665                 .init_hook = alc888_lenovo_ms7195_front_automute,
8666         },
8667         [ALC883_HAIER_W66] = {
8668                 .mixers = { alc883_tagra_2ch_mixer},
8669                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8670                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8671                 .dac_nids = alc883_dac_nids,
8672                 .dig_out_nid = ALC883_DIGOUT_NID,
8673                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8674                 .channel_mode = alc883_3ST_2ch_modes,
8675                 .input_mux = &alc883_capture_source,
8676                 .unsol_event = alc883_haier_w66_unsol_event,
8677                 .init_hook = alc883_haier_w66_automute,
8678         },
8679         [ALC888_3ST_HP] = {
8680                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8681                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8682                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8683                 .dac_nids = alc883_dac_nids,
8684                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8685                 .channel_mode = alc888_3st_hp_modes,
8686                 .need_dac_fix = 1,
8687                 .input_mux = &alc883_capture_source,
8688         },
8689         [ALC888_6ST_DELL] = {
8690                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8691                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8692                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8693                 .dac_nids = alc883_dac_nids,
8694                 .dig_out_nid = ALC883_DIGOUT_NID,
8695                 .dig_in_nid = ALC883_DIGIN_NID,
8696                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8697                 .channel_mode = alc883_sixstack_modes,
8698                 .input_mux = &alc883_capture_source,
8699                 .unsol_event = alc888_6st_dell_unsol_event,
8700                 .init_hook = alc888_6st_dell_front_automute,
8701         },
8702         [ALC883_MITAC] = {
8703                 .mixers = { alc883_mitac_mixer },
8704                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8705                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8706                 .dac_nids = alc883_dac_nids,
8707                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8708                 .channel_mode = alc883_3ST_2ch_modes,
8709                 .input_mux = &alc883_capture_source,
8710                 .unsol_event = alc883_mitac_unsol_event,
8711                 .init_hook = alc883_mitac_automute,
8712         },
8713         [ALC883_FUJITSU_PI2515] = {
8714                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8715                 .init_verbs = { alc883_init_verbs,
8716                                 alc883_2ch_fujitsu_pi2515_verbs},
8717                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8718                 .dac_nids = alc883_dac_nids,
8719                 .dig_out_nid = ALC883_DIGOUT_NID,
8720                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8721                 .channel_mode = alc883_3ST_2ch_modes,
8722                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8723                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8724                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8725         },
8726         [ALC888_LENOVO_SKY] = {
8727                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8728                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8729                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8730                 .dac_nids = alc883_dac_nids,
8731                 .dig_out_nid = ALC883_DIGOUT_NID,
8732                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
8733                 .adc_nids = alc883_adc_nids,
8734                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8735                 .channel_mode = alc883_sixstack_modes,
8736                 .need_dac_fix = 1,
8737                 .input_mux = &alc883_lenovo_sky_capture_source,
8738                 .unsol_event = alc883_lenovo_sky_unsol_event,
8739                 .init_hook = alc888_lenovo_sky_front_automute,
8740         },
8741         [ALC888_ASUS_M90V] = {
8742                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8743                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
8744                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8745                 .dac_nids = alc883_dac_nids,
8746                 .dig_out_nid = ALC883_DIGOUT_NID,
8747                 .dig_in_nid = ALC883_DIGIN_NID,
8748                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8749                 .channel_mode = alc883_3ST_6ch_modes,
8750                 .need_dac_fix = 1,
8751                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8752                 .unsol_event = alc883_mode2_unsol_event,
8753                 .init_hook = alc883_mode2_inithook,
8754         },
8755         [ALC888_ASUS_EEE1601] = {
8756                 .mixers = { alc883_asus_eee1601_mixer },
8757                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
8758                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8759                 .dac_nids = alc883_dac_nids,
8760                 .dig_out_nid = ALC883_DIGOUT_NID,
8761                 .dig_in_nid = ALC883_DIGIN_NID,
8762                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8763                 .channel_mode = alc883_3ST_2ch_modes,
8764                 .need_dac_fix = 1,
8765                 .input_mux = &alc883_asus_eee1601_capture_source,
8766                 .unsol_event = alc883_eee1601_unsol_event,
8767                 .init_hook = alc883_eee1601_inithook,
8768         },
8769 };
8770
8771
8772 /*
8773  * BIOS auto configuration
8774  */
8775 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8776                                               hda_nid_t nid, int pin_type,
8777                                               int dac_idx)
8778 {
8779         /* set as output */
8780         struct alc_spec *spec = codec->spec;
8781         int idx;
8782
8783         alc_set_pin_output(codec, nid, pin_type);
8784         if (spec->multiout.dac_nids[dac_idx] == 0x25)
8785                 idx = 4;
8786         else
8787                 idx = spec->multiout.dac_nids[dac_idx] - 2;
8788         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8789
8790 }
8791
8792 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8793 {
8794         struct alc_spec *spec = codec->spec;
8795         int i;
8796
8797         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8798         for (i = 0; i <= HDA_SIDE; i++) {
8799                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8800                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8801                 if (nid)
8802                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8803                                                           i);
8804         }
8805 }
8806
8807 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8808 {
8809         struct alc_spec *spec = codec->spec;
8810         hda_nid_t pin;
8811
8812         pin = spec->autocfg.hp_pins[0];
8813         if (pin) /* connect to front */
8814                 /* use dac 0 */
8815                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8816         pin = spec->autocfg.speaker_pins[0];
8817         if (pin)
8818                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8819 }
8820
8821 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
8822 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
8823
8824 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8825 {
8826         struct alc_spec *spec = codec->spec;
8827         int i;
8828
8829         for (i = 0; i < AUTO_PIN_LAST; i++) {
8830                 hda_nid_t nid = spec->autocfg.input_pins[i];
8831                 if (alc883_is_input_pin(nid)) {
8832                         snd_hda_codec_write(codec, nid, 0,
8833                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
8834                                             (i <= AUTO_PIN_FRONT_MIC ?
8835                                              PIN_VREF80 : PIN_IN));
8836                         if (nid != ALC883_PIN_CD_NID)
8837                                 snd_hda_codec_write(codec, nid, 0,
8838                                                     AC_VERB_SET_AMP_GAIN_MUTE,
8839                                                     AMP_OUT_MUTE);
8840                 }
8841         }
8842 }
8843
8844 #define alc883_auto_init_input_src      alc882_auto_init_input_src
8845
8846 /* almost identical with ALC880 parser... */
8847 static int alc883_parse_auto_config(struct hda_codec *codec)
8848 {
8849         struct alc_spec *spec = codec->spec;
8850         int err = alc880_parse_auto_config(codec);
8851
8852         if (err < 0)
8853                 return err;
8854         else if (!err)
8855                 return 0; /* no config found */
8856
8857         err = alc_auto_add_mic_boost(codec);
8858         if (err < 0)
8859                 return err;
8860
8861         /* hack - override the init verbs */
8862         spec->init_verbs[0] = alc883_auto_init_verbs;
8863         spec->mixers[spec->num_mixers] = alc883_capture_mixer;
8864         spec->num_mixers++;
8865
8866         return 1; /* config found */
8867 }
8868
8869 /* additional initialization for auto-configuration model */
8870 static void alc883_auto_init(struct hda_codec *codec)
8871 {
8872         struct alc_spec *spec = codec->spec;
8873         alc883_auto_init_multi_out(codec);
8874         alc883_auto_init_hp_out(codec);
8875         alc883_auto_init_analog_input(codec);
8876         alc883_auto_init_input_src(codec);
8877         if (spec->unsol_event)
8878                 alc_inithook(codec);
8879 }
8880
8881 static int patch_alc883(struct hda_codec *codec)
8882 {
8883         struct alc_spec *spec;
8884         int err, board_config;
8885
8886         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
8887         if (spec == NULL)
8888                 return -ENOMEM;
8889
8890         codec->spec = spec;
8891
8892         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
8893
8894         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
8895                                                   alc883_models,
8896                                                   alc883_cfg_tbl);
8897         if (board_config < 0) {
8898                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
8899                        "trying auto-probe from BIOS...\n");
8900                 board_config = ALC883_AUTO;
8901         }
8902
8903         if (board_config == ALC883_AUTO) {
8904                 /* automatic parse from the BIOS config */
8905                 err = alc883_parse_auto_config(codec);
8906                 if (err < 0) {
8907                         alc_free(codec);
8908                         return err;
8909                 } else if (!err) {
8910                         printk(KERN_INFO
8911                                "hda_codec: Cannot set up configuration "
8912                                "from BIOS.  Using base mode...\n");
8913                         board_config = ALC883_3ST_2ch_DIG;
8914                 }
8915         }
8916
8917         if (board_config != ALC883_AUTO)
8918                 setup_preset(spec, &alc883_presets[board_config]);
8919
8920         switch (codec->vendor_id) {
8921         case 0x10ec0888:
8922                 if (codec->revision_id == 0x100101) {
8923                         spec->stream_name_analog = "ALC1200 Analog";
8924                         spec->stream_name_digital = "ALC1200 Digital";
8925                 } else {
8926                         spec->stream_name_analog = "ALC888 Analog";
8927                         spec->stream_name_digital = "ALC888 Digital";
8928                 }
8929                 break;
8930         case 0x10ec0889:
8931                 spec->stream_name_analog = "ALC889 Analog";
8932                 spec->stream_name_digital = "ALC889 Digital";
8933                 break;
8934         default:
8935                 spec->stream_name_analog = "ALC883 Analog";
8936                 spec->stream_name_digital = "ALC883 Digital";
8937                 break;
8938         }
8939
8940         spec->stream_analog_playback = &alc883_pcm_analog_playback;
8941         spec->stream_analog_capture = &alc883_pcm_analog_capture;
8942         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
8943
8944         spec->stream_digital_playback = &alc883_pcm_digital_playback;
8945         spec->stream_digital_capture = &alc883_pcm_digital_capture;
8946
8947         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
8948         spec->adc_nids = alc883_adc_nids;
8949         spec->capsrc_nids = alc883_capsrc_nids;
8950
8951         spec->vmaster_nid = 0x0c;
8952
8953         codec->patch_ops = alc_patch_ops;
8954         if (board_config == ALC883_AUTO)
8955                 spec->init_hook = alc883_auto_init;
8956
8957 #ifdef CONFIG_SND_HDA_POWER_SAVE
8958         if (!spec->loopback.amplist)
8959                 spec->loopback.amplist = alc883_loopbacks;
8960 #endif
8961
8962         return 0;
8963 }
8964
8965 /*
8966  * ALC262 support
8967  */
8968
8969 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
8970 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
8971
8972 #define alc262_dac_nids         alc260_dac_nids
8973 #define alc262_adc_nids         alc882_adc_nids
8974 #define alc262_adc_nids_alt     alc882_adc_nids_alt
8975 #define alc262_capsrc_nids      alc882_capsrc_nids
8976 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
8977
8978 #define alc262_modes            alc260_modes
8979 #define alc262_capture_source   alc882_capture_source
8980
8981 static hda_nid_t alc262_dmic_adc_nids[1] = {
8982         /* ADC0 */
8983         0x09
8984 };
8985
8986 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
8987
8988 static struct snd_kcontrol_new alc262_base_mixer[] = {
8989         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8990         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8991         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8992         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8993         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8994         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8995         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8996         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8997         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8998         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
8999         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9000         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9001         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9002            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
9003         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9004         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9005         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9006         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9007         { } /* end */
9008 };
9009
9010 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9011         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9012         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9013         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9014         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9015         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9016         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9017         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9018         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9019         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9020         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9021         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9022         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9023         /* HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9024            HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT), */
9025         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9026         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9027         { } /* end */
9028 };
9029
9030 /* update HP, line and mono-out pins according to the master switch */
9031 static void alc262_hp_master_update(struct hda_codec *codec)
9032 {
9033         struct alc_spec *spec = codec->spec;
9034         int val = spec->master_sw;
9035
9036         /* HP & line-out */
9037         snd_hda_codec_write_cache(codec, 0x1b, 0,
9038                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9039                                   val ? PIN_HP : 0);
9040         snd_hda_codec_write_cache(codec, 0x15, 0,
9041                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9042                                   val ? PIN_HP : 0);
9043         /* mono (speaker) depending on the HP jack sense */
9044         val = val && !spec->jack_present;
9045         snd_hda_codec_write_cache(codec, 0x16, 0,
9046                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9047                                   val ? PIN_OUT : 0);
9048 }
9049
9050 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9051 {
9052         struct alc_spec *spec = codec->spec;
9053         unsigned int presence;
9054         presence = snd_hda_codec_read(codec, 0x1b, 0,
9055                                       AC_VERB_GET_PIN_SENSE, 0);
9056         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9057         alc262_hp_master_update(codec);
9058 }
9059
9060 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9061 {
9062         if ((res >> 26) != ALC880_HP_EVENT)
9063                 return;
9064         alc262_hp_bpc_automute(codec);
9065 }
9066
9067 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9068 {
9069         struct alc_spec *spec = codec->spec;
9070         unsigned int presence;
9071         presence = snd_hda_codec_read(codec, 0x15, 0,
9072                                       AC_VERB_GET_PIN_SENSE, 0);
9073         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9074         alc262_hp_master_update(codec);
9075 }
9076
9077 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9078                                            unsigned int res)
9079 {
9080         if ((res >> 26) != ALC880_HP_EVENT)
9081                 return;
9082         alc262_hp_wildwest_automute(codec);
9083 }
9084
9085 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9086                                    struct snd_ctl_elem_value *ucontrol)
9087 {
9088         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9089         struct alc_spec *spec = codec->spec;
9090         *ucontrol->value.integer.value = spec->master_sw;
9091         return 0;
9092 }
9093
9094 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9095                                    struct snd_ctl_elem_value *ucontrol)
9096 {
9097         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9098         struct alc_spec *spec = codec->spec;
9099         int val = !!*ucontrol->value.integer.value;
9100
9101         if (val == spec->master_sw)
9102                 return 0;
9103         spec->master_sw = val;
9104         alc262_hp_master_update(codec);
9105         return 1;
9106 }
9107
9108 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9109         {
9110                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9111                 .name = "Master Playback Switch",
9112                 .info = snd_ctl_boolean_mono_info,
9113                 .get = alc262_hp_master_sw_get,
9114                 .put = alc262_hp_master_sw_put,
9115         },
9116         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9117         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9118         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9119         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9120                               HDA_OUTPUT),
9121         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9122                             HDA_OUTPUT),
9123         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9124         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9125         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9126         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9127         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9128         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9129         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9130         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9131         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9132         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9133         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9134         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9135         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9136         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9137         { } /* end */
9138 };
9139
9140 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9141         {
9142                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9143                 .name = "Master Playback Switch",
9144                 .info = snd_ctl_boolean_mono_info,
9145                 .get = alc262_hp_master_sw_get,
9146                 .put = alc262_hp_master_sw_put,
9147         },
9148         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9149         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9150         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9151         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9152         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9153                               HDA_OUTPUT),
9154         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9155                             HDA_OUTPUT),
9156         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9157         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9158         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9159         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9160         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9161         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9162         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9163         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x0b, 0x05, HDA_INPUT),
9164         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x0b, 0x05, HDA_INPUT),
9165         { } /* end */
9166 };
9167
9168 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9169         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9170         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9171         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9172         { } /* end */
9173 };
9174
9175 /* mute/unmute internal speaker according to the hp jack and mute state */
9176 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9177 {
9178         struct alc_spec *spec = codec->spec;
9179
9180         if (force || !spec->sense_updated) {
9181                 unsigned int present;
9182                 present = snd_hda_codec_read(codec, 0x15, 0,
9183                                              AC_VERB_GET_PIN_SENSE, 0);
9184                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9185                 spec->sense_updated = 1;
9186         }
9187         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9188                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9189 }
9190
9191 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9192                                         unsigned int res)
9193 {
9194         if ((res >> 26) != ALC880_HP_EVENT)
9195                 return;
9196         alc262_hp_t5735_automute(codec, 1);
9197 }
9198
9199 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9200 {
9201         alc262_hp_t5735_automute(codec, 1);
9202 }
9203
9204 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9205         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9206         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9207         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9208         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9209         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9210         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9211         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9212         { } /* end */
9213 };
9214
9215 static struct hda_verb alc262_hp_t5735_verbs[] = {
9216         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9217         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9218
9219         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9220         { }
9221 };
9222
9223 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9224         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9225         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9226         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9227         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9228         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9229         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9230         { } /* end */
9231 };
9232
9233 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9234         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9235         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9236         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9237         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9238         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9239         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9240         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9241         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9242         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9243         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9244         {}
9245 };
9246
9247 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9248         .num_items = 1,
9249         .items = {
9250                 { "Line", 0x1 },
9251         },
9252 };
9253
9254 /* bind hp and internal speaker mute (with plug check) */
9255 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9256                                      struct snd_ctl_elem_value *ucontrol)
9257 {
9258         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9259         long *valp = ucontrol->value.integer.value;
9260         int change;
9261
9262         /* change hp mute */
9263         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9264                                           HDA_AMP_MUTE,
9265                                           valp[0] ? 0 : HDA_AMP_MUTE);
9266         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9267                                            HDA_AMP_MUTE,
9268                                            valp[1] ? 0 : HDA_AMP_MUTE);
9269         if (change) {
9270                 /* change speaker according to HP jack state */
9271                 struct alc_spec *spec = codec->spec;
9272                 unsigned int mute;
9273                 if (spec->jack_present)
9274                         mute = HDA_AMP_MUTE;
9275                 else
9276                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9277                                                       HDA_OUTPUT, 0);
9278                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9279                                          HDA_AMP_MUTE, mute);
9280         }
9281         return change;
9282 }
9283
9284 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9285         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9286         {
9287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9288                 .name = "Master Playback Switch",
9289                 .info = snd_hda_mixer_amp_switch_info,
9290                 .get = snd_hda_mixer_amp_switch_get,
9291                 .put = alc262_sony_master_sw_put,
9292                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9293         },
9294         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9295         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9296         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9297         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9298         { } /* end */
9299 };
9300
9301 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9302         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9303         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9304         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9305         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9306         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9307         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9308         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9309         { } /* end */
9310 };
9311
9312 #define alc262_capture_mixer            alc882_capture_mixer
9313 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9314
9315 /*
9316  * generic initialization of ADC, input mixers and output mixers
9317  */
9318 static struct hda_verb alc262_init_verbs[] = {
9319         /*
9320          * Unmute ADC0-2 and set the default input to mic-in
9321          */
9322         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9323         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9324         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9326         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9327         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9328
9329         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9330          * mixer widget
9331          * Note: PASD motherboards uses the Line In 2 as the input for
9332          * front panel mic (mic 2)
9333          */
9334         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9335         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9336         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9337         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9338         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9339         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9340
9341         /*
9342          * Set up output mixers (0x0c - 0x0e)
9343          */
9344         /* set vol=0 to output mixers */
9345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9346         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9348         /* set up input amps for analog loopback */
9349         /* Amp Indices: DAC = 0, mixer = 1 */
9350         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9351         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9352         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9353         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9354         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9355         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9356
9357         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9358         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9359         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9360         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9361         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9362         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9363
9364         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9365         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9366         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9367         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9368         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9369
9370         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9371         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9372
9373         /* FIXME: use matrix-type input source selection */
9374         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9375         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9376         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9377         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9378         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9379         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9380         /* Input mixer2 */
9381         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9382         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9383         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9384         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9385         /* Input mixer3 */
9386         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9387         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9388         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9389         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9390
9391         { }
9392 };
9393
9394 static struct hda_verb alc262_eapd_verbs[] = {
9395         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9396         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9397         { }
9398 };
9399
9400 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9401         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9402         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9403         {}
9404 };
9405
9406 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9407         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9408         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9409         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9410
9411         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9412         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9413         {}
9414 };
9415
9416 static struct hda_verb alc262_sony_unsol_verbs[] = {
9417         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9418         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9419         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9420
9421         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9422         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9423         {}
9424 };
9425
9426 static struct hda_input_mux alc262_dmic_capture_source = {
9427         .num_items = 2,
9428         .items = {
9429                 { "Int DMic", 0x9 },
9430                 { "Mic", 0x0 },
9431         },
9432 };
9433
9434 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9435         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9436         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9437         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9438         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9439         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9440         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
9441         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
9442         {
9443                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9444                 /* The multiple "Capture Source" controls confuse alsamixer
9445                  * So call somewhat different..
9446                  */
9447                 /* .name = "Capture Source", */
9448                 .name = "Input Source",
9449                 .count = 1,
9450                 .info = alc_mux_enum_info,
9451                 .get = alc_mux_enum_get,
9452                 .put = alc_mux_enum_put,
9453         },
9454         { } /* end */
9455 };
9456
9457 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9458         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9459         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9460         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9461         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9462         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9463         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9464         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9465         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9466         {}
9467 };
9468
9469 static void alc262_dmic_automute(struct hda_codec *codec)
9470 {
9471         unsigned int present;
9472
9473         present = snd_hda_codec_read(codec, 0x18, 0,
9474                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9475         snd_hda_codec_write(codec, 0x22, 0,
9476                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9477 }
9478
9479 /* toggle speaker-output according to the hp-jack state */
9480 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9481 {
9482         unsigned int present;
9483         unsigned char bits;
9484
9485         present = snd_hda_codec_read(codec, 0x15, 0,
9486                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9487         bits = present ? 0 : PIN_OUT;
9488         snd_hda_codec_write(codec, 0x14, 0,
9489                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9490 }
9491
9492
9493
9494 /* unsolicited event for HP jack sensing */
9495 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9496                                        unsigned int res)
9497 {
9498         if ((res >> 26) == ALC880_HP_EVENT)
9499                 alc262_toshiba_s06_speaker_automute(codec);
9500         if ((res >> 26) == ALC880_MIC_EVENT)
9501                 alc262_dmic_automute(codec);
9502
9503 }
9504
9505 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9506 {
9507         alc262_toshiba_s06_speaker_automute(codec);
9508         alc262_dmic_automute(codec);
9509 }
9510
9511 /* mute/unmute internal speaker according to the hp jack and mute state */
9512 static void alc262_hippo_automute(struct hda_codec *codec)
9513 {
9514         struct alc_spec *spec = codec->spec;
9515         unsigned int mute;
9516         unsigned int present;
9517
9518         /* need to execute and sync at first */
9519         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9520         present = snd_hda_codec_read(codec, 0x15, 0,
9521                                      AC_VERB_GET_PIN_SENSE, 0);
9522         spec->jack_present = (present & 0x80000000) != 0;
9523         if (spec->jack_present) {
9524                 /* mute internal speaker */
9525                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9526                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9527         } else {
9528                 /* unmute internal speaker if necessary */
9529                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9530                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9531                                          HDA_AMP_MUTE, mute);
9532         }
9533 }
9534
9535 /* unsolicited event for HP jack sensing */
9536 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9537                                        unsigned int res)
9538 {
9539         if ((res >> 26) != ALC880_HP_EVENT)
9540                 return;
9541         alc262_hippo_automute(codec);
9542 }
9543
9544 static void alc262_hippo1_automute(struct hda_codec *codec)
9545 {
9546         unsigned int mute;
9547         unsigned int present;
9548
9549         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9550         present = snd_hda_codec_read(codec, 0x1b, 0,
9551                                      AC_VERB_GET_PIN_SENSE, 0);
9552         present = (present & 0x80000000) != 0;
9553         if (present) {
9554                 /* mute internal speaker */
9555                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9556                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9557         } else {
9558                 /* unmute internal speaker if necessary */
9559                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9560                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9561                                          HDA_AMP_MUTE, mute);
9562         }
9563 }
9564
9565 /* unsolicited event for HP jack sensing */
9566 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9567                                        unsigned int res)
9568 {
9569         if ((res >> 26) != ALC880_HP_EVENT)
9570                 return;
9571         alc262_hippo1_automute(codec);
9572 }
9573
9574 /*
9575  * nec model
9576  *  0x15 = headphone
9577  *  0x16 = internal speaker
9578  *  0x18 = external mic
9579  */
9580
9581 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9582         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9583         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9584
9585         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9586         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9587         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9588
9589         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9590         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9591         { } /* end */
9592 };
9593
9594 static struct hda_verb alc262_nec_verbs[] = {
9595         /* Unmute Speaker */
9596         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9597
9598         /* Headphone */
9599         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9600         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9601
9602         /* External mic to headphone */
9603         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9604         /* External mic to speaker */
9605         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9606         {}
9607 };
9608
9609 /*
9610  * fujitsu model
9611  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
9612  *  0x1b = port replicator headphone out
9613  */
9614
9615 #define ALC_HP_EVENT    0x37
9616
9617 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9618         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9619         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9620         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9621         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9622         {}
9623 };
9624
9625 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9626         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9627         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9628         {}
9629 };
9630
9631 static struct hda_input_mux alc262_fujitsu_capture_source = {
9632         .num_items = 3,
9633         .items = {
9634                 { "Mic", 0x0 },
9635                 { "Int Mic", 0x1 },
9636                 { "CD", 0x4 },
9637         },
9638 };
9639
9640 static struct hda_input_mux alc262_HP_capture_source = {
9641         .num_items = 5,
9642         .items = {
9643                 { "Mic", 0x0 },
9644                 { "Front Mic", 0x1 },
9645                 { "Line", 0x2 },
9646                 { "CD", 0x4 },
9647                 { "AUX IN", 0x6 },
9648         },
9649 };
9650
9651 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9652         .num_items = 4,
9653         .items = {
9654                 { "Mic", 0x0 },
9655                 { "Front Mic", 0x2 },
9656                 { "Line", 0x1 },
9657                 { "CD", 0x4 },
9658         },
9659 };
9660
9661 /* mute/unmute internal speaker according to the hp jacks and mute state */
9662 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9663 {
9664         struct alc_spec *spec = codec->spec;
9665         unsigned int mute;
9666
9667         if (force || !spec->sense_updated) {
9668                 unsigned int present;
9669                 /* need to execute and sync at first */
9670                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9671                 /* check laptop HP jack */
9672                 present = snd_hda_codec_read(codec, 0x14, 0,
9673                                              AC_VERB_GET_PIN_SENSE, 0);
9674                 /* need to execute and sync at first */
9675                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9676                 /* check docking HP jack */
9677                 present |= snd_hda_codec_read(codec, 0x1b, 0,
9678                                               AC_VERB_GET_PIN_SENSE, 0);
9679                 if (present & AC_PINSENSE_PRESENCE)
9680                         spec->jack_present = 1;
9681                 else
9682                         spec->jack_present = 0;
9683                 spec->sense_updated = 1;
9684         }
9685         /* unmute internal speaker only if both HPs are unplugged and
9686          * master switch is on
9687          */
9688         if (spec->jack_present)
9689                 mute = HDA_AMP_MUTE;
9690         else
9691                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9692         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9693                                  HDA_AMP_MUTE, mute);
9694 }
9695
9696 /* unsolicited event for HP jack sensing */
9697 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9698                                        unsigned int res)
9699 {
9700         if ((res >> 26) != ALC_HP_EVENT)
9701                 return;
9702         alc262_fujitsu_automute(codec, 1);
9703 }
9704
9705 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9706 {
9707         alc262_fujitsu_automute(codec, 1);
9708 }
9709
9710 /* bind volumes of both NID 0x0c and 0x0d */
9711 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9712         .ops = &snd_hda_bind_vol,
9713         .values = {
9714                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9715                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9716                 0
9717         },
9718 };
9719
9720 /* mute/unmute internal speaker according to the hp jack and mute state */
9721 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9722 {
9723         struct alc_spec *spec = codec->spec;
9724         unsigned int mute;
9725
9726         if (force || !spec->sense_updated) {
9727                 unsigned int present_int_hp;
9728                 /* need to execute and sync at first */
9729                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9730                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9731                                         AC_VERB_GET_PIN_SENSE, 0);
9732                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9733                 spec->sense_updated = 1;
9734         }
9735         if (spec->jack_present) {
9736                 /* mute internal speaker */
9737                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9738                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9739                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9740                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9741         } else {
9742                 /* unmute internal speaker if necessary */
9743                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9744                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9745                                          HDA_AMP_MUTE, mute);
9746                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9747                                          HDA_AMP_MUTE, mute);
9748         }
9749 }
9750
9751 /* unsolicited event for HP jack sensing */
9752 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9753                                        unsigned int res)
9754 {
9755         if ((res >> 26) != ALC_HP_EVENT)
9756                 return;
9757         alc262_lenovo_3000_automute(codec, 1);
9758 }
9759
9760 /* bind hp and internal speaker mute (with plug check) */
9761 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9762                                          struct snd_ctl_elem_value *ucontrol)
9763 {
9764         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9765         long *valp = ucontrol->value.integer.value;
9766         int change;
9767
9768         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9769                                                  HDA_AMP_MUTE,
9770                                                  valp ? 0 : HDA_AMP_MUTE);
9771         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9772                                                  HDA_AMP_MUTE,
9773                                                  valp ? 0 : HDA_AMP_MUTE);
9774
9775         if (change)
9776                 alc262_fujitsu_automute(codec, 0);
9777         return change;
9778 }
9779
9780 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
9781         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9782         {
9783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9784                 .name = "Master Playback Switch",
9785                 .info = snd_hda_mixer_amp_switch_info,
9786                 .get = snd_hda_mixer_amp_switch_get,
9787                 .put = alc262_fujitsu_master_sw_put,
9788                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
9789         },
9790         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9791         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9792         HDA_CODEC_VOLUME("PC Speaker Volume", 0x0b, 0x05, HDA_INPUT),
9793         HDA_CODEC_MUTE("PC Speaker Switch", 0x0b, 0x05, HDA_INPUT),
9794         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9795         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9796         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9797         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9798         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9799         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9800         { } /* end */
9801 };
9802
9803 /* bind hp and internal speaker mute (with plug check) */
9804 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
9805                                          struct snd_ctl_elem_value *ucontrol)
9806 {
9807         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9808         long *valp = ucontrol->value.integer.value;
9809         int change;
9810
9811         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9812                                                  HDA_AMP_MUTE,
9813                                                  valp ? 0 : HDA_AMP_MUTE);
9814
9815         if (change)
9816                 alc262_lenovo_3000_automute(codec, 0);
9817         return change;
9818 }
9819
9820 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
9821         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9822         {
9823                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9824                 .name = "Master Playback Switch",
9825                 .info = snd_hda_mixer_amp_switch_info,
9826                 .get = snd_hda_mixer_amp_switch_get,
9827                 .put = alc262_lenovo_3000_master_sw_put,
9828                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
9829         },
9830         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9831         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9832         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9833         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9834         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9835         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
9836         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9837         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9838         { } /* end */
9839 };
9840
9841 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
9842         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
9843         {
9844                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9845                 .name = "Master Playback Switch",
9846                 .info = snd_hda_mixer_amp_switch_info,
9847                 .get = snd_hda_mixer_amp_switch_get,
9848                 .put = alc262_sony_master_sw_put,
9849                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9850         },
9851         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9852         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9853         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9854         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9855         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9856         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9857         { } /* end */
9858 };
9859
9860 /* additional init verbs for Benq laptops */
9861 static struct hda_verb alc262_EAPD_verbs[] = {
9862         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9863         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
9864         {}
9865 };
9866
9867 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
9868         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9869         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9870
9871         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9872         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
9873         {}
9874 };
9875
9876 /* Samsung Q1 Ultra Vista model setup */
9877 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
9878         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9879         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9880         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9881         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9882         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9883         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
9884         { } /* end */
9885 };
9886
9887 static struct hda_verb alc262_ultra_verbs[] = {
9888         /* output mixer */
9889         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9890         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9891         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9892         /* speaker */
9893         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9894         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9895         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9896         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9897         /* HP */
9898         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9899         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
9900         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9901         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9902         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9903         /* internal mic */
9904         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
9905         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9906         /* ADC, choose mic */
9907         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9908         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9909         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9910         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9911         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9912         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9913         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
9914         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
9915         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
9916         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
9917         {}
9918 };
9919
9920 /* mute/unmute internal speaker according to the hp jack and mute state */
9921 static void alc262_ultra_automute(struct hda_codec *codec)
9922 {
9923         struct alc_spec *spec = codec->spec;
9924         unsigned int mute;
9925
9926         mute = 0;
9927         /* auto-mute only when HP is used as HP */
9928         if (!spec->cur_mux[0]) {
9929                 unsigned int present;
9930                 /* need to execute and sync at first */
9931                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9932                 present = snd_hda_codec_read(codec, 0x15, 0,
9933                                              AC_VERB_GET_PIN_SENSE, 0);
9934                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9935                 if (spec->jack_present)
9936                         mute = HDA_AMP_MUTE;
9937         }
9938         /* mute/unmute internal speaker */
9939         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9940                                  HDA_AMP_MUTE, mute);
9941         /* mute/unmute HP */
9942         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9943                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
9944 }
9945
9946 /* unsolicited event for HP jack sensing */
9947 static void alc262_ultra_unsol_event(struct hda_codec *codec,
9948                                        unsigned int res)
9949 {
9950         if ((res >> 26) != ALC880_HP_EVENT)
9951                 return;
9952         alc262_ultra_automute(codec);
9953 }
9954
9955 static struct hda_input_mux alc262_ultra_capture_source = {
9956         .num_items = 2,
9957         .items = {
9958                 { "Mic", 0x1 },
9959                 { "Headphone", 0x7 },
9960         },
9961 };
9962
9963 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
9964                                      struct snd_ctl_elem_value *ucontrol)
9965 {
9966         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9967         struct alc_spec *spec = codec->spec;
9968         int ret;
9969
9970         ret = alc882_mux_enum_put(kcontrol, ucontrol);
9971         if (!ret)
9972                 return 0;
9973         /* reprogram the HP pin as mic or HP according to the input source */
9974         snd_hda_codec_write_cache(codec, 0x15, 0,
9975                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9976                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
9977         alc262_ultra_automute(codec); /* mute/unmute HP */
9978         return ret;
9979 }
9980
9981 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
9982         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
9983         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
9984         {
9985                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9986                 .name = "Capture Source",
9987                 .info = alc882_mux_enum_info,
9988                 .get = alc882_mux_enum_get,
9989                 .put = alc262_ultra_mux_enum_put,
9990         },
9991         { } /* end */
9992 };
9993
9994 /* add playback controls from the parsed DAC table */
9995 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
9996                                              const struct auto_pin_cfg *cfg)
9997 {
9998         hda_nid_t nid;
9999         int err;
10000
10001         spec->multiout.num_dacs = 1;    /* only use one dac */
10002         spec->multiout.dac_nids = spec->private_dac_nids;
10003         spec->multiout.dac_nids[0] = 2;
10004
10005         nid = cfg->line_out_pins[0];
10006         if (nid) {
10007                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10008                                   "Front Playback Volume",
10009                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10010                 if (err < 0)
10011                         return err;
10012                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10013                                   "Front Playback Switch",
10014                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10015                 if (err < 0)
10016                         return err;
10017         }
10018
10019         nid = cfg->speaker_pins[0];
10020         if (nid) {
10021                 if (nid == 0x16) {
10022                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10023                                           "Speaker Playback Volume",
10024                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10025                                                               HDA_OUTPUT));
10026                         if (err < 0)
10027                                 return err;
10028                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10029                                           "Speaker Playback Switch",
10030                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10031                                                               HDA_OUTPUT));
10032                         if (err < 0)
10033                                 return err;
10034                 } else {
10035                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10036                                           "Speaker Playback Switch",
10037                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10038                                                               HDA_OUTPUT));
10039                         if (err < 0)
10040                                 return err;
10041                 }
10042         }
10043         nid = cfg->hp_pins[0];
10044         if (nid) {
10045                 /* spec->multiout.hp_nid = 2; */
10046                 if (nid == 0x16) {
10047                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10048                                           "Headphone Playback Volume",
10049                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10050                                                               HDA_OUTPUT));
10051                         if (err < 0)
10052                                 return err;
10053                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10054                                           "Headphone Playback Switch",
10055                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10056                                                               HDA_OUTPUT));
10057                         if (err < 0)
10058                                 return err;
10059                 } else {
10060                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10061                                           "Headphone Playback Switch",
10062                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10063                                                               HDA_OUTPUT));
10064                         if (err < 0)
10065                                 return err;
10066                 }
10067         }
10068         return 0;
10069 }
10070
10071 /* identical with ALC880 */
10072 #define alc262_auto_create_analog_input_ctls \
10073         alc880_auto_create_analog_input_ctls
10074
10075 /*
10076  * generic initialization of ADC, input mixers and output mixers
10077  */
10078 static struct hda_verb alc262_volume_init_verbs[] = {
10079         /*
10080          * Unmute ADC0-2 and set the default input to mic-in
10081          */
10082         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10083         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10084         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10085         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10086         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10087         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10088
10089         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10090          * mixer widget
10091          * Note: PASD motherboards uses the Line In 2 as the input for
10092          * front panel mic (mic 2)
10093          */
10094         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10095         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10096         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10097         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10098         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10099         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10100
10101         /*
10102          * Set up output mixers (0x0c - 0x0f)
10103          */
10104         /* set vol=0 to output mixers */
10105         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10106         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10107         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10108
10109         /* set up input amps for analog loopback */
10110         /* Amp Indices: DAC = 0, mixer = 1 */
10111         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10112         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10113         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10114         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10115         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10116         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10117
10118         /* FIXME: use matrix-type input source selection */
10119         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10120         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10121         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10122         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10123         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10124         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10125         /* Input mixer2 */
10126         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10127         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10128         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10129         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10130         /* Input mixer3 */
10131         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10132         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10133         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10134         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10135
10136         { }
10137 };
10138
10139 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10140         /*
10141          * Unmute ADC0-2 and set the default input to mic-in
10142          */
10143         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10144         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10145         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10147         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10148         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10149
10150         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10151          * mixer widget
10152          * Note: PASD motherboards uses the Line In 2 as the input for
10153          * front panel mic (mic 2)
10154          */
10155         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10156         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10157         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10158         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10159         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10160         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10161         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10162         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10163
10164         /*
10165          * Set up output mixers (0x0c - 0x0e)
10166          */
10167         /* set vol=0 to output mixers */
10168         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10169         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10170         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10171
10172         /* set up input amps for analog loopback */
10173         /* Amp Indices: DAC = 0, mixer = 1 */
10174         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10175         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10176         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10177         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10178         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10179         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10180
10181         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10182         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10183         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10184
10185         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10186         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10187
10188         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10189         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10190
10191         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10192         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10193         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10194         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10195         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10196
10197         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10198         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10199         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10200         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10201         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10202         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10203
10204
10205         /* FIXME: use matrix-type input source selection */
10206         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10207         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10208         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10210         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10212         /* Input mixer2 */
10213         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10214         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10215         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10216         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10217         /* Input mixer3 */
10218         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10219         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10220         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10221         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10222
10223         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10224
10225         { }
10226 };
10227
10228 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10229         /*
10230          * Unmute ADC0-2 and set the default input to mic-in
10231          */
10232         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10233         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10234         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10235         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10236         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10237         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10238
10239         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10240          * mixer widget
10241          * Note: PASD motherboards uses the Line In 2 as the input for front
10242          * panel mic (mic 2)
10243          */
10244         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10245         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10246         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10247         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10248         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10249         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10250         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10251         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10252         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10253         /*
10254          * Set up output mixers (0x0c - 0x0e)
10255          */
10256         /* set vol=0 to output mixers */
10257         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10258         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10259         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10260
10261         /* set up input amps for analog loopback */
10262         /* Amp Indices: DAC = 0, mixer = 1 */
10263         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10264         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10265         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10266         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10267         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10268         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10269
10270
10271         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10272         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10273         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10274         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10275         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10276         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10277         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10278
10279         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10280         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10281
10282         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10283         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10284
10285         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10286         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10287         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10288         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10289         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10290         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10291
10292         /* FIXME: use matrix-type input source selection */
10293         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10294         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10295         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10296         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10297         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10298         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10299         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10300         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10301         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10302         /* Input mixer2 */
10303         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10304         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10305         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10306         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10307         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10308         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10309         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10310         /* Input mixer3 */
10311         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10312         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10313         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10314         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10315         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10316         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10317         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10318
10319         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10320
10321         { }
10322 };
10323
10324 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10325
10326         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10327         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10328         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10329
10330         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10331         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10332         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10333         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10334
10335         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10336         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10337         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10338         {}
10339 };
10340
10341
10342 #ifdef CONFIG_SND_HDA_POWER_SAVE
10343 #define alc262_loopbacks        alc880_loopbacks
10344 #endif
10345
10346 /* pcm configuration: identiacal with ALC880 */
10347 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10348 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10349 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10350 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10351
10352 /*
10353  * BIOS auto configuration
10354  */
10355 static int alc262_parse_auto_config(struct hda_codec *codec)
10356 {
10357         struct alc_spec *spec = codec->spec;
10358         int err;
10359         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10360
10361         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10362                                            alc262_ignore);
10363         if (err < 0)
10364                 return err;
10365         if (!spec->autocfg.line_outs)
10366                 return 0; /* can't find valid BIOS pin config */
10367         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10368         if (err < 0)
10369                 return err;
10370         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10371         if (err < 0)
10372                 return err;
10373
10374         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10375
10376         if (spec->autocfg.dig_out_pin)
10377                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10378         if (spec->autocfg.dig_in_pin)
10379                 spec->dig_in_nid = ALC262_DIGIN_NID;
10380
10381         if (spec->kctl_alloc)
10382                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
10383
10384         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
10385         spec->num_mux_defs = 1;
10386         spec->input_mux = &spec->private_imux;
10387
10388         err = alc_auto_add_mic_boost(codec);
10389         if (err < 0)
10390                 return err;
10391
10392         store_pin_configs(codec);
10393         return 1;
10394 }
10395
10396 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10397 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10398 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10399 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10400
10401
10402 /* init callback for auto-configuration model -- overriding the default init */
10403 static void alc262_auto_init(struct hda_codec *codec)
10404 {
10405         struct alc_spec *spec = codec->spec;
10406         alc262_auto_init_multi_out(codec);
10407         alc262_auto_init_hp_out(codec);
10408         alc262_auto_init_analog_input(codec);
10409         alc262_auto_init_input_src(codec);
10410         if (spec->unsol_event)
10411                 alc_inithook(codec);
10412 }
10413
10414 /*
10415  * configuration and preset
10416  */
10417 static const char *alc262_models[ALC262_MODEL_LAST] = {
10418         [ALC262_BASIC]          = "basic",
10419         [ALC262_HIPPO]          = "hippo",
10420         [ALC262_HIPPO_1]        = "hippo_1",
10421         [ALC262_FUJITSU]        = "fujitsu",
10422         [ALC262_HP_BPC]         = "hp-bpc",
10423         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10424         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10425         [ALC262_HP_RP5700]      = "hp-rp5700",
10426         [ALC262_BENQ_ED8]       = "benq",
10427         [ALC262_BENQ_T31]       = "benq-t31",
10428         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10429         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10430         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10431         [ALC262_ULTRA]          = "ultra",
10432         [ALC262_LENOVO_3000]    = "lenovo-3000",
10433         [ALC262_NEC]            = "nec",
10434         [ALC262_AUTO]           = "auto",
10435 };
10436
10437 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10438         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10439         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10440         SND_PCI_QUIRK(0x103c, 0x12fe, "HP xw9400", ALC262_HP_BPC),
10441         SND_PCI_QUIRK(0x103c, 0x12ff, "HP xw4550", ALC262_HP_BPC),
10442         SND_PCI_QUIRK(0x103c, 0x1306, "HP xw8600", ALC262_HP_BPC),
10443         SND_PCI_QUIRK(0x103c, 0x1307, "HP xw6600", ALC262_HP_BPC),
10444         SND_PCI_QUIRK(0x103c, 0x1308, "HP xw4600", ALC262_HP_BPC),
10445         SND_PCI_QUIRK(0x103c, 0x1309, "HP xw4*00", ALC262_HP_BPC),
10446         SND_PCI_QUIRK(0x103c, 0x130a, "HP xw6*00", ALC262_HP_BPC),
10447         SND_PCI_QUIRK(0x103c, 0x130b, "HP xw8*00", ALC262_HP_BPC),
10448         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10449         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10450         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10451         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10452         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10453         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10454         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10455         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10456         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10457         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10458         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10459         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10460                       ALC262_HP_TC_T5735),
10461         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10462         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10463         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10464         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10465         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10466         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10467         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10468                       ALC262_TOSHIBA_RX1),
10469         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10470         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10471         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10472         SND_PCI_QUIRK(0x144d, 0xc032, "Samsung Q1 Ultra", ALC262_ULTRA),
10473         SND_PCI_QUIRK(0x144d, 0xc039, "Samsung Q1U EL", ALC262_ULTRA),
10474         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10475         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10476         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10477         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10478         {}
10479 };
10480
10481 static struct alc_config_preset alc262_presets[] = {
10482         [ALC262_BASIC] = {
10483                 .mixers = { alc262_base_mixer },
10484                 .init_verbs = { alc262_init_verbs },
10485                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10486                 .dac_nids = alc262_dac_nids,
10487                 .hp_nid = 0x03,
10488                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10489                 .channel_mode = alc262_modes,
10490                 .input_mux = &alc262_capture_source,
10491         },
10492         [ALC262_HIPPO] = {
10493                 .mixers = { alc262_base_mixer },
10494                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10495                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10496                 .dac_nids = alc262_dac_nids,
10497                 .hp_nid = 0x03,
10498                 .dig_out_nid = ALC262_DIGOUT_NID,
10499                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10500                 .channel_mode = alc262_modes,
10501                 .input_mux = &alc262_capture_source,
10502                 .unsol_event = alc262_hippo_unsol_event,
10503                 .init_hook = alc262_hippo_automute,
10504         },
10505         [ALC262_HIPPO_1] = {
10506                 .mixers = { alc262_hippo1_mixer },
10507                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10508                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10509                 .dac_nids = alc262_dac_nids,
10510                 .hp_nid = 0x02,
10511                 .dig_out_nid = ALC262_DIGOUT_NID,
10512                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10513                 .channel_mode = alc262_modes,
10514                 .input_mux = &alc262_capture_source,
10515                 .unsol_event = alc262_hippo1_unsol_event,
10516                 .init_hook = alc262_hippo1_automute,
10517         },
10518         [ALC262_FUJITSU] = {
10519                 .mixers = { alc262_fujitsu_mixer },
10520                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10521                                 alc262_fujitsu_unsol_verbs },
10522                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10523                 .dac_nids = alc262_dac_nids,
10524                 .hp_nid = 0x03,
10525                 .dig_out_nid = ALC262_DIGOUT_NID,
10526                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10527                 .channel_mode = alc262_modes,
10528                 .input_mux = &alc262_fujitsu_capture_source,
10529                 .unsol_event = alc262_fujitsu_unsol_event,
10530                 .init_hook = alc262_fujitsu_init_hook,
10531         },
10532         [ALC262_HP_BPC] = {
10533                 .mixers = { alc262_HP_BPC_mixer },
10534                 .init_verbs = { alc262_HP_BPC_init_verbs },
10535                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10536                 .dac_nids = alc262_dac_nids,
10537                 .hp_nid = 0x03,
10538                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10539                 .channel_mode = alc262_modes,
10540                 .input_mux = &alc262_HP_capture_source,
10541                 .unsol_event = alc262_hp_bpc_unsol_event,
10542                 .init_hook = alc262_hp_bpc_automute,
10543         },
10544         [ALC262_HP_BPC_D7000_WF] = {
10545                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10546                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10547                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10548                 .dac_nids = alc262_dac_nids,
10549                 .hp_nid = 0x03,
10550                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10551                 .channel_mode = alc262_modes,
10552                 .input_mux = &alc262_HP_D7000_capture_source,
10553                 .unsol_event = alc262_hp_wildwest_unsol_event,
10554                 .init_hook = alc262_hp_wildwest_automute,
10555         },
10556         [ALC262_HP_BPC_D7000_WL] = {
10557                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10558                             alc262_HP_BPC_WildWest_option_mixer },
10559                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10560                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10561                 .dac_nids = alc262_dac_nids,
10562                 .hp_nid = 0x03,
10563                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10564                 .channel_mode = alc262_modes,
10565                 .input_mux = &alc262_HP_D7000_capture_source,
10566                 .unsol_event = alc262_hp_wildwest_unsol_event,
10567                 .init_hook = alc262_hp_wildwest_automute,
10568         },
10569         [ALC262_HP_TC_T5735] = {
10570                 .mixers = { alc262_hp_t5735_mixer },
10571                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10572                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10573                 .dac_nids = alc262_dac_nids,
10574                 .hp_nid = 0x03,
10575                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10576                 .channel_mode = alc262_modes,
10577                 .input_mux = &alc262_capture_source,
10578                 .unsol_event = alc262_hp_t5735_unsol_event,
10579                 .init_hook = alc262_hp_t5735_init_hook,
10580         },
10581         [ALC262_HP_RP5700] = {
10582                 .mixers = { alc262_hp_rp5700_mixer },
10583                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10584                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10585                 .dac_nids = alc262_dac_nids,
10586                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10587                 .channel_mode = alc262_modes,
10588                 .input_mux = &alc262_hp_rp5700_capture_source,
10589         },
10590         [ALC262_BENQ_ED8] = {
10591                 .mixers = { alc262_base_mixer },
10592                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10593                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10594                 .dac_nids = alc262_dac_nids,
10595                 .hp_nid = 0x03,
10596                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10597                 .channel_mode = alc262_modes,
10598                 .input_mux = &alc262_capture_source,
10599         },
10600         [ALC262_SONY_ASSAMD] = {
10601                 .mixers = { alc262_sony_mixer },
10602                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10603                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10604                 .dac_nids = alc262_dac_nids,
10605                 .hp_nid = 0x02,
10606                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10607                 .channel_mode = alc262_modes,
10608                 .input_mux = &alc262_capture_source,
10609                 .unsol_event = alc262_hippo_unsol_event,
10610                 .init_hook = alc262_hippo_automute,
10611         },
10612         [ALC262_BENQ_T31] = {
10613                 .mixers = { alc262_benq_t31_mixer },
10614                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10615                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10616                 .dac_nids = alc262_dac_nids,
10617                 .hp_nid = 0x03,
10618                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10619                 .channel_mode = alc262_modes,
10620                 .input_mux = &alc262_capture_source,
10621                 .unsol_event = alc262_hippo_unsol_event,
10622                 .init_hook = alc262_hippo_automute,
10623         },
10624         [ALC262_ULTRA] = {
10625                 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
10626                 .init_verbs = { alc262_ultra_verbs },
10627                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10628                 .dac_nids = alc262_dac_nids,
10629                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10630                 .channel_mode = alc262_modes,
10631                 .input_mux = &alc262_ultra_capture_source,
10632                 .adc_nids = alc262_adc_nids, /* ADC0 */
10633                 .capsrc_nids = alc262_capsrc_nids,
10634                 .num_adc_nids = 1, /* single ADC */
10635                 .unsol_event = alc262_ultra_unsol_event,
10636                 .init_hook = alc262_ultra_automute,
10637         },
10638         [ALC262_LENOVO_3000] = {
10639                 .mixers = { alc262_lenovo_3000_mixer },
10640                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10641                                 alc262_lenovo_3000_unsol_verbs },
10642                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10643                 .dac_nids = alc262_dac_nids,
10644                 .hp_nid = 0x03,
10645                 .dig_out_nid = ALC262_DIGOUT_NID,
10646                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10647                 .channel_mode = alc262_modes,
10648                 .input_mux = &alc262_fujitsu_capture_source,
10649                 .unsol_event = alc262_lenovo_3000_unsol_event,
10650         },
10651         [ALC262_NEC] = {
10652                 .mixers = { alc262_nec_mixer },
10653                 .init_verbs = { alc262_nec_verbs },
10654                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10655                 .dac_nids = alc262_dac_nids,
10656                 .hp_nid = 0x03,
10657                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10658                 .channel_mode = alc262_modes,
10659                 .input_mux = &alc262_capture_source,
10660         },
10661         [ALC262_TOSHIBA_S06] = {
10662                 .mixers = { alc262_toshiba_s06_mixer },
10663                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10664                                                         alc262_eapd_verbs },
10665                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10666                 .capsrc_nids = alc262_dmic_capsrc_nids,
10667                 .dac_nids = alc262_dac_nids,
10668                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10669                 .dig_out_nid = ALC262_DIGOUT_NID,
10670                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10671                 .channel_mode = alc262_modes,
10672                 .input_mux = &alc262_dmic_capture_source,
10673                 .unsol_event = alc262_toshiba_s06_unsol_event,
10674                 .init_hook = alc262_toshiba_s06_init_hook,
10675         },
10676         [ALC262_TOSHIBA_RX1] = {
10677                 .mixers = { alc262_toshiba_rx1_mixer },
10678                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10679                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10680                 .dac_nids = alc262_dac_nids,
10681                 .hp_nid = 0x03,
10682                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10683                 .channel_mode = alc262_modes,
10684                 .input_mux = &alc262_capture_source,
10685                 .unsol_event = alc262_hippo_unsol_event,
10686                 .init_hook = alc262_hippo_automute,
10687         },
10688 };
10689
10690 static int patch_alc262(struct hda_codec *codec)
10691 {
10692         struct alc_spec *spec;
10693         int board_config;
10694         int err;
10695
10696         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10697         if (spec == NULL)
10698                 return -ENOMEM;
10699
10700         codec->spec = spec;
10701 #if 0
10702         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
10703          * under-run
10704          */
10705         {
10706         int tmp;
10707         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10708         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
10709         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10710         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
10711         }
10712 #endif
10713
10714         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10715
10716         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
10717                                                   alc262_models,
10718                                                   alc262_cfg_tbl);
10719
10720         if (board_config < 0) {
10721                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
10722                        "trying auto-probe from BIOS...\n");
10723                 board_config = ALC262_AUTO;
10724         }
10725
10726         if (board_config == ALC262_AUTO) {
10727                 /* automatic parse from the BIOS config */
10728                 err = alc262_parse_auto_config(codec);
10729                 if (err < 0) {
10730                         alc_free(codec);
10731                         return err;
10732                 } else if (!err) {
10733                         printk(KERN_INFO
10734                                "hda_codec: Cannot set up configuration "
10735                                "from BIOS.  Using base mode...\n");
10736                         board_config = ALC262_BASIC;
10737                 }
10738         }
10739
10740         if (board_config != ALC262_AUTO)
10741                 setup_preset(spec, &alc262_presets[board_config]);
10742
10743         spec->stream_name_analog = "ALC262 Analog";
10744         spec->stream_analog_playback = &alc262_pcm_analog_playback;
10745         spec->stream_analog_capture = &alc262_pcm_analog_capture;
10746
10747         spec->stream_name_digital = "ALC262 Digital";
10748         spec->stream_digital_playback = &alc262_pcm_digital_playback;
10749         spec->stream_digital_capture = &alc262_pcm_digital_capture;
10750
10751         if (!spec->adc_nids && spec->input_mux) {
10752                 /* check whether NID 0x07 is valid */
10753                 unsigned int wcap = get_wcaps(codec, 0x07);
10754
10755                 /* get type */
10756                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
10757                 if (wcap != AC_WID_AUD_IN) {
10758                         spec->adc_nids = alc262_adc_nids_alt;
10759                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
10760                         spec->capsrc_nids = alc262_capsrc_nids_alt;
10761                         spec->mixers[spec->num_mixers] =
10762                                 alc262_capture_alt_mixer;
10763                         spec->num_mixers++;
10764                 } else {
10765                         spec->adc_nids = alc262_adc_nids;
10766                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
10767                         spec->capsrc_nids = alc262_capsrc_nids;
10768                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
10769                         spec->num_mixers++;
10770                 }
10771         }
10772
10773         spec->vmaster_nid = 0x0c;
10774
10775         codec->patch_ops = alc_patch_ops;
10776         if (board_config == ALC262_AUTO)
10777                 spec->init_hook = alc262_auto_init;
10778 #ifdef CONFIG_SND_HDA_POWER_SAVE
10779         if (!spec->loopback.amplist)
10780                 spec->loopback.amplist = alc262_loopbacks;
10781 #endif
10782
10783         return 0;
10784 }
10785
10786 /*
10787  *  ALC268 channel source setting (2 channel)
10788  */
10789 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
10790 #define alc268_modes            alc260_modes
10791
10792 static hda_nid_t alc268_dac_nids[2] = {
10793         /* front, hp */
10794         0x02, 0x03
10795 };
10796
10797 static hda_nid_t alc268_adc_nids[2] = {
10798         /* ADC0-1 */
10799         0x08, 0x07
10800 };
10801
10802 static hda_nid_t alc268_adc_nids_alt[1] = {
10803         /* ADC0 */
10804         0x08
10805 };
10806
10807 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
10808
10809 static struct snd_kcontrol_new alc268_base_mixer[] = {
10810         /* output mixer control */
10811         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
10812         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10813         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
10814         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10815         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10816         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10817         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10818         { }
10819 };
10820
10821 /* bind Beep switches of both NID 0x0f and 0x10 */
10822 static struct hda_bind_ctls alc268_bind_beep_sw = {
10823         .ops = &snd_hda_bind_sw,
10824         .values = {
10825                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
10826                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
10827                 0
10828         },
10829 };
10830
10831 static struct snd_kcontrol_new alc268_beep_mixer[] = {
10832         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
10833         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
10834         { }
10835 };
10836
10837 static struct hda_verb alc268_eapd_verbs[] = {
10838         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10839         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10840         { }
10841 };
10842
10843 /* Toshiba specific */
10844 #define alc268_toshiba_automute alc262_hippo_automute
10845
10846 static struct hda_verb alc268_toshiba_verbs[] = {
10847         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10848         { } /* end */
10849 };
10850
10851 static struct hda_input_mux alc268_acer_lc_capture_source = {
10852         .num_items = 2,
10853         .items = {
10854                 { "i-Mic", 0x6 },
10855                 { "E-Mic", 0x0 },
10856         },
10857 };
10858
10859 /* Acer specific */
10860 /* bind volumes of both NID 0x02 and 0x03 */
10861 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
10862         .ops = &snd_hda_bind_vol,
10863         .values = {
10864                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
10865                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
10866                 0
10867         },
10868 };
10869
10870 /* mute/unmute internal speaker according to the hp jack and mute state */
10871 static void alc268_acer_automute(struct hda_codec *codec, int force)
10872 {
10873         struct alc_spec *spec = codec->spec;
10874         unsigned int mute;
10875
10876         if (force || !spec->sense_updated) {
10877                 unsigned int present;
10878                 present = snd_hda_codec_read(codec, 0x14, 0,
10879                                          AC_VERB_GET_PIN_SENSE, 0);
10880                 spec->jack_present = (present & 0x80000000) != 0;
10881                 spec->sense_updated = 1;
10882         }
10883         if (spec->jack_present)
10884                 mute = HDA_AMP_MUTE; /* mute internal speaker */
10885         else /* unmute internal speaker if necessary */
10886                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10887         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10888                                  HDA_AMP_MUTE, mute);
10889 }
10890
10891
10892 /* bind hp and internal speaker mute (with plug check) */
10893 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
10894                                      struct snd_ctl_elem_value *ucontrol)
10895 {
10896         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10897         long *valp = ucontrol->value.integer.value;
10898         int change;
10899
10900         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
10901                                           HDA_AMP_MUTE,
10902                                           valp[0] ? 0 : HDA_AMP_MUTE);
10903         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
10904                                            HDA_AMP_MUTE,
10905                                            valp[1] ? 0 : HDA_AMP_MUTE);
10906         if (change)
10907                 alc268_acer_automute(codec, 0);
10908         return change;
10909 }
10910
10911 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
10912         /* output mixer control */
10913         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10914         {
10915                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10916                 .name = "Master Playback Switch",
10917                 .info = snd_hda_mixer_amp_switch_info,
10918                 .get = snd_hda_mixer_amp_switch_get,
10919                 .put = alc268_acer_master_sw_put,
10920                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10921         },
10922         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
10923         { }
10924 };
10925
10926 static struct snd_kcontrol_new alc268_acer_mixer[] = {
10927         /* output mixer control */
10928         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
10929         {
10930                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10931                 .name = "Master Playback Switch",
10932                 .info = snd_hda_mixer_amp_switch_info,
10933                 .get = snd_hda_mixer_amp_switch_get,
10934                 .put = alc268_acer_master_sw_put,
10935                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10936         },
10937         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10938         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
10939         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
10940         { }
10941 };
10942
10943 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
10944         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10945         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10946         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10947         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10948         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
10949         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
10950         { }
10951 };
10952
10953 static struct hda_verb alc268_acer_verbs[] = {
10954         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
10955         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10956         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10957         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10958         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10959         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10960         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10961         { }
10962 };
10963
10964 /* unsolicited event for HP jack sensing */
10965 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
10966                                        unsigned int res)
10967 {
10968         if ((res >> 26) != ALC880_HP_EVENT)
10969                 return;
10970         alc268_toshiba_automute(codec);
10971 }
10972
10973 static void alc268_acer_unsol_event(struct hda_codec *codec,
10974                                        unsigned int res)
10975 {
10976         if ((res >> 26) != ALC880_HP_EVENT)
10977                 return;
10978         alc268_acer_automute(codec, 1);
10979 }
10980
10981 static void alc268_acer_init_hook(struct hda_codec *codec)
10982 {
10983         alc268_acer_automute(codec, 1);
10984 }
10985
10986 /* toggle speaker-output according to the hp-jack state */
10987 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
10988 {
10989         unsigned int present;
10990         unsigned char bits;
10991
10992         present = snd_hda_codec_read(codec, 0x15, 0,
10993                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10994         bits = present ? AMP_IN_MUTE(0) : 0;
10995         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
10996                                 AMP_IN_MUTE(0), bits);
10997         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
10998                                 AMP_IN_MUTE(0), bits);
10999 }
11000
11001
11002 static void alc268_acer_mic_automute(struct hda_codec *codec)
11003 {
11004         unsigned int present;
11005
11006         present = snd_hda_codec_read(codec, 0x18, 0,
11007                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11008         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11009                             present ? 0x0 : 0x6);
11010 }
11011
11012 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11013                                     unsigned int res)
11014 {
11015         if ((res >> 26) == ALC880_HP_EVENT)
11016                 alc268_aspire_one_speaker_automute(codec);
11017         if ((res >> 26) == ALC880_MIC_EVENT)
11018                 alc268_acer_mic_automute(codec);
11019 }
11020
11021 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11022 {
11023         alc268_aspire_one_speaker_automute(codec);
11024         alc268_acer_mic_automute(codec);
11025 }
11026
11027 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11028         /* output mixer control */
11029         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11030         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11031         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11032         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11033         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11034         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11035         { }
11036 };
11037
11038 static struct hda_verb alc268_dell_verbs[] = {
11039         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11040         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11041         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11042         { }
11043 };
11044
11045 /* mute/unmute internal speaker according to the hp jack and mute state */
11046 static void alc268_dell_automute(struct hda_codec *codec)
11047 {
11048         unsigned int present;
11049         unsigned int mute;
11050
11051         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11052         if (present & 0x80000000)
11053                 mute = HDA_AMP_MUTE;
11054         else
11055                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11056         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11057                                  HDA_AMP_MUTE, mute);
11058 }
11059
11060 static void alc268_dell_unsol_event(struct hda_codec *codec,
11061                                     unsigned int res)
11062 {
11063         if ((res >> 26) != ALC880_HP_EVENT)
11064                 return;
11065         alc268_dell_automute(codec);
11066 }
11067
11068 #define alc268_dell_init_hook   alc268_dell_automute
11069
11070 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11071         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11072         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11073         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11074         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11075         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11076         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11077         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11078         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11079         { }
11080 };
11081
11082 static struct hda_verb alc267_quanta_il1_verbs[] = {
11083         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11084         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11085         { }
11086 };
11087
11088 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11089 {
11090         unsigned int present;
11091
11092         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11093                 & AC_PINSENSE_PRESENCE;
11094         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11095                             present ? 0 : PIN_OUT);
11096 }
11097
11098 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11099 {
11100         unsigned int present;
11101
11102         present = snd_hda_codec_read(codec, 0x18, 0,
11103                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11104         snd_hda_codec_write(codec, 0x23, 0,
11105                             AC_VERB_SET_CONNECT_SEL,
11106                             present ? 0x00 : 0x01);
11107 }
11108
11109 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11110 {
11111         alc267_quanta_il1_hp_automute(codec);
11112         alc267_quanta_il1_mic_automute(codec);
11113 }
11114
11115 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11116                                            unsigned int res)
11117 {
11118         switch (res >> 26) {
11119         case ALC880_HP_EVENT:
11120                 alc267_quanta_il1_hp_automute(codec);
11121                 break;
11122         case ALC880_MIC_EVENT:
11123                 alc267_quanta_il1_mic_automute(codec);
11124                 break;
11125         }
11126 }
11127
11128 /*
11129  * generic initialization of ADC, input mixers and output mixers
11130  */
11131 static struct hda_verb alc268_base_init_verbs[] = {
11132         /* Unmute DAC0-1 and set vol = 0 */
11133         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11134         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11135         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11136         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11137         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11138         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11139
11140         /*
11141          * Set up output mixers (0x0c - 0x0e)
11142          */
11143         /* set vol=0 to output mixers */
11144         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11145         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11146         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11147         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11148
11149         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11150         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11151
11152         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11153         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11154         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11155         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11156         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11157         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11158         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11159         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11160
11161         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11162         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11163         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11164         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11165         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11166         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11167         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11168
11169         /* set PCBEEP vol = 0, mute connections */
11170         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11171         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11172         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11173
11174         /* Unmute Selector 23h,24h and set the default input to mic-in */
11175
11176         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11177         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11178         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11179         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11180
11181         { }
11182 };
11183
11184 /*
11185  * generic initialization of ADC, input mixers and output mixers
11186  */
11187 static struct hda_verb alc268_volume_init_verbs[] = {
11188         /* set output DAC */
11189         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11190         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11191         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11192         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11193
11194         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11195         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11196         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11197         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11198         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11199
11200         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11201         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11202         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11203         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11204         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11205
11206         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11207         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11208         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11209         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11210
11211         /* set PCBEEP vol = 0, mute connections */
11212         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11213         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11214         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11215
11216         { }
11217 };
11218
11219 #define alc268_mux_enum_info alc_mux_enum_info
11220 #define alc268_mux_enum_get alc_mux_enum_get
11221 #define alc268_mux_enum_put alc_mux_enum_put
11222
11223 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11224         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11225         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11226         {
11227                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11228                 /* The multiple "Capture Source" controls confuse alsamixer
11229                  * So call somewhat different..
11230                  */
11231                 /* .name = "Capture Source", */
11232                 .name = "Input Source",
11233                 .count = 1,
11234                 .info = alc268_mux_enum_info,
11235                 .get = alc268_mux_enum_get,
11236                 .put = alc268_mux_enum_put,
11237         },
11238         { } /* end */
11239 };
11240
11241 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11242         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11243         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11244         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11245         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11246         {
11247                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11248                 /* The multiple "Capture Source" controls confuse alsamixer
11249                  * So call somewhat different..
11250                  */
11251                 /* .name = "Capture Source", */
11252                 .name = "Input Source",
11253                 .count = 2,
11254                 .info = alc268_mux_enum_info,
11255                 .get = alc268_mux_enum_get,
11256                 .put = alc268_mux_enum_put,
11257         },
11258         { } /* end */
11259 };
11260
11261 static struct hda_input_mux alc268_capture_source = {
11262         .num_items = 4,
11263         .items = {
11264                 { "Mic", 0x0 },
11265                 { "Front Mic", 0x1 },
11266                 { "Line", 0x2 },
11267                 { "CD", 0x3 },
11268         },
11269 };
11270
11271 static struct hda_input_mux alc268_acer_capture_source = {
11272         .num_items = 3,
11273         .items = {
11274                 { "Mic", 0x0 },
11275                 { "Internal Mic", 0x6 },
11276                 { "Line", 0x2 },
11277         },
11278 };
11279
11280 #ifdef CONFIG_SND_DEBUG
11281 static struct snd_kcontrol_new alc268_test_mixer[] = {
11282         /* Volume widgets */
11283         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11284         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11285         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11286         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11287         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11288         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11289         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11290         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11291         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11292         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11293         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11294         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11295         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11296         /* The below appears problematic on some hardwares */
11297         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11298         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11299         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11300         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11301         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11302
11303         /* Modes for retasking pin widgets */
11304         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11305         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11306         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11307         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11308
11309         /* Controls for GPIO pins, assuming they are configured as outputs */
11310         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11311         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11312         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11313         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11314
11315         /* Switches to allow the digital SPDIF output pin to be enabled.
11316          * The ALC268 does not have an SPDIF input.
11317          */
11318         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11319
11320         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11321          * this output to turn on an external amplifier.
11322          */
11323         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11324         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11325
11326         { } /* end */
11327 };
11328 #endif
11329
11330 /* create input playback/capture controls for the given pin */
11331 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11332                                     const char *ctlname, int idx)
11333 {
11334         char name[32];
11335         int err;
11336
11337         sprintf(name, "%s Playback Volume", ctlname);
11338         if (nid == 0x14) {
11339                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11340                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11341                                                       HDA_OUTPUT));
11342                 if (err < 0)
11343                         return err;
11344         } else if (nid == 0x15) {
11345                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11346                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11347                                                       HDA_OUTPUT));
11348                 if (err < 0)
11349                         return err;
11350         } else
11351                 return -1;
11352         sprintf(name, "%s Playback Switch", ctlname);
11353         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11354                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11355         if (err < 0)
11356                 return err;
11357         return 0;
11358 }
11359
11360 /* add playback controls from the parsed DAC table */
11361 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11362                                              const struct auto_pin_cfg *cfg)
11363 {
11364         hda_nid_t nid;
11365         int err;
11366
11367         spec->multiout.num_dacs = 2;    /* only use one dac */
11368         spec->multiout.dac_nids = spec->private_dac_nids;
11369         spec->multiout.dac_nids[0] = 2;
11370         spec->multiout.dac_nids[1] = 3;
11371
11372         nid = cfg->line_out_pins[0];
11373         if (nid)
11374                 alc268_new_analog_output(spec, nid, "Front", 0);
11375
11376         nid = cfg->speaker_pins[0];
11377         if (nid == 0x1d) {
11378                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11379                                   "Speaker Playback Volume",
11380                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11381                 if (err < 0)
11382                         return err;
11383         }
11384         nid = cfg->hp_pins[0];
11385         if (nid)
11386                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11387
11388         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11389         if (nid == 0x16) {
11390                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11391                                   "Mono Playback Switch",
11392                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11393                 if (err < 0)
11394                         return err;
11395         }
11396         return 0;
11397 }
11398
11399 /* create playback/capture controls for input pins */
11400 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11401                                                 const struct auto_pin_cfg *cfg)
11402 {
11403         struct hda_input_mux *imux = &spec->private_imux;
11404         int i, idx1;
11405
11406         for (i = 0; i < AUTO_PIN_LAST; i++) {
11407                 switch(cfg->input_pins[i]) {
11408                 case 0x18:
11409                         idx1 = 0;       /* Mic 1 */
11410                         break;
11411                 case 0x19:
11412                         idx1 = 1;       /* Mic 2 */
11413                         break;
11414                 case 0x1a:
11415                         idx1 = 2;       /* Line In */
11416                         break;
11417                 case 0x1c:
11418                         idx1 = 3;       /* CD */
11419                         break;
11420                 case 0x12:
11421                 case 0x13:
11422                         idx1 = 6;       /* digital mics */
11423                         break;
11424                 default:
11425                         continue;
11426                 }
11427                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11428                 imux->items[imux->num_items].index = idx1;
11429                 imux->num_items++;
11430         }
11431         return 0;
11432 }
11433
11434 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11435 {
11436         struct alc_spec *spec = codec->spec;
11437         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11438         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11439         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11440         unsigned int    dac_vol1, dac_vol2;
11441
11442         if (speaker_nid) {
11443                 snd_hda_codec_write(codec, speaker_nid, 0,
11444                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11445                 snd_hda_codec_write(codec, 0x0f, 0,
11446                                     AC_VERB_SET_AMP_GAIN_MUTE,
11447                                     AMP_IN_UNMUTE(1));
11448                 snd_hda_codec_write(codec, 0x10, 0,
11449                                     AC_VERB_SET_AMP_GAIN_MUTE,
11450                                     AMP_IN_UNMUTE(1));
11451         } else {
11452                 snd_hda_codec_write(codec, 0x0f, 0,
11453                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11454                 snd_hda_codec_write(codec, 0x10, 0,
11455                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11456         }
11457
11458         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11459         if (line_nid == 0x14)
11460                 dac_vol2 = AMP_OUT_ZERO;
11461         else if (line_nid == 0x15)
11462                 dac_vol1 = AMP_OUT_ZERO;
11463         if (hp_nid == 0x14)
11464                 dac_vol2 = AMP_OUT_ZERO;
11465         else if (hp_nid == 0x15)
11466                 dac_vol1 = AMP_OUT_ZERO;
11467         if (line_nid != 0x16 || hp_nid != 0x16 ||
11468             spec->autocfg.line_out_pins[1] != 0x16 ||
11469             spec->autocfg.line_out_pins[2] != 0x16)
11470                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11471
11472         snd_hda_codec_write(codec, 0x02, 0,
11473                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11474         snd_hda_codec_write(codec, 0x03, 0,
11475                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11476 }
11477
11478 /* pcm configuration: identiacal with ALC880 */
11479 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11480 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11481 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11482 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11483
11484 /*
11485  * BIOS auto configuration
11486  */
11487 static int alc268_parse_auto_config(struct hda_codec *codec)
11488 {
11489         struct alc_spec *spec = codec->spec;
11490         int err;
11491         static hda_nid_t alc268_ignore[] = { 0 };
11492
11493         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11494                                            alc268_ignore);
11495         if (err < 0)
11496                 return err;
11497         if (!spec->autocfg.line_outs)
11498                 return 0; /* can't find valid BIOS pin config */
11499
11500         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11501         if (err < 0)
11502                 return err;
11503         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11504         if (err < 0)
11505                 return err;
11506
11507         spec->multiout.max_channels = 2;
11508
11509         /* digital only support output */
11510         if (spec->autocfg.dig_out_pin)
11511                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11512
11513         if (spec->kctl_alloc)
11514                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
11515
11516         if (spec->autocfg.speaker_pins[0] != 0x1d)
11517                 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
11518
11519         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
11520         spec->num_mux_defs = 1;
11521         spec->input_mux = &spec->private_imux;
11522
11523         err = alc_auto_add_mic_boost(codec);
11524         if (err < 0)
11525                 return err;
11526
11527         store_pin_configs(codec);
11528         return 1;
11529 }
11530
11531 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11532 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11533 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11534
11535 /* init callback for auto-configuration model -- overriding the default init */
11536 static void alc268_auto_init(struct hda_codec *codec)
11537 {
11538         struct alc_spec *spec = codec->spec;
11539         alc268_auto_init_multi_out(codec);
11540         alc268_auto_init_hp_out(codec);
11541         alc268_auto_init_mono_speaker_out(codec);
11542         alc268_auto_init_analog_input(codec);
11543         if (spec->unsol_event)
11544                 alc_inithook(codec);
11545 }
11546
11547 /*
11548  * configuration and preset
11549  */
11550 static const char *alc268_models[ALC268_MODEL_LAST] = {
11551         [ALC267_QUANTA_IL1]     = "quanta-il1",
11552         [ALC268_3ST]            = "3stack",
11553         [ALC268_TOSHIBA]        = "toshiba",
11554         [ALC268_ACER]           = "acer",
11555         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
11556         [ALC268_DELL]           = "dell",
11557         [ALC268_ZEPTO]          = "zepto",
11558 #ifdef CONFIG_SND_DEBUG
11559         [ALC268_TEST]           = "test",
11560 #endif
11561         [ALC268_AUTO]           = "auto",
11562 };
11563
11564 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11565         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11566         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11567         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11568         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11569         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11570         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11571                                                 ALC268_ACER_ASPIRE_ONE),
11572         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11573         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11574         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11575         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11576         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11577         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11578         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11579         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11580         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11581         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11582         {}
11583 };
11584
11585 static struct alc_config_preset alc268_presets[] = {
11586         [ALC267_QUANTA_IL1] = {
11587                 .mixers = { alc267_quanta_il1_mixer },
11588                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11589                                 alc267_quanta_il1_verbs },
11590                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11591                 .dac_nids = alc268_dac_nids,
11592                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11593                 .adc_nids = alc268_adc_nids_alt,
11594                 .hp_nid = 0x03,
11595                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11596                 .channel_mode = alc268_modes,
11597                 .input_mux = &alc268_capture_source,
11598                 .unsol_event = alc267_quanta_il1_unsol_event,
11599                 .init_hook = alc267_quanta_il1_automute,
11600         },
11601         [ALC268_3ST] = {
11602                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11603                             alc268_beep_mixer },
11604                 .init_verbs = { alc268_base_init_verbs },
11605                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11606                 .dac_nids = alc268_dac_nids,
11607                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11608                 .adc_nids = alc268_adc_nids_alt,
11609                 .capsrc_nids = alc268_capsrc_nids,
11610                 .hp_nid = 0x03,
11611                 .dig_out_nid = ALC268_DIGOUT_NID,
11612                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11613                 .channel_mode = alc268_modes,
11614                 .input_mux = &alc268_capture_source,
11615         },
11616         [ALC268_TOSHIBA] = {
11617                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11618                             alc268_beep_mixer },
11619                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11620                                 alc268_toshiba_verbs },
11621                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11622                 .dac_nids = alc268_dac_nids,
11623                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11624                 .adc_nids = alc268_adc_nids_alt,
11625                 .capsrc_nids = alc268_capsrc_nids,
11626                 .hp_nid = 0x03,
11627                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11628                 .channel_mode = alc268_modes,
11629                 .input_mux = &alc268_capture_source,
11630                 .unsol_event = alc268_toshiba_unsol_event,
11631                 .init_hook = alc268_toshiba_automute,
11632         },
11633         [ALC268_ACER] = {
11634                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11635                             alc268_beep_mixer },
11636                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11637                                 alc268_acer_verbs },
11638                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11639                 .dac_nids = alc268_dac_nids,
11640                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11641                 .adc_nids = alc268_adc_nids_alt,
11642                 .capsrc_nids = alc268_capsrc_nids,
11643                 .hp_nid = 0x02,
11644                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11645                 .channel_mode = alc268_modes,
11646                 .input_mux = &alc268_acer_capture_source,
11647                 .unsol_event = alc268_acer_unsol_event,
11648                 .init_hook = alc268_acer_init_hook,
11649         },
11650         [ALC268_ACER_ASPIRE_ONE] = {
11651                 .mixers = { alc268_acer_aspire_one_mixer,
11652                                 alc268_capture_alt_mixer },
11653                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11654                                 alc268_acer_aspire_one_verbs },
11655                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11656                 .dac_nids = alc268_dac_nids,
11657                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11658                 .adc_nids = alc268_adc_nids_alt,
11659                 .capsrc_nids = alc268_capsrc_nids,
11660                 .hp_nid = 0x03,
11661                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11662                 .channel_mode = alc268_modes,
11663                 .input_mux = &alc268_acer_lc_capture_source,
11664                 .unsol_event = alc268_acer_lc_unsol_event,
11665                 .init_hook = alc268_acer_lc_init_hook,
11666         },
11667         [ALC268_DELL] = {
11668                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
11669                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11670                                 alc268_dell_verbs },
11671                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11672                 .dac_nids = alc268_dac_nids,
11673                 .hp_nid = 0x02,
11674                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11675                 .channel_mode = alc268_modes,
11676                 .unsol_event = alc268_dell_unsol_event,
11677                 .init_hook = alc268_dell_init_hook,
11678                 .input_mux = &alc268_capture_source,
11679         },
11680         [ALC268_ZEPTO] = {
11681                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11682                             alc268_beep_mixer },
11683                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11684                                 alc268_toshiba_verbs },
11685                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11686                 .dac_nids = alc268_dac_nids,
11687                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11688                 .adc_nids = alc268_adc_nids_alt,
11689                 .capsrc_nids = alc268_capsrc_nids,
11690                 .hp_nid = 0x03,
11691                 .dig_out_nid = ALC268_DIGOUT_NID,
11692                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11693                 .channel_mode = alc268_modes,
11694                 .input_mux = &alc268_capture_source,
11695                 .unsol_event = alc268_toshiba_unsol_event,
11696                 .init_hook = alc268_toshiba_automute
11697         },
11698 #ifdef CONFIG_SND_DEBUG
11699         [ALC268_TEST] = {
11700                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
11701                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11702                                 alc268_volume_init_verbs },
11703                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11704                 .dac_nids = alc268_dac_nids,
11705                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11706                 .adc_nids = alc268_adc_nids_alt,
11707                 .capsrc_nids = alc268_capsrc_nids,
11708                 .hp_nid = 0x03,
11709                 .dig_out_nid = ALC268_DIGOUT_NID,
11710                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11711                 .channel_mode = alc268_modes,
11712                 .input_mux = &alc268_capture_source,
11713         },
11714 #endif
11715 };
11716
11717 static int patch_alc268(struct hda_codec *codec)
11718 {
11719         struct alc_spec *spec;
11720         int board_config;
11721         int err;
11722
11723         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
11724         if (spec == NULL)
11725                 return -ENOMEM;
11726
11727         codec->spec = spec;
11728
11729         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
11730                                                   alc268_models,
11731                                                   alc268_cfg_tbl);
11732
11733         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
11734                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
11735                        "trying auto-probe from BIOS...\n");
11736                 board_config = ALC268_AUTO;
11737         }
11738
11739         if (board_config == ALC268_AUTO) {
11740                 /* automatic parse from the BIOS config */
11741                 err = alc268_parse_auto_config(codec);
11742                 if (err < 0) {
11743                         alc_free(codec);
11744                         return err;
11745                 } else if (!err) {
11746                         printk(KERN_INFO
11747                                "hda_codec: Cannot set up configuration "
11748                                "from BIOS.  Using base mode...\n");
11749                         board_config = ALC268_3ST;
11750                 }
11751         }
11752
11753         if (board_config != ALC268_AUTO)
11754                 setup_preset(spec, &alc268_presets[board_config]);
11755
11756         if (codec->vendor_id == 0x10ec0267) {
11757                 spec->stream_name_analog = "ALC267 Analog";
11758                 spec->stream_name_digital = "ALC267 Digital";
11759         } else {
11760                 spec->stream_name_analog = "ALC268 Analog";
11761                 spec->stream_name_digital = "ALC268 Digital";
11762         }
11763
11764         spec->stream_analog_playback = &alc268_pcm_analog_playback;
11765         spec->stream_analog_capture = &alc268_pcm_analog_capture;
11766         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
11767
11768         spec->stream_digital_playback = &alc268_pcm_digital_playback;
11769
11770         if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
11771                 /* override the amp caps for beep generator */
11772                 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
11773                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
11774                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
11775                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11776                                           (0 << AC_AMPCAP_MUTE_SHIFT));
11777
11778         if (!spec->adc_nids && spec->input_mux) {
11779                 /* check whether NID 0x07 is valid */
11780                 unsigned int wcap = get_wcaps(codec, 0x07);
11781                 int i;
11782
11783                 /* get type */
11784                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11785                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
11786                         spec->adc_nids = alc268_adc_nids_alt;
11787                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
11788                         spec->mixers[spec->num_mixers] =
11789                                         alc268_capture_alt_mixer;
11790                         spec->num_mixers++;
11791                 } else {
11792                         spec->adc_nids = alc268_adc_nids;
11793                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
11794                         spec->mixers[spec->num_mixers] =
11795                                 alc268_capture_mixer;
11796                         spec->num_mixers++;
11797                 }
11798                 spec->capsrc_nids = alc268_capsrc_nids;
11799                 /* set default input source */
11800                 for (i = 0; i < spec->num_adc_nids; i++)
11801                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
11802                                 0, AC_VERB_SET_CONNECT_SEL,
11803                                 spec->input_mux->items[0].index);
11804         }
11805
11806         spec->vmaster_nid = 0x02;
11807
11808         codec->patch_ops = alc_patch_ops;
11809         if (board_config == ALC268_AUTO)
11810                 spec->init_hook = alc268_auto_init;
11811
11812         return 0;
11813 }
11814
11815 /*
11816  *  ALC269 channel source setting (2 channel)
11817  */
11818 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
11819
11820 #define alc269_dac_nids         alc260_dac_nids
11821
11822 static hda_nid_t alc269_adc_nids[1] = {
11823         /* ADC1 */
11824         0x08,
11825 };
11826
11827 static hda_nid_t alc269_capsrc_nids[1] = {
11828         0x23,
11829 };
11830
11831 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
11832  *       not a mux!
11833  */
11834
11835 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
11836         .num_items = 2,
11837         .items = {
11838                 { "i-Mic", 0x5 },
11839                 { "e-Mic", 0x0 },
11840         },
11841 };
11842
11843 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
11844         .num_items = 2,
11845         .items = {
11846                 { "i-Mic", 0x1 },
11847                 { "e-Mic", 0x0 },
11848         },
11849 };
11850
11851 #define alc269_modes            alc260_modes
11852 #define alc269_capture_source   alc880_lg_lw_capture_source
11853
11854 static struct snd_kcontrol_new alc269_base_mixer[] = {
11855         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11856         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11857         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11858         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11859         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11860         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11861         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11862         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11863         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11864         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11865         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11866         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11867         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11868         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11869         { } /* end */
11870 };
11871
11872 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
11873         /* output mixer control */
11874         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11875         {
11876                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11877                 .name = "Master Playback Switch",
11878                 .info = snd_hda_mixer_amp_switch_info,
11879                 .get = snd_hda_mixer_amp_switch_get,
11880                 .put = alc268_acer_master_sw_put,
11881                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11882         },
11883         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11884         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11885         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11886         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11887         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11888         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11889         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
11890         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
11891         { }
11892 };
11893
11894 /* bind volumes of both NID 0x0c and 0x0d */
11895 static struct hda_bind_ctls alc269_epc_bind_vol = {
11896         .ops = &snd_hda_bind_vol,
11897         .values = {
11898                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11899                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11900                 0
11901         },
11902 };
11903
11904 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
11905         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11906         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
11907         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11908         { } /* end */
11909 };
11910
11911 /* capture mixer elements */
11912 static struct snd_kcontrol_new alc269_capture_mixer[] = {
11913         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11914         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11915         {
11916                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11917                 /* The multiple "Capture Source" controls confuse alsamixer
11918                  * So call somewhat different..
11919                  */
11920                 /* .name = "Capture Source", */
11921                 .name = "Input Source",
11922                 .count = 1,
11923                 .info = alc_mux_enum_info,
11924                 .get = alc_mux_enum_get,
11925                 .put = alc_mux_enum_put,
11926         },
11927         { } /* end */
11928 };
11929
11930 /* capture mixer elements */
11931 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
11932         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
11933         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
11934         { } /* end */
11935 };
11936
11937 /* beep control */
11938 static struct snd_kcontrol_new alc269_beep_mixer[] = {
11939         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x4, HDA_INPUT),
11940         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x4, HDA_INPUT),
11941         { } /* end */
11942 };
11943
11944 static struct hda_verb alc269_quanta_fl1_verbs[] = {
11945         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11946         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11947         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11948         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11949         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11950         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11951         { }
11952 };
11953
11954 /* toggle speaker-output according to the hp-jack state */
11955 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
11956 {
11957         unsigned int present;
11958         unsigned char bits;
11959
11960         present = snd_hda_codec_read(codec, 0x15, 0,
11961                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11962         bits = present ? AMP_IN_MUTE(0) : 0;
11963         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
11964                         AMP_IN_MUTE(0), bits);
11965         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
11966                         AMP_IN_MUTE(0), bits);
11967
11968         snd_hda_codec_write(codec, 0x20, 0,
11969                         AC_VERB_SET_COEF_INDEX, 0x0c);
11970         snd_hda_codec_write(codec, 0x20, 0,
11971                         AC_VERB_SET_PROC_COEF, 0x680);
11972
11973         snd_hda_codec_write(codec, 0x20, 0,
11974                         AC_VERB_SET_COEF_INDEX, 0x0c);
11975         snd_hda_codec_write(codec, 0x20, 0,
11976                         AC_VERB_SET_PROC_COEF, 0x480);
11977 }
11978
11979 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
11980 {
11981         unsigned int present;
11982
11983         present = snd_hda_codec_read(codec, 0x18, 0,
11984                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11985         snd_hda_codec_write(codec, 0x23, 0,
11986                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
11987 }
11988
11989 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
11990                                     unsigned int res)
11991 {
11992         if ((res >> 26) == ALC880_HP_EVENT)
11993                 alc269_quanta_fl1_speaker_automute(codec);
11994         if ((res >> 26) == ALC880_MIC_EVENT)
11995                 alc269_quanta_fl1_mic_automute(codec);
11996 }
11997
11998 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
11999 {
12000         alc269_quanta_fl1_speaker_automute(codec);
12001         alc269_quanta_fl1_mic_automute(codec);
12002 }
12003
12004 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12005         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12006         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12007         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12008         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12009         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12010         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12011         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12012         {}
12013 };
12014
12015 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12016         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12017         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12018         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12019         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12020         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12021         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12022         {}
12023 };
12024
12025 /* toggle speaker-output according to the hp-jack state */
12026 static void alc269_speaker_automute(struct hda_codec *codec)
12027 {
12028         unsigned int present;
12029         unsigned char bits;
12030
12031         present = snd_hda_codec_read(codec, 0x15, 0,
12032                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12033         bits = present ? AMP_IN_MUTE(0) : 0;
12034         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12035                                 AMP_IN_MUTE(0), bits);
12036         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12037                                 AMP_IN_MUTE(0), bits);
12038 }
12039
12040 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12041 {
12042         unsigned int present;
12043
12044         present = snd_hda_codec_read(codec, 0x18, 0,
12045                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12046         snd_hda_codec_write(codec, 0x23, 0,
12047                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12048 }
12049
12050 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12051 {
12052         unsigned int present;
12053
12054         present = snd_hda_codec_read(codec, 0x18, 0,
12055                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12056         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12057                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12058         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12059                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12060 }
12061
12062 /* unsolicited event for HP jack sensing */
12063 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12064                                      unsigned int res)
12065 {
12066         if ((res >> 26) == ALC880_HP_EVENT)
12067                 alc269_speaker_automute(codec);
12068
12069         if ((res >> 26) == ALC880_MIC_EVENT)
12070                 alc269_eeepc_dmic_automute(codec);
12071 }
12072
12073 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12074 {
12075         alc269_speaker_automute(codec);
12076         alc269_eeepc_dmic_automute(codec);
12077 }
12078
12079 /* unsolicited event for HP jack sensing */
12080 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12081                                      unsigned int res)
12082 {
12083         if ((res >> 26) == ALC880_HP_EVENT)
12084                 alc269_speaker_automute(codec);
12085
12086         if ((res >> 26) == ALC880_MIC_EVENT)
12087                 alc269_eeepc_amic_automute(codec);
12088 }
12089
12090 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12091 {
12092         alc269_speaker_automute(codec);
12093         alc269_eeepc_amic_automute(codec);
12094 }
12095
12096 /*
12097  * generic initialization of ADC, input mixers and output mixers
12098  */
12099 static struct hda_verb alc269_init_verbs[] = {
12100         /*
12101          * Unmute ADC0 and set the default input to mic-in
12102          */
12103         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12104
12105         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12106          * analog-loopback mixer widget
12107          * Note: PASD motherboards uses the Line In 2 as the input for
12108          * front panel mic (mic 2)
12109          */
12110         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12111         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12116
12117         /*
12118          * Set up output mixers (0x0c - 0x0e)
12119          */
12120         /* set vol=0 to output mixers */
12121         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12122         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12123
12124         /* set up input amps for analog loopback */
12125         /* Amp Indices: DAC = 0, mixer = 1 */
12126         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12127         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12128         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12129         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12130         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12131         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12132
12133         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12134         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12135         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12136         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12137         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12138         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12139         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12140
12141         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12142         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12143         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12144         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12145         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12146         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12147         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12148
12149         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12150         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12151
12152         /* FIXME: use matrix-type input source selection */
12153         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12154         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12155         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12156         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12157         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12158         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12159
12160         /* set EAPD */
12161         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12162         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12163         { }
12164 };
12165
12166 /* add playback controls from the parsed DAC table */
12167 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12168                                              const struct auto_pin_cfg *cfg)
12169 {
12170         hda_nid_t nid;
12171         int err;
12172
12173         spec->multiout.num_dacs = 1;    /* only use one dac */
12174         spec->multiout.dac_nids = spec->private_dac_nids;
12175         spec->multiout.dac_nids[0] = 2;
12176
12177         nid = cfg->line_out_pins[0];
12178         if (nid) {
12179                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12180                                   "Front Playback Volume",
12181                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12182                 if (err < 0)
12183                         return err;
12184                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12185                                   "Front Playback Switch",
12186                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12187                 if (err < 0)
12188                         return err;
12189         }
12190
12191         nid = cfg->speaker_pins[0];
12192         if (nid) {
12193                 if (!cfg->line_out_pins[0]) {
12194                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12195                                           "Speaker Playback Volume",
12196                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12197                                                               HDA_OUTPUT));
12198                         if (err < 0)
12199                                 return err;
12200                 }
12201                 if (nid == 0x16) {
12202                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12203                                           "Speaker Playback Switch",
12204                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12205                                                               HDA_OUTPUT));
12206                         if (err < 0)
12207                                 return err;
12208                 } else {
12209                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12210                                           "Speaker Playback Switch",
12211                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12212                                                               HDA_OUTPUT));
12213                         if (err < 0)
12214                                 return err;
12215                 }
12216         }
12217         nid = cfg->hp_pins[0];
12218         if (nid) {
12219                 /* spec->multiout.hp_nid = 2; */
12220                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12221                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12222                                           "Headphone Playback Volume",
12223                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12224                                                               HDA_OUTPUT));
12225                         if (err < 0)
12226                                 return err;
12227                 }
12228                 if (nid == 0x16) {
12229                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12230                                           "Headphone Playback Switch",
12231                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12232                                                               HDA_OUTPUT));
12233                         if (err < 0)
12234                                 return err;
12235                 } else {
12236                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12237                                           "Headphone Playback Switch",
12238                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12239                                                               HDA_OUTPUT));
12240                         if (err < 0)
12241                                 return err;
12242                 }
12243         }
12244         return 0;
12245 }
12246
12247 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12248                                                 const struct auto_pin_cfg *cfg)
12249 {
12250         int err;
12251
12252         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12253         if (err < 0)
12254                 return err;
12255         /* digital-mic input pin is excluded in alc880_auto_create..()
12256          * because it's under 0x18
12257          */
12258         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12259             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12260                 struct hda_input_mux *imux = &spec->private_imux;
12261                 imux->items[imux->num_items].label = "Int Mic";
12262                 imux->items[imux->num_items].index = 0x05;
12263                 imux->num_items++;
12264         }
12265         return 0;
12266 }
12267
12268 #ifdef CONFIG_SND_HDA_POWER_SAVE
12269 #define alc269_loopbacks        alc880_loopbacks
12270 #endif
12271
12272 /* pcm configuration: identiacal with ALC880 */
12273 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12274 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12275 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12276 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12277
12278 /*
12279  * BIOS auto configuration
12280  */
12281 static int alc269_parse_auto_config(struct hda_codec *codec)
12282 {
12283         struct alc_spec *spec = codec->spec;
12284         int i, err;
12285         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12286
12287         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12288                                            alc269_ignore);
12289         if (err < 0)
12290                 return err;
12291
12292         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12293         if (err < 0)
12294                 return err;
12295         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12296         if (err < 0)
12297                 return err;
12298
12299         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12300
12301         if (spec->autocfg.dig_out_pin)
12302                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12303
12304         if (spec->kctl_alloc)
12305                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
12306
12307         /* create a beep mixer control if the pin 0x1d isn't assigned */
12308         for (i = 0; i < ARRAY_SIZE(spec->autocfg.input_pins); i++)
12309                 if (spec->autocfg.input_pins[i] == 0x1d)
12310                         break;
12311         if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
12312                 spec->mixers[spec->num_mixers++] = alc269_beep_mixer;
12313
12314         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
12315         spec->num_mux_defs = 1;
12316         spec->input_mux = &spec->private_imux;
12317         /* set default input source */
12318         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12319                                   0, AC_VERB_SET_CONNECT_SEL,
12320                                   spec->input_mux->items[0].index);
12321
12322         err = alc_auto_add_mic_boost(codec);
12323         if (err < 0)
12324                 return err;
12325
12326         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
12327         spec->num_mixers++;
12328
12329         store_pin_configs(codec);
12330         return 1;
12331 }
12332
12333 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12334 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12335 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12336
12337
12338 /* init callback for auto-configuration model -- overriding the default init */
12339 static void alc269_auto_init(struct hda_codec *codec)
12340 {
12341         struct alc_spec *spec = codec->spec;
12342         alc269_auto_init_multi_out(codec);
12343         alc269_auto_init_hp_out(codec);
12344         alc269_auto_init_analog_input(codec);
12345         if (spec->unsol_event)
12346                 alc_inithook(codec);
12347 }
12348
12349 /*
12350  * configuration and preset
12351  */
12352 static const char *alc269_models[ALC269_MODEL_LAST] = {
12353         [ALC269_BASIC]                  = "basic",
12354         [ALC269_QUANTA_FL1]             = "quanta",
12355         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12356         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901"
12357 };
12358
12359 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12360         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12361         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12362                       ALC269_ASUS_EEEPC_P703),
12363         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12364                       ALC269_ASUS_EEEPC_P901),
12365         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12366                       ALC269_ASUS_EEEPC_P901),
12367         {}
12368 };
12369
12370 static struct alc_config_preset alc269_presets[] = {
12371         [ALC269_BASIC] = {
12372                 .mixers = { alc269_base_mixer, alc269_capture_mixer },
12373                 .init_verbs = { alc269_init_verbs },
12374                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12375                 .dac_nids = alc269_dac_nids,
12376                 .hp_nid = 0x03,
12377                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12378                 .channel_mode = alc269_modes,
12379                 .input_mux = &alc269_capture_source,
12380         },
12381         [ALC269_QUANTA_FL1] = {
12382                 .mixers = { alc269_quanta_fl1_mixer },
12383                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12384                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12385                 .dac_nids = alc269_dac_nids,
12386                 .hp_nid = 0x03,
12387                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12388                 .channel_mode = alc269_modes,
12389                 .input_mux = &alc269_capture_source,
12390                 .unsol_event = alc269_quanta_fl1_unsol_event,
12391                 .init_hook = alc269_quanta_fl1_init_hook,
12392         },
12393         [ALC269_ASUS_EEEPC_P703] = {
12394                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
12395                 .init_verbs = { alc269_init_verbs,
12396                                 alc269_eeepc_amic_init_verbs },
12397                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12398                 .dac_nids = alc269_dac_nids,
12399                 .hp_nid = 0x03,
12400                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12401                 .channel_mode = alc269_modes,
12402                 .input_mux = &alc269_eeepc_amic_capture_source,
12403                 .unsol_event = alc269_eeepc_amic_unsol_event,
12404                 .init_hook = alc269_eeepc_amic_inithook,
12405         },
12406         [ALC269_ASUS_EEEPC_P901] = {
12407                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
12408                 .init_verbs = { alc269_init_verbs,
12409                                 alc269_eeepc_dmic_init_verbs },
12410                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12411                 .dac_nids = alc269_dac_nids,
12412                 .hp_nid = 0x03,
12413                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12414                 .channel_mode = alc269_modes,
12415                 .input_mux = &alc269_eeepc_dmic_capture_source,
12416                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12417                 .init_hook = alc269_eeepc_dmic_inithook,
12418         },
12419 };
12420
12421 static int patch_alc269(struct hda_codec *codec)
12422 {
12423         struct alc_spec *spec;
12424         int board_config;
12425         int err;
12426
12427         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12428         if (spec == NULL)
12429                 return -ENOMEM;
12430
12431         codec->spec = spec;
12432
12433         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12434
12435         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12436                                                   alc269_models,
12437                                                   alc269_cfg_tbl);
12438
12439         if (board_config < 0) {
12440                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12441                        "trying auto-probe from BIOS...\n");
12442                 board_config = ALC269_AUTO;
12443         }
12444
12445         if (board_config == ALC269_AUTO) {
12446                 /* automatic parse from the BIOS config */
12447                 err = alc269_parse_auto_config(codec);
12448                 if (err < 0) {
12449                         alc_free(codec);
12450                         return err;
12451                 } else if (!err) {
12452                         printk(KERN_INFO
12453                                "hda_codec: Cannot set up configuration "
12454                                "from BIOS.  Using base mode...\n");
12455                         board_config = ALC269_BASIC;
12456                 }
12457         }
12458
12459         if (board_config != ALC269_AUTO)
12460                 setup_preset(spec, &alc269_presets[board_config]);
12461
12462         spec->stream_name_analog = "ALC269 Analog";
12463         spec->stream_analog_playback = &alc269_pcm_analog_playback;
12464         spec->stream_analog_capture = &alc269_pcm_analog_capture;
12465
12466         spec->stream_name_digital = "ALC269 Digital";
12467         spec->stream_digital_playback = &alc269_pcm_digital_playback;
12468         spec->stream_digital_capture = &alc269_pcm_digital_capture;
12469
12470         spec->adc_nids = alc269_adc_nids;
12471         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12472         spec->capsrc_nids = alc269_capsrc_nids;
12473
12474         codec->patch_ops = alc_patch_ops;
12475         if (board_config == ALC269_AUTO)
12476                 spec->init_hook = alc269_auto_init;
12477 #ifdef CONFIG_SND_HDA_POWER_SAVE
12478         if (!spec->loopback.amplist)
12479                 spec->loopback.amplist = alc269_loopbacks;
12480 #endif
12481
12482         return 0;
12483 }
12484
12485 /*
12486  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
12487  */
12488
12489 /*
12490  * set the path ways for 2 channel output
12491  * need to set the codec line out and mic 1 pin widgets to inputs
12492  */
12493 static struct hda_verb alc861_threestack_ch2_init[] = {
12494         /* set pin widget 1Ah (line in) for input */
12495         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12496         /* set pin widget 18h (mic1/2) for input, for mic also enable
12497          * the vref
12498          */
12499         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12500
12501         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12502 #if 0
12503         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12504         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12505 #endif
12506         { } /* end */
12507 };
12508 /*
12509  * 6ch mode
12510  * need to set the codec line out and mic 1 pin widgets to outputs
12511  */
12512 static struct hda_verb alc861_threestack_ch6_init[] = {
12513         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12514         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12515         /* set pin widget 18h (mic1) for output (CLFE)*/
12516         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12517
12518         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12519         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12520
12521         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12522 #if 0
12523         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12524         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12525 #endif
12526         { } /* end */
12527 };
12528
12529 static struct hda_channel_mode alc861_threestack_modes[2] = {
12530         { 2, alc861_threestack_ch2_init },
12531         { 6, alc861_threestack_ch6_init },
12532 };
12533 /* Set mic1 as input and unmute the mixer */
12534 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
12535         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12536         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12537         { } /* end */
12538 };
12539 /* Set mic1 as output and mute mixer */
12540 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
12541         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12542         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12543         { } /* end */
12544 };
12545
12546 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
12547         { 2, alc861_uniwill_m31_ch2_init },
12548         { 4, alc861_uniwill_m31_ch4_init },
12549 };
12550
12551 /* Set mic1 and line-in as input and unmute the mixer */
12552 static struct hda_verb alc861_asus_ch2_init[] = {
12553         /* set pin widget 1Ah (line in) for input */
12554         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12555         /* set pin widget 18h (mic1/2) for input, for mic also enable
12556          * the vref
12557          */
12558         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12559
12560         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12561 #if 0
12562         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12563         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12564 #endif
12565         { } /* end */
12566 };
12567 /* Set mic1 nad line-in as output and mute mixer */
12568 static struct hda_verb alc861_asus_ch6_init[] = {
12569         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12570         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12571         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12572         /* set pin widget 18h (mic1) for output (CLFE)*/
12573         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12574         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12575         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12576         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12577
12578         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12579 #if 0
12580         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12581         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12582 #endif
12583         { } /* end */
12584 };
12585
12586 static struct hda_channel_mode alc861_asus_modes[2] = {
12587         { 2, alc861_asus_ch2_init },
12588         { 6, alc861_asus_ch6_init },
12589 };
12590
12591 /* patch-ALC861 */
12592
12593 static struct snd_kcontrol_new alc861_base_mixer[] = {
12594         /* output mixer control */
12595         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12596         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12597         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12598         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12599         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12600
12601         /*Input mixer control */
12602         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12603            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12604         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12605         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12606         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12607         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12608         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12609         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12610         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12611         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12612
12613         /* Capture mixer control */
12614         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12615         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12616         {
12617                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12618                 .name = "Capture Source",
12619                 .count = 1,
12620                 .info = alc_mux_enum_info,
12621                 .get = alc_mux_enum_get,
12622                 .put = alc_mux_enum_put,
12623         },
12624         { } /* end */
12625 };
12626
12627 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
12628         /* output mixer control */
12629         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12630         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12631         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12632         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12633         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12634
12635         /* Input mixer control */
12636         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12637            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12638         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12639         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12640         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12641         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12642         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12643         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12644         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12645         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12646
12647         /* Capture mixer control */
12648         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12649         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12650         {
12651                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12652                 .name = "Capture Source",
12653                 .count = 1,
12654                 .info = alc_mux_enum_info,
12655                 .get = alc_mux_enum_get,
12656                 .put = alc_mux_enum_put,
12657         },
12658         {
12659                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12660                 .name = "Channel Mode",
12661                 .info = alc_ch_mode_info,
12662                 .get = alc_ch_mode_get,
12663                 .put = alc_ch_mode_put,
12664                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
12665         },
12666         { } /* end */
12667 };
12668
12669 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
12670         /* output mixer control */
12671         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12672         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12673         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12674
12675         /*Capture mixer control */
12676         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12677         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12678         {
12679                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12680                 .name = "Capture Source",
12681                 .count = 1,
12682                 .info = alc_mux_enum_info,
12683                 .get = alc_mux_enum_get,
12684                 .put = alc_mux_enum_put,
12685         },
12686
12687         { } /* end */
12688 };
12689
12690 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
12691         /* output mixer control */
12692         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12693         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12694         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12695         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12696         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
12697
12698         /* Input mixer control */
12699         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12700            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
12701         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12702         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12703         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12704         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12705         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12706         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12707         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12708         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
12709
12710         /* Capture mixer control */
12711         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12712         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12713         {
12714                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12715                 .name = "Capture Source",
12716                 .count = 1,
12717                 .info = alc_mux_enum_info,
12718                 .get = alc_mux_enum_get,
12719                 .put = alc_mux_enum_put,
12720         },
12721         {
12722                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12723                 .name = "Channel Mode",
12724                 .info = alc_ch_mode_info,
12725                 .get = alc_ch_mode_get,
12726                 .put = alc_ch_mode_put,
12727                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
12728         },
12729         { } /* end */
12730 };
12731
12732 static struct snd_kcontrol_new alc861_asus_mixer[] = {
12733         /* output mixer control */
12734         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
12735         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
12736         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
12737         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
12738         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
12739
12740         /* Input mixer control */
12741         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
12742         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12743         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12744         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12745         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
12746         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
12747         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
12748         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
12749         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
12750         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
12751
12752         /* Capture mixer control */
12753         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12754         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12755         {
12756                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12757                 .name = "Capture Source",
12758                 .count = 1,
12759                 .info = alc_mux_enum_info,
12760                 .get = alc_mux_enum_get,
12761                 .put = alc_mux_enum_put,
12762         },
12763         {
12764                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12765                 .name = "Channel Mode",
12766                 .info = alc_ch_mode_info,
12767                 .get = alc_ch_mode_get,
12768                 .put = alc_ch_mode_put,
12769                 .private_value = ARRAY_SIZE(alc861_asus_modes),
12770         },
12771         { }
12772 };
12773
12774 /* additional mixer */
12775 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
12776         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
12777         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
12778         HDA_CODEC_VOLUME("PC Beep Playback Volume", 0x23, 0x0, HDA_OUTPUT),
12779         HDA_CODEC_MUTE("PC Beep Playback Switch", 0x23, 0x0, HDA_OUTPUT),
12780         { }
12781 };
12782
12783 /*
12784  * generic initialization of ADC, input mixers and output mixers
12785  */
12786 static struct hda_verb alc861_base_init_verbs[] = {
12787         /*
12788          * Unmute ADC0 and set the default input to mic-in
12789          */
12790         /* port-A for surround (rear panel) */
12791         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12792         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
12793         /* port-B for mic-in (rear panel) with vref */
12794         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12795         /* port-C for line-in (rear panel) */
12796         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12797         /* port-D for Front */
12798         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12799         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12800         /* port-E for HP out (front panel) */
12801         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12802         /* route front PCM to HP */
12803         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12804         /* port-F for mic-in (front panel) with vref */
12805         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12806         /* port-G for CLFE (rear panel) */
12807         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12808         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12809         /* port-H for side (rear panel) */
12810         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12811         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
12812         /* CD-in */
12813         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12814         /* route front mic to ADC1*/
12815         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12816         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12817
12818         /* Unmute DAC0~3 & spdif out*/
12819         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12820         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12821         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12822         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12823         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12824
12825         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12826         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12827         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12828         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12829         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12830
12831         /* Unmute Stereo Mixer 15 */
12832         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12833         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12834         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12835         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12836
12837         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12838         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12839         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12840         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12841         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12842         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12843         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12844         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12845         /* hp used DAC 3 (Front) */
12846         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12847         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12848
12849         { }
12850 };
12851
12852 static struct hda_verb alc861_threestack_init_verbs[] = {
12853         /*
12854          * Unmute ADC0 and set the default input to mic-in
12855          */
12856         /* port-A for surround (rear panel) */
12857         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12858         /* port-B for mic-in (rear panel) with vref */
12859         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12860         /* port-C for line-in (rear panel) */
12861         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12862         /* port-D for Front */
12863         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12864         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12865         /* port-E for HP out (front panel) */
12866         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
12867         /* route front PCM to HP */
12868         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12869         /* port-F for mic-in (front panel) with vref */
12870         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12871         /* port-G for CLFE (rear panel) */
12872         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12873         /* port-H for side (rear panel) */
12874         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12875         /* CD-in */
12876         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12877         /* route front mic to ADC1*/
12878         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12879         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12880         /* Unmute DAC0~3 & spdif out*/
12881         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12882         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12883         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12884         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12885         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12886
12887         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12888         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12889         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12890         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12891         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12892
12893         /* Unmute Stereo Mixer 15 */
12894         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12895         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12896         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12897         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12898
12899         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12900         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12901         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12902         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12903         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12904         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12905         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12906         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12907         /* hp used DAC 3 (Front) */
12908         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12909         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12910         { }
12911 };
12912
12913 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
12914         /*
12915          * Unmute ADC0 and set the default input to mic-in
12916          */
12917         /* port-A for surround (rear panel) */
12918         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12919         /* port-B for mic-in (rear panel) with vref */
12920         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12921         /* port-C for line-in (rear panel) */
12922         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12923         /* port-D for Front */
12924         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12925         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12926         /* port-E for HP out (front panel) */
12927         /* this has to be set to VREF80 */
12928         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12929         /* route front PCM to HP */
12930         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12931         /* port-F for mic-in (front panel) with vref */
12932         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12933         /* port-G for CLFE (rear panel) */
12934         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12935         /* port-H for side (rear panel) */
12936         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
12937         /* CD-in */
12938         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12939         /* route front mic to ADC1*/
12940         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12941         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12942         /* Unmute DAC0~3 & spdif out*/
12943         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12944         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12945         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12946         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12947         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12948
12949         /* Unmute Mixer 14 (mic) 1c (Line in)*/
12950         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12951         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12952         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12953         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12954
12955         /* Unmute Stereo Mixer 15 */
12956         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12957         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12958         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12959         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
12960
12961         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12962         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12963         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12964         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12965         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12966         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12967         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12968         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12969         /* hp used DAC 3 (Front) */
12970         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
12971         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
12972         { }
12973 };
12974
12975 static struct hda_verb alc861_asus_init_verbs[] = {
12976         /*
12977          * Unmute ADC0 and set the default input to mic-in
12978          */
12979         /* port-A for surround (rear panel)
12980          * according to codec#0 this is the HP jack
12981          */
12982         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
12983         /* route front PCM to HP */
12984         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
12985         /* port-B for mic-in (rear panel) with vref */
12986         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12987         /* port-C for line-in (rear panel) */
12988         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12989         /* port-D for Front */
12990         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12991         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
12992         /* port-E for HP out (front panel) */
12993         /* this has to be set to VREF80 */
12994         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12995         /* route front PCM to HP */
12996         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
12997         /* port-F for mic-in (front panel) with vref */
12998         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12999         /* port-G for CLFE (rear panel) */
13000         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13001         /* port-H for side (rear panel) */
13002         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13003         /* CD-in */
13004         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13005         /* route front mic to ADC1*/
13006         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13007         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13008         /* Unmute DAC0~3 & spdif out*/
13009         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13010         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13011         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13012         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13013         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13014         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13015         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13016         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13017         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13018         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13019
13020         /* Unmute Stereo Mixer 15 */
13021         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13022         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13023         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13024         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13025
13026         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13027         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13028         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13029         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13030         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13031         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13032         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13033         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13034         /* hp used DAC 3 (Front) */
13035         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13036         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13037         { }
13038 };
13039
13040 /* additional init verbs for ASUS laptops */
13041 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13042         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13043         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13044         { }
13045 };
13046
13047 /*
13048  * generic initialization of ADC, input mixers and output mixers
13049  */
13050 static struct hda_verb alc861_auto_init_verbs[] = {
13051         /*
13052          * Unmute ADC0 and set the default input to mic-in
13053          */
13054         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13055         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13056
13057         /* Unmute DAC0~3 & spdif out*/
13058         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13059         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13060         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13061         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13062         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13063
13064         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13065         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13066         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13067         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13068         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13069
13070         /* Unmute Stereo Mixer 15 */
13071         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13072         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13073         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13074         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13075
13076         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13077         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13078         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13079         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13080         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13081         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13082         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13083         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13084
13085         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13086         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13087         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13088         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13089         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13090         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13091         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13092         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13093
13094         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13095
13096         { }
13097 };
13098
13099 static struct hda_verb alc861_toshiba_init_verbs[] = {
13100         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13101
13102         { }
13103 };
13104
13105 /* toggle speaker-output according to the hp-jack state */
13106 static void alc861_toshiba_automute(struct hda_codec *codec)
13107 {
13108         unsigned int present;
13109
13110         present = snd_hda_codec_read(codec, 0x0f, 0,
13111                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13112         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13113                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13114         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13115                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13116 }
13117
13118 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13119                                        unsigned int res)
13120 {
13121         if ((res >> 26) == ALC880_HP_EVENT)
13122                 alc861_toshiba_automute(codec);
13123 }
13124
13125 /* pcm configuration: identiacal with ALC880 */
13126 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13127 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13128 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13129 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13130
13131
13132 #define ALC861_DIGOUT_NID       0x07
13133
13134 static struct hda_channel_mode alc861_8ch_modes[1] = {
13135         { 8, NULL }
13136 };
13137
13138 static hda_nid_t alc861_dac_nids[4] = {
13139         /* front, surround, clfe, side */
13140         0x03, 0x06, 0x05, 0x04
13141 };
13142
13143 static hda_nid_t alc660_dac_nids[3] = {
13144         /* front, clfe, surround */
13145         0x03, 0x05, 0x06
13146 };
13147
13148 static hda_nid_t alc861_adc_nids[1] = {
13149         /* ADC0-2 */
13150         0x08,
13151 };
13152
13153 static struct hda_input_mux alc861_capture_source = {
13154         .num_items = 5,
13155         .items = {
13156                 { "Mic", 0x0 },
13157                 { "Front Mic", 0x3 },
13158                 { "Line", 0x1 },
13159                 { "CD", 0x4 },
13160                 { "Mixer", 0x5 },
13161         },
13162 };
13163
13164 /* fill in the dac_nids table from the parsed pin configuration */
13165 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13166                                      const struct auto_pin_cfg *cfg)
13167 {
13168         int i;
13169         hda_nid_t nid;
13170
13171         spec->multiout.dac_nids = spec->private_dac_nids;
13172         for (i = 0; i < cfg->line_outs; i++) {
13173                 nid = cfg->line_out_pins[i];
13174                 if (nid) {
13175                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13176                                 continue;
13177                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13178                 }
13179         }
13180         spec->multiout.num_dacs = cfg->line_outs;
13181         return 0;
13182 }
13183
13184 /* add playback controls from the parsed DAC table */
13185 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13186                                              const struct auto_pin_cfg *cfg)
13187 {
13188         char name[32];
13189         static const char *chname[4] = {
13190                 "Front", "Surround", NULL /*CLFE*/, "Side"
13191         };
13192         hda_nid_t nid;
13193         int i, idx, err;
13194
13195         for (i = 0; i < cfg->line_outs; i++) {
13196                 nid = spec->multiout.dac_nids[i];
13197                 if (!nid)
13198                         continue;
13199                 if (nid == 0x05) {
13200                         /* Center/LFE */
13201                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13202                                           "Center Playback Switch",
13203                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13204                                                               HDA_OUTPUT));
13205                         if (err < 0)
13206                                 return err;
13207                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13208                                           "LFE Playback Switch",
13209                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13210                                                               HDA_OUTPUT));
13211                         if (err < 0)
13212                                 return err;
13213                 } else {
13214                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13215                              idx++)
13216                                 if (nid == alc861_dac_nids[idx])
13217                                         break;
13218                         sprintf(name, "%s Playback Switch", chname[idx]);
13219                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13220                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13221                                                               HDA_OUTPUT));
13222                         if (err < 0)
13223                                 return err;
13224                 }
13225         }
13226         return 0;
13227 }
13228
13229 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13230 {
13231         int err;
13232         hda_nid_t nid;
13233
13234         if (!pin)
13235                 return 0;
13236
13237         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13238                 nid = 0x03;
13239                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13240                                   "Headphone Playback Switch",
13241                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13242                 if (err < 0)
13243                         return err;
13244                 spec->multiout.hp_nid = nid;
13245         }
13246         return 0;
13247 }
13248
13249 /* create playback/capture controls for input pins */
13250 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13251                                                 const struct auto_pin_cfg *cfg)
13252 {
13253         struct hda_input_mux *imux = &spec->private_imux;
13254         int i, err, idx, idx1;
13255
13256         for (i = 0; i < AUTO_PIN_LAST; i++) {
13257                 switch (cfg->input_pins[i]) {
13258                 case 0x0c:
13259                         idx1 = 1;
13260                         idx = 2;        /* Line In */
13261                         break;
13262                 case 0x0f:
13263                         idx1 = 2;
13264                         idx = 2;        /* Line In */
13265                         break;
13266                 case 0x0d:
13267                         idx1 = 0;
13268                         idx = 1;        /* Mic In */
13269                         break;
13270                 case 0x10:
13271                         idx1 = 3;
13272                         idx = 1;        /* Mic In */
13273                         break;
13274                 case 0x11:
13275                         idx1 = 4;
13276                         idx = 0;        /* CD */
13277                         break;
13278                 default:
13279                         continue;
13280                 }
13281
13282                 err = new_analog_input(spec, cfg->input_pins[i],
13283                                        auto_pin_cfg_labels[i], idx, 0x15);
13284                 if (err < 0)
13285                         return err;
13286
13287                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13288                 imux->items[imux->num_items].index = idx1;
13289                 imux->num_items++;
13290         }
13291         return 0;
13292 }
13293
13294 static struct snd_kcontrol_new alc861_capture_mixer[] = {
13295         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13296         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13297
13298         {
13299                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13300                 /* The multiple "Capture Source" controls confuse alsamixer
13301                  * So call somewhat different..
13302                  */
13303                 /* .name = "Capture Source", */
13304                 .name = "Input Source",
13305                 .count = 1,
13306                 .info = alc_mux_enum_info,
13307                 .get = alc_mux_enum_get,
13308                 .put = alc_mux_enum_put,
13309         },
13310         { } /* end */
13311 };
13312
13313 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13314                                               hda_nid_t nid,
13315                                               int pin_type, int dac_idx)
13316 {
13317         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13318                             pin_type);
13319         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13320                             AMP_OUT_UNMUTE);
13321 }
13322
13323 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13324 {
13325         struct alc_spec *spec = codec->spec;
13326         int i;
13327
13328         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13329         for (i = 0; i < spec->autocfg.line_outs; i++) {
13330                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13331                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13332                 if (nid)
13333                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13334                                                           spec->multiout.dac_nids[i]);
13335         }
13336 }
13337
13338 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13339 {
13340         struct alc_spec *spec = codec->spec;
13341         hda_nid_t pin;
13342
13343         pin = spec->autocfg.hp_pins[0];
13344         if (pin) /* connect to front */
13345                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13346                                                   spec->multiout.dac_nids[0]);
13347         pin = spec->autocfg.speaker_pins[0];
13348         if (pin)
13349                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13350 }
13351
13352 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13353 {
13354         struct alc_spec *spec = codec->spec;
13355         int i;
13356
13357         for (i = 0; i < AUTO_PIN_LAST; i++) {
13358                 hda_nid_t nid = spec->autocfg.input_pins[i];
13359                 if (nid >= 0x0c && nid <= 0x11) {
13360                         snd_hda_codec_write(codec, nid, 0,
13361                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
13362                                             i <= AUTO_PIN_FRONT_MIC ?
13363                                             PIN_VREF80 : PIN_IN);
13364                 }
13365         }
13366 }
13367
13368 /* parse the BIOS configuration and set up the alc_spec */
13369 /* return 1 if successful, 0 if the proper config is not found,
13370  * or a negative error code
13371  */
13372 static int alc861_parse_auto_config(struct hda_codec *codec)
13373 {
13374         struct alc_spec *spec = codec->spec;
13375         int err;
13376         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13377
13378         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13379                                            alc861_ignore);
13380         if (err < 0)
13381                 return err;
13382         if (!spec->autocfg.line_outs)
13383                 return 0; /* can't find valid BIOS pin config */
13384
13385         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13386         if (err < 0)
13387                 return err;
13388         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13389         if (err < 0)
13390                 return err;
13391         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13392         if (err < 0)
13393                 return err;
13394         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13395         if (err < 0)
13396                 return err;
13397
13398         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13399
13400         if (spec->autocfg.dig_out_pin)
13401                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13402
13403         if (spec->kctl_alloc)
13404                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
13405
13406         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
13407
13408         spec->num_mux_defs = 1;
13409         spec->input_mux = &spec->private_imux;
13410
13411         spec->adc_nids = alc861_adc_nids;
13412         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13413         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
13414         spec->num_mixers++;
13415
13416         store_pin_configs(codec);
13417         return 1;
13418 }
13419
13420 /* additional initialization for auto-configuration model */
13421 static void alc861_auto_init(struct hda_codec *codec)
13422 {
13423         struct alc_spec *spec = codec->spec;
13424         alc861_auto_init_multi_out(codec);
13425         alc861_auto_init_hp_out(codec);
13426         alc861_auto_init_analog_input(codec);
13427         if (spec->unsol_event)
13428                 alc_inithook(codec);
13429 }
13430
13431 #ifdef CONFIG_SND_HDA_POWER_SAVE
13432 static struct hda_amp_list alc861_loopbacks[] = {
13433         { 0x15, HDA_INPUT, 0 },
13434         { 0x15, HDA_INPUT, 1 },
13435         { 0x15, HDA_INPUT, 2 },
13436         { 0x15, HDA_INPUT, 3 },
13437         { } /* end */
13438 };
13439 #endif
13440
13441
13442 /*
13443  * configuration and preset
13444  */
13445 static const char *alc861_models[ALC861_MODEL_LAST] = {
13446         [ALC861_3ST]            = "3stack",
13447         [ALC660_3ST]            = "3stack-660",
13448         [ALC861_3ST_DIG]        = "3stack-dig",
13449         [ALC861_6ST_DIG]        = "6stack-dig",
13450         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13451         [ALC861_TOSHIBA]        = "toshiba",
13452         [ALC861_ASUS]           = "asus",
13453         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13454         [ALC861_AUTO]           = "auto",
13455 };
13456
13457 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13458         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13459         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13460         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13461         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13462         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13463         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13464         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13465         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13466          *        Any other models that need this preset?
13467          */
13468         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13469         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13470         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13471         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13472         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13473         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13474         /* FIXME: the below seems conflict */
13475         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13476         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13477         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13478         {}
13479 };
13480
13481 static struct alc_config_preset alc861_presets[] = {
13482         [ALC861_3ST] = {
13483                 .mixers = { alc861_3ST_mixer },
13484                 .init_verbs = { alc861_threestack_init_verbs },
13485                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13486                 .dac_nids = alc861_dac_nids,
13487                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13488                 .channel_mode = alc861_threestack_modes,
13489                 .need_dac_fix = 1,
13490                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13491                 .adc_nids = alc861_adc_nids,
13492                 .input_mux = &alc861_capture_source,
13493         },
13494         [ALC861_3ST_DIG] = {
13495                 .mixers = { alc861_base_mixer },
13496                 .init_verbs = { alc861_threestack_init_verbs },
13497                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13498                 .dac_nids = alc861_dac_nids,
13499                 .dig_out_nid = ALC861_DIGOUT_NID,
13500                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13501                 .channel_mode = alc861_threestack_modes,
13502                 .need_dac_fix = 1,
13503                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13504                 .adc_nids = alc861_adc_nids,
13505                 .input_mux = &alc861_capture_source,
13506         },
13507         [ALC861_6ST_DIG] = {
13508                 .mixers = { alc861_base_mixer },
13509                 .init_verbs = { alc861_base_init_verbs },
13510                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13511                 .dac_nids = alc861_dac_nids,
13512                 .dig_out_nid = ALC861_DIGOUT_NID,
13513                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13514                 .channel_mode = alc861_8ch_modes,
13515                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13516                 .adc_nids = alc861_adc_nids,
13517                 .input_mux = &alc861_capture_source,
13518         },
13519         [ALC660_3ST] = {
13520                 .mixers = { alc861_3ST_mixer },
13521                 .init_verbs = { alc861_threestack_init_verbs },
13522                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13523                 .dac_nids = alc660_dac_nids,
13524                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13525                 .channel_mode = alc861_threestack_modes,
13526                 .need_dac_fix = 1,
13527                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13528                 .adc_nids = alc861_adc_nids,
13529                 .input_mux = &alc861_capture_source,
13530         },
13531         [ALC861_UNIWILL_M31] = {
13532                 .mixers = { alc861_uniwill_m31_mixer },
13533                 .init_verbs = { alc861_uniwill_m31_init_verbs },
13534                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13535                 .dac_nids = alc861_dac_nids,
13536                 .dig_out_nid = ALC861_DIGOUT_NID,
13537                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13538                 .channel_mode = alc861_uniwill_m31_modes,
13539                 .need_dac_fix = 1,
13540                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13541                 .adc_nids = alc861_adc_nids,
13542                 .input_mux = &alc861_capture_source,
13543         },
13544         [ALC861_TOSHIBA] = {
13545                 .mixers = { alc861_toshiba_mixer },
13546                 .init_verbs = { alc861_base_init_verbs,
13547                                 alc861_toshiba_init_verbs },
13548                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13549                 .dac_nids = alc861_dac_nids,
13550                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13551                 .channel_mode = alc883_3ST_2ch_modes,
13552                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13553                 .adc_nids = alc861_adc_nids,
13554                 .input_mux = &alc861_capture_source,
13555                 .unsol_event = alc861_toshiba_unsol_event,
13556                 .init_hook = alc861_toshiba_automute,
13557         },
13558         [ALC861_ASUS] = {
13559                 .mixers = { alc861_asus_mixer },
13560                 .init_verbs = { alc861_asus_init_verbs },
13561                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13562                 .dac_nids = alc861_dac_nids,
13563                 .dig_out_nid = ALC861_DIGOUT_NID,
13564                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13565                 .channel_mode = alc861_asus_modes,
13566                 .need_dac_fix = 1,
13567                 .hp_nid = 0x06,
13568                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13569                 .adc_nids = alc861_adc_nids,
13570                 .input_mux = &alc861_capture_source,
13571         },
13572         [ALC861_ASUS_LAPTOP] = {
13573                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13574                 .init_verbs = { alc861_asus_init_verbs,
13575                                 alc861_asus_laptop_init_verbs },
13576                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13577                 .dac_nids = alc861_dac_nids,
13578                 .dig_out_nid = ALC861_DIGOUT_NID,
13579                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13580                 .channel_mode = alc883_3ST_2ch_modes,
13581                 .need_dac_fix = 1,
13582                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13583                 .adc_nids = alc861_adc_nids,
13584                 .input_mux = &alc861_capture_source,
13585         },
13586 };
13587
13588
13589 static int patch_alc861(struct hda_codec *codec)
13590 {
13591         struct alc_spec *spec;
13592         int board_config;
13593         int err;
13594
13595         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13596         if (spec == NULL)
13597                 return -ENOMEM;
13598
13599         codec->spec = spec;
13600
13601         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
13602                                                   alc861_models,
13603                                                   alc861_cfg_tbl);
13604
13605         if (board_config < 0) {
13606                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
13607                        "trying auto-probe from BIOS...\n");
13608                 board_config = ALC861_AUTO;
13609         }
13610
13611         if (board_config == ALC861_AUTO) {
13612                 /* automatic parse from the BIOS config */
13613                 err = alc861_parse_auto_config(codec);
13614                 if (err < 0) {
13615                         alc_free(codec);
13616                         return err;
13617                 } else if (!err) {
13618                         printk(KERN_INFO
13619                                "hda_codec: Cannot set up configuration "
13620                                "from BIOS.  Using base mode...\n");
13621                    board_config = ALC861_3ST_DIG;
13622                 }
13623         }
13624
13625         if (board_config != ALC861_AUTO)
13626                 setup_preset(spec, &alc861_presets[board_config]);
13627
13628         spec->stream_name_analog = "ALC861 Analog";
13629         spec->stream_analog_playback = &alc861_pcm_analog_playback;
13630         spec->stream_analog_capture = &alc861_pcm_analog_capture;
13631
13632         spec->stream_name_digital = "ALC861 Digital";
13633         spec->stream_digital_playback = &alc861_pcm_digital_playback;
13634         spec->stream_digital_capture = &alc861_pcm_digital_capture;
13635
13636         spec->vmaster_nid = 0x03;
13637
13638         codec->patch_ops = alc_patch_ops;
13639         if (board_config == ALC861_AUTO)
13640                 spec->init_hook = alc861_auto_init;
13641 #ifdef CONFIG_SND_HDA_POWER_SAVE
13642         if (!spec->loopback.amplist)
13643                 spec->loopback.amplist = alc861_loopbacks;
13644 #endif
13645
13646         return 0;
13647 }
13648
13649 /*
13650  * ALC861-VD support
13651  *
13652  * Based on ALC882
13653  *
13654  * In addition, an independent DAC
13655  */
13656 #define ALC861VD_DIGOUT_NID     0x06
13657
13658 static hda_nid_t alc861vd_dac_nids[4] = {
13659         /* front, surr, clfe, side surr */
13660         0x02, 0x03, 0x04, 0x05
13661 };
13662
13663 /* dac_nids for ALC660vd are in a different order - according to
13664  * Realtek's driver.
13665  * This should probably tesult in a different mixer for 6stack models
13666  * of ALC660vd codecs, but for now there is only 3stack mixer
13667  * - and it is the same as in 861vd.
13668  * adc_nids in ALC660vd are (is) the same as in 861vd
13669  */
13670 static hda_nid_t alc660vd_dac_nids[3] = {
13671         /* front, rear, clfe, rear_surr */
13672         0x02, 0x04, 0x03
13673 };
13674
13675 static hda_nid_t alc861vd_adc_nids[1] = {
13676         /* ADC0 */
13677         0x09,
13678 };
13679
13680 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
13681
13682 /* input MUX */
13683 /* FIXME: should be a matrix-type input source selection */
13684 static struct hda_input_mux alc861vd_capture_source = {
13685         .num_items = 4,
13686         .items = {
13687                 { "Mic", 0x0 },
13688                 { "Front Mic", 0x1 },
13689                 { "Line", 0x2 },
13690                 { "CD", 0x4 },
13691         },
13692 };
13693
13694 static struct hda_input_mux alc861vd_dallas_capture_source = {
13695         .num_items = 2,
13696         .items = {
13697                 { "Ext Mic", 0x0 },
13698                 { "Int Mic", 0x1 },
13699         },
13700 };
13701
13702 static struct hda_input_mux alc861vd_hp_capture_source = {
13703         .num_items = 2,
13704         .items = {
13705                 { "Front Mic", 0x0 },
13706                 { "ATAPI Mic", 0x1 },
13707         },
13708 };
13709
13710 #define alc861vd_mux_enum_info alc_mux_enum_info
13711 #define alc861vd_mux_enum_get alc_mux_enum_get
13712 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
13713 #define alc861vd_mux_enum_put alc882_mux_enum_put
13714
13715 /*
13716  * 2ch mode
13717  */
13718 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
13719         { 2, NULL }
13720 };
13721
13722 /*
13723  * 6ch mode
13724  */
13725 static struct hda_verb alc861vd_6stack_ch6_init[] = {
13726         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13727         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13728         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13729         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13730         { } /* end */
13731 };
13732
13733 /*
13734  * 8ch mode
13735  */
13736 static struct hda_verb alc861vd_6stack_ch8_init[] = {
13737         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13738         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13739         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13740         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
13741         { } /* end */
13742 };
13743
13744 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
13745         { 6, alc861vd_6stack_ch6_init },
13746         { 8, alc861vd_6stack_ch8_init },
13747 };
13748
13749 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
13750         {
13751                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13752                 .name = "Channel Mode",
13753                 .info = alc_ch_mode_info,
13754                 .get = alc_ch_mode_get,
13755                 .put = alc_ch_mode_put,
13756         },
13757         { } /* end */
13758 };
13759
13760 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
13761         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13762         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13763
13764         {
13765                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13766                 /* The multiple "Capture Source" controls confuse alsamixer
13767                  * So call somewhat different..
13768                  */
13769                 /* .name = "Capture Source", */
13770                 .name = "Input Source",
13771                 .count = 1,
13772                 .info = alc861vd_mux_enum_info,
13773                 .get = alc861vd_mux_enum_get,
13774                 .put = alc861vd_mux_enum_put,
13775         },
13776         { } /* end */
13777 };
13778
13779 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
13780  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
13781  */
13782 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
13783         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13784         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13785
13786         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13787         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
13788
13789         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
13790                                 HDA_OUTPUT),
13791         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
13792                                 HDA_OUTPUT),
13793         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13794         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
13795
13796         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
13797         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
13798
13799         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13800
13801         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13802         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13803         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13804
13805         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13806         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13807         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13808
13809         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13810         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13811
13812         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13813         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13814
13815         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13816         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13817
13818         { } /* end */
13819 };
13820
13821 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
13822         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13823         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13824
13825         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13826
13827         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13828         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13829         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13830
13831         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13832         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13833         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13834
13835         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13836         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13837
13838         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13839         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13840
13841         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
13842         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
13843
13844         { } /* end */
13845 };
13846
13847 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
13848         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13849         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
13850         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13851
13852         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
13853
13854         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13855         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13856         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13857
13858         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13859         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13860         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13861
13862         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
13863         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
13864
13865         { } /* end */
13866 };
13867
13868 /* Pin assignment: Speaker=0x14, HP = 0x15,
13869  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
13870  */
13871 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
13872         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13873         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
13874         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13875         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13876         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13877         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13878         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13879         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13880         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13881         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13882         HDA_CODEC_VOLUME("PC Beep Volume", 0x0b, 0x05, HDA_INPUT),
13883         HDA_CODEC_MUTE("PC Beep Switch", 0x0b, 0x05, HDA_INPUT),
13884         { } /* end */
13885 };
13886
13887 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
13888  *                 Front Mic=0x18, ATAPI Mic = 0x19,
13889  */
13890 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
13891         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13892         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
13893         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13894         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
13895         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13896         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13897         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
13898         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
13899
13900         { } /* end */
13901 };
13902
13903 /*
13904  * generic initialization of ADC, input mixers and output mixers
13905  */
13906 static struct hda_verb alc861vd_volume_init_verbs[] = {
13907         /*
13908          * Unmute ADC0 and set the default input to mic-in
13909          */
13910         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
13911         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13912
13913         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
13914          * the analog-loopback mixer widget
13915          */
13916         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13917         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13918         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13919         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13920         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13921         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13922
13923         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
13924         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13925         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13926         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13927         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
13928
13929         /*
13930          * Set up output mixers (0x02 - 0x05)
13931          */
13932         /* set vol=0 to output mixers */
13933         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13934         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13935         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13936         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13937
13938         /* set up input amps for analog loopback */
13939         /* Amp Indices: DAC = 0, mixer = 1 */
13940         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13941         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13942         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13943         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13944         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13945         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13946         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13947         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13948
13949         { }
13950 };
13951
13952 /*
13953  * 3-stack pin configuration:
13954  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
13955  */
13956 static struct hda_verb alc861vd_3stack_init_verbs[] = {
13957         /*
13958          * Set pin mode and muting
13959          */
13960         /* set front pin widgets 0x14 for output */
13961         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13962         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13963         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13964
13965         /* Mic (rear) pin: input vref at 80% */
13966         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13967         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13968         /* Front Mic pin: input vref at 80% */
13969         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13970         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13971         /* Line In pin: input */
13972         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13973         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13974         /* Line-2 In: Headphone output (output 0 - 0x0c) */
13975         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13976         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13977         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
13978         /* CD pin widget for input */
13979         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13980
13981         { }
13982 };
13983
13984 /*
13985  * 6-stack pin configuration:
13986  */
13987 static struct hda_verb alc861vd_6stack_init_verbs[] = {
13988         /*
13989          * Set pin mode and muting
13990          */
13991         /* set front pin widgets 0x14 for output */
13992         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13993         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13994         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13995
13996         /* Rear Pin: output 1 (0x0d) */
13997         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13998         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13999         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14000         /* CLFE Pin: output 2 (0x0e) */
14001         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14002         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14003         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14004         /* Side Pin: output 3 (0x0f) */
14005         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14006         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14007         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14008
14009         /* Mic (rear) pin: input vref at 80% */
14010         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14011         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14012         /* Front Mic pin: input vref at 80% */
14013         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14014         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14015         /* Line In pin: input */
14016         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14017         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14018         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14019         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14020         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14021         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14022         /* CD pin widget for input */
14023         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14024
14025         { }
14026 };
14027
14028 static struct hda_verb alc861vd_eapd_verbs[] = {
14029         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14030         { }
14031 };
14032
14033 static struct hda_verb alc660vd_eapd_verbs[] = {
14034         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14035         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14036         { }
14037 };
14038
14039 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14040         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14041         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14042         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14043         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14044         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14045         {}
14046 };
14047
14048 /* toggle speaker-output according to the hp-jack state */
14049 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14050 {
14051         unsigned int present;
14052         unsigned char bits;
14053
14054         present = snd_hda_codec_read(codec, 0x1b, 0,
14055                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14056         bits = present ? HDA_AMP_MUTE : 0;
14057         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14058                                  HDA_AMP_MUTE, bits);
14059 }
14060
14061 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14062 {
14063         unsigned int present;
14064         unsigned char bits;
14065
14066         present = snd_hda_codec_read(codec, 0x18, 0,
14067                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14068         bits = present ? HDA_AMP_MUTE : 0;
14069         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14070                                  HDA_AMP_MUTE, bits);
14071 }
14072
14073 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14074 {
14075         alc861vd_lenovo_hp_automute(codec);
14076         alc861vd_lenovo_mic_automute(codec);
14077 }
14078
14079 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14080                                         unsigned int res)
14081 {
14082         switch (res >> 26) {
14083         case ALC880_HP_EVENT:
14084                 alc861vd_lenovo_hp_automute(codec);
14085                 break;
14086         case ALC880_MIC_EVENT:
14087                 alc861vd_lenovo_mic_automute(codec);
14088                 break;
14089         }
14090 }
14091
14092 static struct hda_verb alc861vd_dallas_verbs[] = {
14093         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14094         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14095         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14096         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14097
14098         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14099         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14100         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14101         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14102         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14103         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14104         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14105         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14106
14107         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14108         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14109         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14110         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14111         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14112         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14113         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14114         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14115
14116         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14117         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14118         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14119         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14120         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14121         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14122         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14123         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14124
14125         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14126         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14127         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14128         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14129
14130         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14131         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14132         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14133
14134         { } /* end */
14135 };
14136
14137 /* toggle speaker-output according to the hp-jack state */
14138 static void alc861vd_dallas_automute(struct hda_codec *codec)
14139 {
14140         unsigned int present;
14141
14142         present = snd_hda_codec_read(codec, 0x15, 0,
14143                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14144         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14145                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14146 }
14147
14148 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14149 {
14150         if ((res >> 26) == ALC880_HP_EVENT)
14151                 alc861vd_dallas_automute(codec);
14152 }
14153
14154 #ifdef CONFIG_SND_HDA_POWER_SAVE
14155 #define alc861vd_loopbacks      alc880_loopbacks
14156 #endif
14157
14158 /* pcm configuration: identiacal with ALC880 */
14159 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14160 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14161 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14162 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14163
14164 /*
14165  * configuration and preset
14166  */
14167 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14168         [ALC660VD_3ST]          = "3stack-660",
14169         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14170         [ALC861VD_3ST]          = "3stack",
14171         [ALC861VD_3ST_DIG]      = "3stack-digout",
14172         [ALC861VD_6ST_DIG]      = "6stack-digout",
14173         [ALC861VD_LENOVO]       = "lenovo",
14174         [ALC861VD_DALLAS]       = "dallas",
14175         [ALC861VD_HP]           = "hp",
14176         [ALC861VD_AUTO]         = "auto",
14177 };
14178
14179 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14180         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14181         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14182         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14183         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14184         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
14185         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14186         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14187         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14188         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14189         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14190         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14191         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14192         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14193         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo", ALC861VD_LENOVO),
14194         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo 3000 C200", ALC861VD_LENOVO),
14195         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 N200", ALC861VD_LENOVO),
14196         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14197         {}
14198 };
14199
14200 static struct alc_config_preset alc861vd_presets[] = {
14201         [ALC660VD_3ST] = {
14202                 .mixers = { alc861vd_3st_mixer },
14203                 .init_verbs = { alc861vd_volume_init_verbs,
14204                                  alc861vd_3stack_init_verbs },
14205                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14206                 .dac_nids = alc660vd_dac_nids,
14207                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14208                 .channel_mode = alc861vd_3stack_2ch_modes,
14209                 .input_mux = &alc861vd_capture_source,
14210         },
14211         [ALC660VD_3ST_DIG] = {
14212                 .mixers = { alc861vd_3st_mixer },
14213                 .init_verbs = { alc861vd_volume_init_verbs,
14214                                  alc861vd_3stack_init_verbs },
14215                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14216                 .dac_nids = alc660vd_dac_nids,
14217                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14218                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14219                 .channel_mode = alc861vd_3stack_2ch_modes,
14220                 .input_mux = &alc861vd_capture_source,
14221         },
14222         [ALC861VD_3ST] = {
14223                 .mixers = { alc861vd_3st_mixer },
14224                 .init_verbs = { alc861vd_volume_init_verbs,
14225                                  alc861vd_3stack_init_verbs },
14226                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14227                 .dac_nids = alc861vd_dac_nids,
14228                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14229                 .channel_mode = alc861vd_3stack_2ch_modes,
14230                 .input_mux = &alc861vd_capture_source,
14231         },
14232         [ALC861VD_3ST_DIG] = {
14233                 .mixers = { alc861vd_3st_mixer },
14234                 .init_verbs = { alc861vd_volume_init_verbs,
14235                                  alc861vd_3stack_init_verbs },
14236                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14237                 .dac_nids = alc861vd_dac_nids,
14238                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14239                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14240                 .channel_mode = alc861vd_3stack_2ch_modes,
14241                 .input_mux = &alc861vd_capture_source,
14242         },
14243         [ALC861VD_6ST_DIG] = {
14244                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14245                 .init_verbs = { alc861vd_volume_init_verbs,
14246                                 alc861vd_6stack_init_verbs },
14247                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14248                 .dac_nids = alc861vd_dac_nids,
14249                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14250                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14251                 .channel_mode = alc861vd_6stack_modes,
14252                 .input_mux = &alc861vd_capture_source,
14253         },
14254         [ALC861VD_LENOVO] = {
14255                 .mixers = { alc861vd_lenovo_mixer },
14256                 .init_verbs = { alc861vd_volume_init_verbs,
14257                                 alc861vd_3stack_init_verbs,
14258                                 alc861vd_eapd_verbs,
14259                                 alc861vd_lenovo_unsol_verbs },
14260                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14261                 .dac_nids = alc660vd_dac_nids,
14262                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14263                 .channel_mode = alc861vd_3stack_2ch_modes,
14264                 .input_mux = &alc861vd_capture_source,
14265                 .unsol_event = alc861vd_lenovo_unsol_event,
14266                 .init_hook = alc861vd_lenovo_automute,
14267         },
14268         [ALC861VD_DALLAS] = {
14269                 .mixers = { alc861vd_dallas_mixer },
14270                 .init_verbs = { alc861vd_dallas_verbs },
14271                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14272                 .dac_nids = alc861vd_dac_nids,
14273                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14274                 .channel_mode = alc861vd_3stack_2ch_modes,
14275                 .input_mux = &alc861vd_dallas_capture_source,
14276                 .unsol_event = alc861vd_dallas_unsol_event,
14277                 .init_hook = alc861vd_dallas_automute,
14278         },
14279         [ALC861VD_HP] = {
14280                 .mixers = { alc861vd_hp_mixer },
14281                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14282                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14283                 .dac_nids = alc861vd_dac_nids,
14284                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14285                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14286                 .channel_mode = alc861vd_3stack_2ch_modes,
14287                 .input_mux = &alc861vd_hp_capture_source,
14288                 .unsol_event = alc861vd_dallas_unsol_event,
14289                 .init_hook = alc861vd_dallas_automute,
14290         },
14291 };
14292
14293 /*
14294  * BIOS auto configuration
14295  */
14296 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14297                                 hda_nid_t nid, int pin_type, int dac_idx)
14298 {
14299         alc_set_pin_output(codec, nid, pin_type);
14300 }
14301
14302 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14303 {
14304         struct alc_spec *spec = codec->spec;
14305         int i;
14306
14307         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14308         for (i = 0; i <= HDA_SIDE; i++) {
14309                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14310                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14311                 if (nid)
14312                         alc861vd_auto_set_output_and_unmute(codec, nid,
14313                                                             pin_type, i);
14314         }
14315 }
14316
14317
14318 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14319 {
14320         struct alc_spec *spec = codec->spec;
14321         hda_nid_t pin;
14322
14323         pin = spec->autocfg.hp_pins[0];
14324         if (pin) /* connect to front and  use dac 0 */
14325                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14326         pin = spec->autocfg.speaker_pins[0];
14327         if (pin)
14328                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14329 }
14330
14331 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14332 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14333
14334 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14335 {
14336         struct alc_spec *spec = codec->spec;
14337         int i;
14338
14339         for (i = 0; i < AUTO_PIN_LAST; i++) {
14340                 hda_nid_t nid = spec->autocfg.input_pins[i];
14341                 if (alc861vd_is_input_pin(nid)) {
14342                         snd_hda_codec_write(codec, nid, 0,
14343                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
14344                                         i <= AUTO_PIN_FRONT_MIC ?
14345                                                         PIN_VREF80 : PIN_IN);
14346                         if (nid != ALC861VD_PIN_CD_NID)
14347                                 snd_hda_codec_write(codec, nid, 0,
14348                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14349                                                 AMP_OUT_MUTE);
14350                 }
14351         }
14352 }
14353
14354 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14355
14356 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14357 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14358
14359 /* add playback controls from the parsed DAC table */
14360 /* Based on ALC880 version. But ALC861VD has separate,
14361  * different NIDs for mute/unmute switch and volume control */
14362 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14363                                              const struct auto_pin_cfg *cfg)
14364 {
14365         char name[32];
14366         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14367         hda_nid_t nid_v, nid_s;
14368         int i, err;
14369
14370         for (i = 0; i < cfg->line_outs; i++) {
14371                 if (!spec->multiout.dac_nids[i])
14372                         continue;
14373                 nid_v = alc861vd_idx_to_mixer_vol(
14374                                 alc880_dac_to_idx(
14375                                         spec->multiout.dac_nids[i]));
14376                 nid_s = alc861vd_idx_to_mixer_switch(
14377                                 alc880_dac_to_idx(
14378                                         spec->multiout.dac_nids[i]));
14379
14380                 if (i == 2) {
14381                         /* Center/LFE */
14382                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14383                                           "Center Playback Volume",
14384                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14385                                                               HDA_OUTPUT));
14386                         if (err < 0)
14387                                 return err;
14388                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14389                                           "LFE Playback Volume",
14390                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14391                                                               HDA_OUTPUT));
14392                         if (err < 0)
14393                                 return err;
14394                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14395                                           "Center Playback Switch",
14396                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14397                                                               HDA_INPUT));
14398                         if (err < 0)
14399                                 return err;
14400                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14401                                           "LFE Playback Switch",
14402                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14403                                                               HDA_INPUT));
14404                         if (err < 0)
14405                                 return err;
14406                 } else {
14407                         sprintf(name, "%s Playback Volume", chname[i]);
14408                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14409                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14410                                                               HDA_OUTPUT));
14411                         if (err < 0)
14412                                 return err;
14413                         sprintf(name, "%s Playback Switch", chname[i]);
14414                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14415                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14416                                                               HDA_INPUT));
14417                         if (err < 0)
14418                                 return err;
14419                 }
14420         }
14421         return 0;
14422 }
14423
14424 /* add playback controls for speaker and HP outputs */
14425 /* Based on ALC880 version. But ALC861VD has separate,
14426  * different NIDs for mute/unmute switch and volume control */
14427 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14428                                         hda_nid_t pin, const char *pfx)
14429 {
14430         hda_nid_t nid_v, nid_s;
14431         int err;
14432         char name[32];
14433
14434         if (!pin)
14435                 return 0;
14436
14437         if (alc880_is_fixed_pin(pin)) {
14438                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14439                 /* specify the DAC as the extra output */
14440                 if (!spec->multiout.hp_nid)
14441                         spec->multiout.hp_nid = nid_v;
14442                 else
14443                         spec->multiout.extra_out_nid[0] = nid_v;
14444                 /* control HP volume/switch on the output mixer amp */
14445                 nid_v = alc861vd_idx_to_mixer_vol(
14446                                 alc880_fixed_pin_idx(pin));
14447                 nid_s = alc861vd_idx_to_mixer_switch(
14448                                 alc880_fixed_pin_idx(pin));
14449
14450                 sprintf(name, "%s Playback Volume", pfx);
14451                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14452                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14453                 if (err < 0)
14454                         return err;
14455                 sprintf(name, "%s Playback Switch", pfx);
14456                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14457                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14458                 if (err < 0)
14459                         return err;
14460         } else if (alc880_is_multi_pin(pin)) {
14461                 /* set manual connection */
14462                 /* we have only a switch on HP-out PIN */
14463                 sprintf(name, "%s Playback Switch", pfx);
14464                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14465                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14466                 if (err < 0)
14467                         return err;
14468         }
14469         return 0;
14470 }
14471
14472 /* parse the BIOS configuration and set up the alc_spec
14473  * return 1 if successful, 0 if the proper config is not found,
14474  * or a negative error code
14475  * Based on ALC880 version - had to change it to override
14476  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14477 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14478 {
14479         struct alc_spec *spec = codec->spec;
14480         int err;
14481         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14482
14483         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14484                                            alc861vd_ignore);
14485         if (err < 0)
14486                 return err;
14487         if (!spec->autocfg.line_outs)
14488                 return 0; /* can't find valid BIOS pin config */
14489
14490         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14491         if (err < 0)
14492                 return err;
14493         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14494         if (err < 0)
14495                 return err;
14496         err = alc861vd_auto_create_extra_out(spec,
14497                                              spec->autocfg.speaker_pins[0],
14498                                              "Speaker");
14499         if (err < 0)
14500                 return err;
14501         err = alc861vd_auto_create_extra_out(spec,
14502                                              spec->autocfg.hp_pins[0],
14503                                              "Headphone");
14504         if (err < 0)
14505                 return err;
14506         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14507         if (err < 0)
14508                 return err;
14509
14510         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14511
14512         if (spec->autocfg.dig_out_pin)
14513                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14514
14515         if (spec->kctl_alloc)
14516                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
14517
14518         spec->init_verbs[spec->num_init_verbs++]
14519                 = alc861vd_volume_init_verbs;
14520
14521         spec->num_mux_defs = 1;
14522         spec->input_mux = &spec->private_imux;
14523
14524         err = alc_auto_add_mic_boost(codec);
14525         if (err < 0)
14526                 return err;
14527
14528         store_pin_configs(codec);
14529         return 1;
14530 }
14531
14532 /* additional initialization for auto-configuration model */
14533 static void alc861vd_auto_init(struct hda_codec *codec)
14534 {
14535         struct alc_spec *spec = codec->spec;
14536         alc861vd_auto_init_multi_out(codec);
14537         alc861vd_auto_init_hp_out(codec);
14538         alc861vd_auto_init_analog_input(codec);
14539         alc861vd_auto_init_input_src(codec);
14540         if (spec->unsol_event)
14541                 alc_inithook(codec);
14542 }
14543
14544 static int patch_alc861vd(struct hda_codec *codec)
14545 {
14546         struct alc_spec *spec;
14547         int err, board_config;
14548
14549         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14550         if (spec == NULL)
14551                 return -ENOMEM;
14552
14553         codec->spec = spec;
14554
14555         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14556                                                   alc861vd_models,
14557                                                   alc861vd_cfg_tbl);
14558
14559         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14560                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
14561                         "ALC861VD, trying auto-probe from BIOS...\n");
14562                 board_config = ALC861VD_AUTO;
14563         }
14564
14565         if (board_config == ALC861VD_AUTO) {
14566                 /* automatic parse from the BIOS config */
14567                 err = alc861vd_parse_auto_config(codec);
14568                 if (err < 0) {
14569                         alc_free(codec);
14570                         return err;
14571                 } else if (!err) {
14572                         printk(KERN_INFO
14573                                "hda_codec: Cannot set up configuration "
14574                                "from BIOS.  Using base mode...\n");
14575                         board_config = ALC861VD_3ST;
14576                 }
14577         }
14578
14579         if (board_config != ALC861VD_AUTO)
14580                 setup_preset(spec, &alc861vd_presets[board_config]);
14581
14582         if (codec->vendor_id == 0x10ec0660) {
14583                 spec->stream_name_analog = "ALC660-VD Analog";
14584                 spec->stream_name_digital = "ALC660-VD Digital";
14585                 /* always turn on EAPD */
14586                 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
14587         } else {
14588                 spec->stream_name_analog = "ALC861VD Analog";
14589                 spec->stream_name_digital = "ALC861VD Digital";
14590         }
14591
14592         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14593         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14594
14595         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14596         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14597
14598         spec->adc_nids = alc861vd_adc_nids;
14599         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14600         spec->capsrc_nids = alc861vd_capsrc_nids;
14601
14602         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
14603         spec->num_mixers++;
14604
14605         spec->vmaster_nid = 0x02;
14606
14607         codec->patch_ops = alc_patch_ops;
14608
14609         if (board_config == ALC861VD_AUTO)
14610                 spec->init_hook = alc861vd_auto_init;
14611 #ifdef CONFIG_SND_HDA_POWER_SAVE
14612         if (!spec->loopback.amplist)
14613                 spec->loopback.amplist = alc861vd_loopbacks;
14614 #endif
14615
14616         return 0;
14617 }
14618
14619 /*
14620  * ALC662 support
14621  *
14622  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
14623  * configuration.  Each pin widget can choose any input DACs and a mixer.
14624  * Each ADC is connected from a mixer of all inputs.  This makes possible
14625  * 6-channel independent captures.
14626  *
14627  * In addition, an independent DAC for the multi-playback (not used in this
14628  * driver yet).
14629  */
14630 #define ALC662_DIGOUT_NID       0x06
14631 #define ALC662_DIGIN_NID        0x0a
14632
14633 static hda_nid_t alc662_dac_nids[4] = {
14634         /* front, rear, clfe, rear_surr */
14635         0x02, 0x03, 0x04
14636 };
14637
14638 static hda_nid_t alc662_adc_nids[1] = {
14639         /* ADC1-2 */
14640         0x09,
14641 };
14642
14643 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
14644
14645 /* input MUX */
14646 /* FIXME: should be a matrix-type input source selection */
14647 static struct hda_input_mux alc662_capture_source = {
14648         .num_items = 4,
14649         .items = {
14650                 { "Mic", 0x0 },
14651                 { "Front Mic", 0x1 },
14652                 { "Line", 0x2 },
14653                 { "CD", 0x4 },
14654         },
14655 };
14656
14657 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
14658         .num_items = 2,
14659         .items = {
14660                 { "Mic", 0x1 },
14661                 { "Line", 0x2 },
14662         },
14663 };
14664
14665 static struct hda_input_mux alc662_eeepc_capture_source = {
14666         .num_items = 2,
14667         .items = {
14668                 { "i-Mic", 0x1 },
14669                 { "e-Mic", 0x0 },
14670         },
14671 };
14672
14673 static struct hda_input_mux alc663_capture_source = {
14674         .num_items = 3,
14675         .items = {
14676                 { "Mic", 0x0 },
14677                 { "Front Mic", 0x1 },
14678                 { "Line", 0x2 },
14679         },
14680 };
14681
14682 static struct hda_input_mux alc663_m51va_capture_source = {
14683         .num_items = 2,
14684         .items = {
14685                 { "Ext-Mic", 0x0 },
14686                 { "D-Mic", 0x9 },
14687         },
14688 };
14689
14690 #define alc662_mux_enum_info alc_mux_enum_info
14691 #define alc662_mux_enum_get alc_mux_enum_get
14692 #define alc662_mux_enum_put alc882_mux_enum_put
14693
14694 /*
14695  * 2ch mode
14696  */
14697 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
14698         { 2, NULL }
14699 };
14700
14701 /*
14702  * 2ch mode
14703  */
14704 static struct hda_verb alc662_3ST_ch2_init[] = {
14705         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
14706         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14707         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
14708         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
14709         { } /* end */
14710 };
14711
14712 /*
14713  * 6ch mode
14714  */
14715 static struct hda_verb alc662_3ST_ch6_init[] = {
14716         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14717         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14718         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
14719         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14720         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
14721         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
14722         { } /* end */
14723 };
14724
14725 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
14726         { 2, alc662_3ST_ch2_init },
14727         { 6, alc662_3ST_ch6_init },
14728 };
14729
14730 /*
14731  * 2ch mode
14732  */
14733 static struct hda_verb alc662_sixstack_ch6_init[] = {
14734         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14735         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14736         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14737         { } /* end */
14738 };
14739
14740 /*
14741  * 6ch mode
14742  */
14743 static struct hda_verb alc662_sixstack_ch8_init[] = {
14744         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14745         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14746         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14747         { } /* end */
14748 };
14749
14750 static struct hda_channel_mode alc662_5stack_modes[2] = {
14751         { 2, alc662_sixstack_ch6_init },
14752         { 6, alc662_sixstack_ch8_init },
14753 };
14754
14755 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14756  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14757  */
14758
14759 static struct snd_kcontrol_new alc662_base_mixer[] = {
14760         /* output mixer control */
14761         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
14762         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14763         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
14764         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14765         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14766         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14767         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14768         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14769         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14770
14771         /*Input mixer control */
14772         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
14773         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
14774         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
14775         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
14776         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
14777         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
14778         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
14779         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
14780         { } /* end */
14781 };
14782
14783 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
14784         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14785         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14786         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14787         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14788         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14789         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14790         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14791         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14792         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14793         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14794         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14795         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14796         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14797         { } /* end */
14798 };
14799
14800 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
14801         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14802         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
14803         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14804         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
14805         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14806         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14807         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
14808         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
14809         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14810         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14811         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14812         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14813         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14814         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14815         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14816         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14817         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14818         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
14819         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
14820         { } /* end */
14821 };
14822
14823 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
14824         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14825         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
14826         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14827         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
14828         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14829         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14830         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14831         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14832         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14833         { } /* end */
14834 };
14835
14836 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
14837         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14838
14839         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14840         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14841
14842         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
14843         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14844         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14845
14846         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
14847         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14848         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14849         { } /* end */
14850 };
14851
14852 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
14853         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14854         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14855         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14856         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
14857         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
14858         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
14859         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
14860         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
14861         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14862         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
14863         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14864         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14865         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14866         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14867         { } /* end */
14868 };
14869
14870 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
14871         .ops = &snd_hda_bind_vol,
14872         .values = {
14873                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14874                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
14875                 0
14876         },
14877 };
14878
14879 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
14880         .ops = &snd_hda_bind_sw,
14881         .values = {
14882                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14883                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14884                 0
14885         },
14886 };
14887
14888 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
14889         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14890         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
14891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14893         { } /* end */
14894 };
14895
14896 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
14897         .ops = &snd_hda_bind_sw,
14898         .values = {
14899                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14900                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14901                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
14902                 0
14903         },
14904 };
14905
14906 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
14907         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14908         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
14909         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14910         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14911         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14912         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14913
14914         { } /* end */
14915 };
14916
14917 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
14918         .ops = &snd_hda_bind_sw,
14919         .values = {
14920                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14921                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
14922                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
14923                 0
14924         },
14925 };
14926
14927 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
14928         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14929         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
14930         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14932         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14933         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14934         { } /* end */
14935 };
14936
14937 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
14938         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14939         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14940         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14941         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14942         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14943         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14944         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14945         { } /* end */
14946 };
14947
14948 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
14949         .ops = &snd_hda_bind_vol,
14950         .values = {
14951                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
14952                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
14953                 0
14954         },
14955 };
14956
14957 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
14958         .ops = &snd_hda_bind_sw,
14959         .values = {
14960                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14961                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
14962                 0
14963         },
14964 };
14965
14966 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
14967         HDA_BIND_VOL("Master Playback Volume",
14968                                 &alc663_asus_two_bind_master_vol),
14969         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14970         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14971         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14972         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14973         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14974         { } /* end */
14975 };
14976
14977 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
14978         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
14979         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
14980         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14981         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14982         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14983         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14984         { } /* end */
14985 };
14986
14987 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
14988         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14989         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14990         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14991         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14992         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14993
14994         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14995         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14996         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14997         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14998         { } /* end */
14999 };
15000
15001 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15002         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15003         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15004         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15005
15006         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15007         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15008         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15009         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15010         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15011         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15012         { } /* end */
15013 };
15014
15015 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15016         {
15017                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15018                 .name = "Channel Mode",
15019                 .info = alc_ch_mode_info,
15020                 .get = alc_ch_mode_get,
15021                 .put = alc_ch_mode_put,
15022         },
15023         { } /* end */
15024 };
15025
15026 static struct hda_verb alc662_init_verbs[] = {
15027         /* ADC: mute amp left and right */
15028         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15029         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15030         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15031
15032         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15033         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15034         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15035         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15036         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15037
15038         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15039         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15040         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15041         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15042         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15043         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15044
15045         /* Front Pin: output 0 (0x0c) */
15046         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15047         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15048
15049         /* Rear Pin: output 1 (0x0d) */
15050         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15051         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15052
15053         /* CLFE Pin: output 2 (0x0e) */
15054         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15055         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15056
15057         /* Mic (rear) pin: input vref at 80% */
15058         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15059         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15060         /* Front Mic pin: input vref at 80% */
15061         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15062         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15063         /* Line In pin: input */
15064         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15065         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15066         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15067         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15068         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15069         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15070         /* CD pin widget for input */
15071         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15072
15073         /* FIXME: use matrix-type input source selection */
15074         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15075         /* Input mixer */
15076         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15077         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15078         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15079         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15080
15081         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15082         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15083         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15084         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15085
15086         /* always trun on EAPD */
15087         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15088         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15089
15090         { }
15091 };
15092
15093 static struct hda_verb alc662_sue_init_verbs[] = {
15094         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15095         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15096         {}
15097 };
15098
15099 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15100         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15101         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15102         {}
15103 };
15104
15105 /* Set Unsolicited Event*/
15106 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15107         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15108         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15109         {}
15110 };
15111
15112 /*
15113  * generic initialization of ADC, input mixers and output mixers
15114  */
15115 static struct hda_verb alc662_auto_init_verbs[] = {
15116         /*
15117          * Unmute ADC and set the default input to mic-in
15118          */
15119         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15120         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15121
15122         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15123          * mixer widget
15124          * Note: PASD motherboards uses the Line In 2 as the input for front
15125          * panel mic (mic 2)
15126          */
15127         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15128         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15129         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15130         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15131         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15132         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15133
15134         /*
15135          * Set up output mixers (0x0c - 0x0f)
15136          */
15137         /* set vol=0 to output mixers */
15138         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15139         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15140         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15141
15142         /* set up input amps for analog loopback */
15143         /* Amp Indices: DAC = 0, mixer = 1 */
15144         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15145         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15146         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15147         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15148         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15149         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15150
15151
15152         /* FIXME: use matrix-type input source selection */
15153         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15154         /* Input mixer */
15155         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15156         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15157         { }
15158 };
15159
15160 /* additional verbs for ALC663 */
15161 static struct hda_verb alc663_auto_init_verbs[] = {
15162         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15163         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15164         { }
15165 };
15166
15167 static struct hda_verb alc663_m51va_init_verbs[] = {
15168         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15169         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15170         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15171         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15172         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15173         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15174         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15175         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15176         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15177         {}
15178 };
15179
15180 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15181         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15182         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15183         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15184         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15185         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15186         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15187         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15188         {}
15189 };
15190
15191 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15192         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15193         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15194         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15195         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15196         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15197         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15198         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15199         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15200         {}
15201 };
15202
15203 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15204         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15205         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15206         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15207         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15208         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15209         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15210         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15211         {}
15212 };
15213
15214 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15215         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15216         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15217         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15218         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15219         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15220         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15221         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15222         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15223         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15224         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15225         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15226         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15227         {}
15228 };
15229
15230 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15231         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15232         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15233         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15234         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15235         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15236         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15237         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15238         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15239         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15240         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15241         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15242         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15243         {}
15244 };
15245
15246 static struct hda_verb alc663_g71v_init_verbs[] = {
15247         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15248         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15249         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15250
15251         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15252         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15253         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15254
15255         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15256         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15257         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15258         {}
15259 };
15260
15261 static struct hda_verb alc663_g50v_init_verbs[] = {
15262         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15263         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15264         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15265
15266         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15267         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15268         {}
15269 };
15270
15271 static struct hda_verb alc662_ecs_init_verbs[] = {
15272         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15273         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15274         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15275         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15276         {}
15277 };
15278
15279 /* capture mixer elements */
15280 static struct snd_kcontrol_new alc662_capture_mixer[] = {
15281         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15282         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15283         {
15284                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15285                 /* The multiple "Capture Source" controls confuse alsamixer
15286                  * So call somewhat different..
15287                  */
15288                 /* .name = "Capture Source", */
15289                 .name = "Input Source",
15290                 .count = 1,
15291                 .info = alc662_mux_enum_info,
15292                 .get = alc662_mux_enum_get,
15293                 .put = alc662_mux_enum_put,
15294         },
15295         { } /* end */
15296 };
15297
15298 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15299         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15300         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15301         { } /* end */
15302 };
15303
15304 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15305 {
15306         unsigned int present;
15307         unsigned char bits;
15308
15309         present = snd_hda_codec_read(codec, 0x14, 0,
15310                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15311         bits = present ? HDA_AMP_MUTE : 0;
15312         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15313                                  HDA_AMP_MUTE, bits);
15314 }
15315
15316 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15317 {
15318         unsigned int present;
15319         unsigned char bits;
15320
15321         present = snd_hda_codec_read(codec, 0x1b, 0,
15322                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15323         bits = present ? HDA_AMP_MUTE : 0;
15324         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15325                                  HDA_AMP_MUTE, bits);
15326         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15327                                  HDA_AMP_MUTE, bits);
15328 }
15329
15330 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15331                                            unsigned int res)
15332 {
15333         if ((res >> 26) == ALC880_HP_EVENT)
15334                 alc662_lenovo_101e_all_automute(codec);
15335         if ((res >> 26) == ALC880_FRONT_EVENT)
15336                 alc662_lenovo_101e_ispeaker_automute(codec);
15337 }
15338
15339 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15340 {
15341         unsigned int present;
15342
15343         present = snd_hda_codec_read(codec, 0x18, 0,
15344                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15345         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15346                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15347         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15348                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15349         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15350                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15351         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15352                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15353 }
15354
15355 /* unsolicited event for HP jack sensing */
15356 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15357                                      unsigned int res)
15358 {
15359         if ((res >> 26) == ALC880_HP_EVENT)
15360                 alc262_hippo1_automute( codec );
15361
15362         if ((res >> 26) == ALC880_MIC_EVENT)
15363                 alc662_eeepc_mic_automute(codec);
15364 }
15365
15366 static void alc662_eeepc_inithook(struct hda_codec *codec)
15367 {
15368         alc262_hippo1_automute( codec );
15369         alc662_eeepc_mic_automute(codec);
15370 }
15371
15372 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15373 {
15374         unsigned int mute;
15375         unsigned int present;
15376
15377         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15378         present = snd_hda_codec_read(codec, 0x14, 0,
15379                                      AC_VERB_GET_PIN_SENSE, 0);
15380         present = (present & 0x80000000) != 0;
15381         if (present) {
15382                 /* mute internal speaker */
15383                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15384                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15385         } else {
15386                 /* unmute internal speaker if necessary */
15387                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15388                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15389                                         HDA_AMP_MUTE, mute);
15390         }
15391 }
15392
15393 /* unsolicited event for HP jack sensing */
15394 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15395                                           unsigned int res)
15396 {
15397         if ((res >> 26) == ALC880_HP_EVENT)
15398                 alc662_eeepc_ep20_automute(codec);
15399 }
15400
15401 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15402 {
15403         alc662_eeepc_ep20_automute(codec);
15404 }
15405
15406 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15407 {
15408         unsigned int present;
15409         unsigned char bits;
15410
15411         present = snd_hda_codec_read(codec, 0x21, 0,
15412                         AC_VERB_GET_PIN_SENSE, 0)
15413                         & AC_PINSENSE_PRESENCE;
15414         bits = present ? HDA_AMP_MUTE : 0;
15415         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15416                                 AMP_IN_MUTE(0), bits);
15417         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15418                                 AMP_IN_MUTE(0), bits);
15419 }
15420
15421 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15422 {
15423         unsigned int present;
15424         unsigned char bits;
15425
15426         present = snd_hda_codec_read(codec, 0x21, 0,
15427                         AC_VERB_GET_PIN_SENSE, 0)
15428                         & AC_PINSENSE_PRESENCE;
15429         bits = present ? HDA_AMP_MUTE : 0;
15430         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15431                                 AMP_IN_MUTE(0), bits);
15432         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15433                                 AMP_IN_MUTE(0), bits);
15434         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15435                                 AMP_IN_MUTE(0), bits);
15436         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15437                                 AMP_IN_MUTE(0), bits);
15438 }
15439
15440 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15441 {
15442         unsigned int present;
15443         unsigned char bits;
15444
15445         present = snd_hda_codec_read(codec, 0x15, 0,
15446                         AC_VERB_GET_PIN_SENSE, 0)
15447                         & AC_PINSENSE_PRESENCE;
15448         bits = present ? HDA_AMP_MUTE : 0;
15449         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15450                                 AMP_IN_MUTE(0), bits);
15451         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15452                                 AMP_IN_MUTE(0), bits);
15453         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15454                                 AMP_IN_MUTE(0), bits);
15455         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15456                                 AMP_IN_MUTE(0), bits);
15457 }
15458
15459 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15460 {
15461         unsigned int present;
15462         unsigned char bits;
15463
15464         present = snd_hda_codec_read(codec, 0x1b, 0,
15465                         AC_VERB_GET_PIN_SENSE, 0)
15466                         & AC_PINSENSE_PRESENCE;
15467         bits = present ? 0 : PIN_OUT;
15468         snd_hda_codec_write(codec, 0x14, 0,
15469                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15470 }
15471
15472 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15473 {
15474         unsigned int present1, present2;
15475
15476         present1 = snd_hda_codec_read(codec, 0x21, 0,
15477                         AC_VERB_GET_PIN_SENSE, 0)
15478                         & AC_PINSENSE_PRESENCE;
15479         present2 = snd_hda_codec_read(codec, 0x15, 0,
15480                         AC_VERB_GET_PIN_SENSE, 0)
15481                         & AC_PINSENSE_PRESENCE;
15482
15483         if (present1 || present2) {
15484                 snd_hda_codec_write_cache(codec, 0x14, 0,
15485                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15486         } else {
15487                 snd_hda_codec_write_cache(codec, 0x14, 0,
15488                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15489         }
15490 }
15491
15492 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15493 {
15494         unsigned int present1, present2;
15495
15496         present1 = snd_hda_codec_read(codec, 0x1b, 0,
15497                                 AC_VERB_GET_PIN_SENSE, 0)
15498                                 & AC_PINSENSE_PRESENCE;
15499         present2 = snd_hda_codec_read(codec, 0x15, 0,
15500                                 AC_VERB_GET_PIN_SENSE, 0)
15501                                 & AC_PINSENSE_PRESENCE;
15502
15503         if (present1 || present2) {
15504                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15505                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15506                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15507                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15508         } else {
15509                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15510                                 AMP_IN_MUTE(0), 0);
15511                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15512                                 AMP_IN_MUTE(0), 0);
15513         }
15514 }
15515
15516 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15517 {
15518         unsigned int present;
15519
15520         present = snd_hda_codec_read(codec, 0x18, 0,
15521                         AC_VERB_GET_PIN_SENSE, 0)
15522                         & AC_PINSENSE_PRESENCE;
15523         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15524                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15525         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15526                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15527         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15528                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15529         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15530                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15531 }
15532
15533 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15534                                            unsigned int res)
15535 {
15536         switch (res >> 26) {
15537         case ALC880_HP_EVENT:
15538                 alc663_m51va_speaker_automute(codec);
15539                 break;
15540         case ALC880_MIC_EVENT:
15541                 alc663_m51va_mic_automute(codec);
15542                 break;
15543         }
15544 }
15545
15546 static void alc663_m51va_inithook(struct hda_codec *codec)
15547 {
15548         alc663_m51va_speaker_automute(codec);
15549         alc663_m51va_mic_automute(codec);
15550 }
15551
15552 /* ***************** Mode1 ******************************/
15553 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15554                                            unsigned int res)
15555 {
15556         switch (res >> 26) {
15557         case ALC880_HP_EVENT:
15558                 alc663_m51va_speaker_automute(codec);
15559                 break;
15560         case ALC880_MIC_EVENT:
15561                 alc662_eeepc_mic_automute(codec);
15562                 break;
15563         }
15564 }
15565
15566 static void alc663_mode1_inithook(struct hda_codec *codec)
15567 {
15568         alc663_m51va_speaker_automute(codec);
15569         alc662_eeepc_mic_automute(codec);
15570 }
15571 /* ***************** Mode2 ******************************/
15572 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15573                                            unsigned int res)
15574 {
15575         switch (res >> 26) {
15576         case ALC880_HP_EVENT:
15577                 alc662_f5z_speaker_automute(codec);
15578                 break;
15579         case ALC880_MIC_EVENT:
15580                 alc662_eeepc_mic_automute(codec);
15581                 break;
15582         }
15583 }
15584
15585 static void alc662_mode2_inithook(struct hda_codec *codec)
15586 {
15587         alc662_f5z_speaker_automute(codec);
15588         alc662_eeepc_mic_automute(codec);
15589 }
15590 /* ***************** Mode3 ******************************/
15591 static void alc663_mode3_unsol_event(struct hda_codec *codec,
15592                                            unsigned int res)
15593 {
15594         switch (res >> 26) {
15595         case ALC880_HP_EVENT:
15596                 alc663_two_hp_m1_speaker_automute(codec);
15597                 break;
15598         case ALC880_MIC_EVENT:
15599                 alc662_eeepc_mic_automute(codec);
15600                 break;
15601         }
15602 }
15603
15604 static void alc663_mode3_inithook(struct hda_codec *codec)
15605 {
15606         alc663_two_hp_m1_speaker_automute(codec);
15607         alc662_eeepc_mic_automute(codec);
15608 }
15609 /* ***************** Mode4 ******************************/
15610 static void alc663_mode4_unsol_event(struct hda_codec *codec,
15611                                            unsigned int res)
15612 {
15613         switch (res >> 26) {
15614         case ALC880_HP_EVENT:
15615                 alc663_21jd_two_speaker_automute(codec);
15616                 break;
15617         case ALC880_MIC_EVENT:
15618                 alc662_eeepc_mic_automute(codec);
15619                 break;
15620         }
15621 }
15622
15623 static void alc663_mode4_inithook(struct hda_codec *codec)
15624 {
15625         alc663_21jd_two_speaker_automute(codec);
15626         alc662_eeepc_mic_automute(codec);
15627 }
15628 /* ***************** Mode5 ******************************/
15629 static void alc663_mode5_unsol_event(struct hda_codec *codec,
15630                                            unsigned int res)
15631 {
15632         switch (res >> 26) {
15633         case ALC880_HP_EVENT:
15634                 alc663_15jd_two_speaker_automute(codec);
15635                 break;
15636         case ALC880_MIC_EVENT:
15637                 alc662_eeepc_mic_automute(codec);
15638                 break;
15639         }
15640 }
15641
15642 static void alc663_mode5_inithook(struct hda_codec *codec)
15643 {
15644         alc663_15jd_two_speaker_automute(codec);
15645         alc662_eeepc_mic_automute(codec);
15646 }
15647 /* ***************** Mode6 ******************************/
15648 static void alc663_mode6_unsol_event(struct hda_codec *codec,
15649                                            unsigned int res)
15650 {
15651         switch (res >> 26) {
15652         case ALC880_HP_EVENT:
15653                 alc663_two_hp_m2_speaker_automute(codec);
15654                 break;
15655         case ALC880_MIC_EVENT:
15656                 alc662_eeepc_mic_automute(codec);
15657                 break;
15658         }
15659 }
15660
15661 static void alc663_mode6_inithook(struct hda_codec *codec)
15662 {
15663         alc663_two_hp_m2_speaker_automute(codec);
15664         alc662_eeepc_mic_automute(codec);
15665 }
15666
15667 static void alc663_g71v_hp_automute(struct hda_codec *codec)
15668 {
15669         unsigned int present;
15670         unsigned char bits;
15671
15672         present = snd_hda_codec_read(codec, 0x21, 0,
15673                                      AC_VERB_GET_PIN_SENSE, 0)
15674                 & AC_PINSENSE_PRESENCE;
15675         bits = present ? HDA_AMP_MUTE : 0;
15676         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15677                                  HDA_AMP_MUTE, bits);
15678         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15679                                  HDA_AMP_MUTE, bits);
15680 }
15681
15682 static void alc663_g71v_front_automute(struct hda_codec *codec)
15683 {
15684         unsigned int present;
15685         unsigned char bits;
15686
15687         present = snd_hda_codec_read(codec, 0x15, 0,
15688                                      AC_VERB_GET_PIN_SENSE, 0)
15689                 & AC_PINSENSE_PRESENCE;
15690         bits = present ? HDA_AMP_MUTE : 0;
15691         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15692                                  HDA_AMP_MUTE, bits);
15693 }
15694
15695 static void alc663_g71v_unsol_event(struct hda_codec *codec,
15696                                            unsigned int res)
15697 {
15698         switch (res >> 26) {
15699         case ALC880_HP_EVENT:
15700                 alc663_g71v_hp_automute(codec);
15701                 break;
15702         case ALC880_FRONT_EVENT:
15703                 alc663_g71v_front_automute(codec);
15704                 break;
15705         case ALC880_MIC_EVENT:
15706                 alc662_eeepc_mic_automute(codec);
15707                 break;
15708         }
15709 }
15710
15711 static void alc663_g71v_inithook(struct hda_codec *codec)
15712 {
15713         alc663_g71v_front_automute(codec);
15714         alc663_g71v_hp_automute(codec);
15715         alc662_eeepc_mic_automute(codec);
15716 }
15717
15718 static void alc663_g50v_unsol_event(struct hda_codec *codec,
15719                                            unsigned int res)
15720 {
15721         switch (res >> 26) {
15722         case ALC880_HP_EVENT:
15723                 alc663_m51va_speaker_automute(codec);
15724                 break;
15725         case ALC880_MIC_EVENT:
15726                 alc662_eeepc_mic_automute(codec);
15727                 break;
15728         }
15729 }
15730
15731 static void alc663_g50v_inithook(struct hda_codec *codec)
15732 {
15733         alc663_m51va_speaker_automute(codec);
15734         alc662_eeepc_mic_automute(codec);
15735 }
15736
15737 /* bind hp and internal speaker mute (with plug check) */
15738 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
15739                                      struct snd_ctl_elem_value *ucontrol)
15740 {
15741         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
15742         long *valp = ucontrol->value.integer.value;
15743         int change;
15744
15745         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
15746                                           HDA_AMP_MUTE,
15747                                           valp[0] ? 0 : HDA_AMP_MUTE);
15748         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
15749                                            HDA_AMP_MUTE,
15750                                            valp[1] ? 0 : HDA_AMP_MUTE);
15751         if (change)
15752                 alc262_hippo1_automute(codec);
15753         return change;
15754 }
15755
15756 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
15757         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15758         {
15759                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15760                 .name = "Master Playback Switch",
15761                 .info = snd_hda_mixer_amp_switch_info,
15762                 .get = snd_hda_mixer_amp_switch_get,
15763                 .put = alc662_ecs_master_sw_put,
15764                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15765         },
15766
15767         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
15768         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
15769         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
15770
15771         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15772         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15773         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15774         { } /* end */
15775 };
15776
15777 #ifdef CONFIG_SND_HDA_POWER_SAVE
15778 #define alc662_loopbacks        alc880_loopbacks
15779 #endif
15780
15781
15782 /* pcm configuration: identiacal with ALC880 */
15783 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
15784 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
15785 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
15786 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
15787
15788 /*
15789  * configuration and preset
15790  */
15791 static const char *alc662_models[ALC662_MODEL_LAST] = {
15792         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
15793         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
15794         [ALC662_3ST_6ch]        = "3stack-6ch",
15795         [ALC662_5ST_DIG]        = "6stack-dig",
15796         [ALC662_LENOVO_101E]    = "lenovo-101e",
15797         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
15798         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
15799         [ALC662_ECS] = "ecs",
15800         [ALC663_ASUS_M51VA] = "m51va",
15801         [ALC663_ASUS_G71V] = "g71v",
15802         [ALC663_ASUS_H13] = "h13",
15803         [ALC663_ASUS_G50V] = "g50v",
15804         [ALC663_ASUS_MODE1] = "asus-mode1",
15805         [ALC662_ASUS_MODE2] = "asus-mode2",
15806         [ALC663_ASUS_MODE3] = "asus-mode3",
15807         [ALC663_ASUS_MODE4] = "asus-mode4",
15808         [ALC663_ASUS_MODE5] = "asus-mode5",
15809         [ALC663_ASUS_MODE6] = "asus-mode6",
15810         [ALC662_AUTO]           = "auto",
15811 };
15812
15813 static struct snd_pci_quirk alc662_cfg_tbl[] = {
15814         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
15815         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
15816         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
15817         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
15818         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
15819         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
15820         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),
15821         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
15822         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
15823         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
15824         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),
15825         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
15826         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
15827         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
15828         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
15829         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
15830         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
15831         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
15832         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
15833         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
15834         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
15835         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
15836         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
15837         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
15838         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
15839         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
15840         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
15841         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
15842         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
15843         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
15844         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
15845         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
15846         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
15847         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
15848         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
15849         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
15850         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
15851         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
15852                       ALC662_3ST_6ch_DIG),
15853         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
15854         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
15855         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
15856         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
15857                       ALC662_3ST_6ch_DIG),
15858         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
15859         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
15860                                         ALC662_3ST_6ch_DIG),
15861         SND_PCI_QUIRK(0x1854, 0x2000, "ASUS H13-2000", ALC663_ASUS_H13),
15862         SND_PCI_QUIRK(0x1854, 0x2001, "ASUS H13-2001", ALC663_ASUS_H13),
15863         SND_PCI_QUIRK(0x1854, 0x2002, "ASUS H13-2002", ALC663_ASUS_H13),
15864         {}
15865 };
15866
15867 static struct alc_config_preset alc662_presets[] = {
15868         [ALC662_3ST_2ch_DIG] = {
15869                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
15870                 .init_verbs = { alc662_init_verbs },
15871                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15872                 .dac_nids = alc662_dac_nids,
15873                 .dig_out_nid = ALC662_DIGOUT_NID,
15874                 .dig_in_nid = ALC662_DIGIN_NID,
15875                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15876                 .channel_mode = alc662_3ST_2ch_modes,
15877                 .input_mux = &alc662_capture_source,
15878         },
15879         [ALC662_3ST_6ch_DIG] = {
15880                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15881                             alc662_capture_mixer },
15882                 .init_verbs = { alc662_init_verbs },
15883                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15884                 .dac_nids = alc662_dac_nids,
15885                 .dig_out_nid = ALC662_DIGOUT_NID,
15886                 .dig_in_nid = ALC662_DIGIN_NID,
15887                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15888                 .channel_mode = alc662_3ST_6ch_modes,
15889                 .need_dac_fix = 1,
15890                 .input_mux = &alc662_capture_source,
15891         },
15892         [ALC662_3ST_6ch] = {
15893                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
15894                             alc662_capture_mixer },
15895                 .init_verbs = { alc662_init_verbs },
15896                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15897                 .dac_nids = alc662_dac_nids,
15898                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15899                 .channel_mode = alc662_3ST_6ch_modes,
15900                 .need_dac_fix = 1,
15901                 .input_mux = &alc662_capture_source,
15902         },
15903         [ALC662_5ST_DIG] = {
15904                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
15905                             alc662_capture_mixer },
15906                 .init_verbs = { alc662_init_verbs },
15907                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15908                 .dac_nids = alc662_dac_nids,
15909                 .dig_out_nid = ALC662_DIGOUT_NID,
15910                 .dig_in_nid = ALC662_DIGIN_NID,
15911                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
15912                 .channel_mode = alc662_5stack_modes,
15913                 .input_mux = &alc662_capture_source,
15914         },
15915         [ALC662_LENOVO_101E] = {
15916                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
15917                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
15918                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15919                 .dac_nids = alc662_dac_nids,
15920                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15921                 .channel_mode = alc662_3ST_2ch_modes,
15922                 .input_mux = &alc662_lenovo_101e_capture_source,
15923                 .unsol_event = alc662_lenovo_101e_unsol_event,
15924                 .init_hook = alc662_lenovo_101e_all_automute,
15925         },
15926         [ALC662_ASUS_EEEPC_P701] = {
15927                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
15928                 .init_verbs = { alc662_init_verbs,
15929                                 alc662_eeepc_sue_init_verbs },
15930                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15931                 .dac_nids = alc662_dac_nids,
15932                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15933                 .channel_mode = alc662_3ST_2ch_modes,
15934                 .input_mux = &alc662_eeepc_capture_source,
15935                 .unsol_event = alc662_eeepc_unsol_event,
15936                 .init_hook = alc662_eeepc_inithook,
15937         },
15938         [ALC662_ASUS_EEEPC_EP20] = {
15939                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
15940                             alc662_chmode_mixer },
15941                 .init_verbs = { alc662_init_verbs,
15942                                 alc662_eeepc_ep20_sue_init_verbs },
15943                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15944                 .dac_nids = alc662_dac_nids,
15945                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
15946                 .channel_mode = alc662_3ST_6ch_modes,
15947                 .input_mux = &alc662_lenovo_101e_capture_source,
15948                 .unsol_event = alc662_eeepc_ep20_unsol_event,
15949                 .init_hook = alc662_eeepc_ep20_inithook,
15950         },
15951         [ALC662_ECS] = {
15952                 .mixers = { alc662_ecs_mixer, alc662_capture_mixer },
15953                 .init_verbs = { alc662_init_verbs,
15954                                 alc662_ecs_init_verbs },
15955                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15956                 .dac_nids = alc662_dac_nids,
15957                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15958                 .channel_mode = alc662_3ST_2ch_modes,
15959                 .input_mux = &alc662_eeepc_capture_source,
15960                 .unsol_event = alc662_eeepc_unsol_event,
15961                 .init_hook = alc662_eeepc_inithook,
15962         },
15963         [ALC663_ASUS_M51VA] = {
15964                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15965                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15966                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15967                 .dac_nids = alc662_dac_nids,
15968                 .dig_out_nid = ALC662_DIGOUT_NID,
15969                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15970                 .channel_mode = alc662_3ST_2ch_modes,
15971                 .input_mux = &alc663_m51va_capture_source,
15972                 .unsol_event = alc663_m51va_unsol_event,
15973                 .init_hook = alc663_m51va_inithook,
15974         },
15975         [ALC663_ASUS_G71V] = {
15976                 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
15977                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
15978                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15979                 .dac_nids = alc662_dac_nids,
15980                 .dig_out_nid = ALC662_DIGOUT_NID,
15981                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15982                 .channel_mode = alc662_3ST_2ch_modes,
15983                 .input_mux = &alc662_eeepc_capture_source,
15984                 .unsol_event = alc663_g71v_unsol_event,
15985                 .init_hook = alc663_g71v_inithook,
15986         },
15987         [ALC663_ASUS_H13] = {
15988                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
15989                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
15990                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
15991                 .dac_nids = alc662_dac_nids,
15992                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
15993                 .channel_mode = alc662_3ST_2ch_modes,
15994                 .input_mux = &alc663_m51va_capture_source,
15995                 .unsol_event = alc663_m51va_unsol_event,
15996                 .init_hook = alc663_m51va_inithook,
15997         },
15998         [ALC663_ASUS_G50V] = {
15999                 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
16000                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16001                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16002                 .dac_nids = alc662_dac_nids,
16003                 .dig_out_nid = ALC662_DIGOUT_NID,
16004                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16005                 .channel_mode = alc662_3ST_6ch_modes,
16006                 .input_mux = &alc663_capture_source,
16007                 .unsol_event = alc663_g50v_unsol_event,
16008                 .init_hook = alc663_g50v_inithook,
16009         },
16010         [ALC663_ASUS_MODE1] = {
16011                 .mixers = { alc663_m51va_mixer, alc662_auto_capture_mixer },
16012                 .init_verbs = { alc662_init_verbs,
16013                                 alc663_21jd_amic_init_verbs },
16014                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16015                 .hp_nid = 0x03,
16016                 .dac_nids = alc662_dac_nids,
16017                 .dig_out_nid = ALC662_DIGOUT_NID,
16018                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16019                 .channel_mode = alc662_3ST_2ch_modes,
16020                 .input_mux = &alc662_eeepc_capture_source,
16021                 .unsol_event = alc663_mode1_unsol_event,
16022                 .init_hook = alc663_mode1_inithook,
16023         },
16024         [ALC662_ASUS_MODE2] = {
16025                 .mixers = { alc662_1bjd_mixer, alc662_auto_capture_mixer },
16026                 .init_verbs = { alc662_init_verbs,
16027                                 alc662_1bjd_amic_init_verbs },
16028                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16029                 .dac_nids = alc662_dac_nids,
16030                 .dig_out_nid = ALC662_DIGOUT_NID,
16031                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16032                 .channel_mode = alc662_3ST_2ch_modes,
16033                 .input_mux = &alc662_eeepc_capture_source,
16034                 .unsol_event = alc662_mode2_unsol_event,
16035                 .init_hook = alc662_mode2_inithook,
16036         },
16037         [ALC663_ASUS_MODE3] = {
16038                 .mixers = { alc663_two_hp_m1_mixer, alc662_auto_capture_mixer },
16039                 .init_verbs = { alc662_init_verbs,
16040                                 alc663_two_hp_amic_m1_init_verbs },
16041                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16042                 .hp_nid = 0x03,
16043                 .dac_nids = alc662_dac_nids,
16044                 .dig_out_nid = ALC662_DIGOUT_NID,
16045                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16046                 .channel_mode = alc662_3ST_2ch_modes,
16047                 .input_mux = &alc662_eeepc_capture_source,
16048                 .unsol_event = alc663_mode3_unsol_event,
16049                 .init_hook = alc663_mode3_inithook,
16050         },
16051         [ALC663_ASUS_MODE4] = {
16052                 .mixers = { alc663_asus_21jd_clfe_mixer,
16053                                 alc662_auto_capture_mixer},
16054                 .init_verbs = { alc662_init_verbs,
16055                                 alc663_21jd_amic_init_verbs},
16056                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16057                 .hp_nid = 0x03,
16058                 .dac_nids = alc662_dac_nids,
16059                 .dig_out_nid = ALC662_DIGOUT_NID,
16060                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16061                 .channel_mode = alc662_3ST_2ch_modes,
16062                 .input_mux = &alc662_eeepc_capture_source,
16063                 .unsol_event = alc663_mode4_unsol_event,
16064                 .init_hook = alc663_mode4_inithook,
16065         },
16066         [ALC663_ASUS_MODE5] = {
16067                 .mixers = { alc663_asus_15jd_clfe_mixer,
16068                                 alc662_auto_capture_mixer },
16069                 .init_verbs = { alc662_init_verbs,
16070                                 alc663_15jd_amic_init_verbs },
16071                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16072                 .hp_nid = 0x03,
16073                 .dac_nids = alc662_dac_nids,
16074                 .dig_out_nid = ALC662_DIGOUT_NID,
16075                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16076                 .channel_mode = alc662_3ST_2ch_modes,
16077                 .input_mux = &alc662_eeepc_capture_source,
16078                 .unsol_event = alc663_mode5_unsol_event,
16079                 .init_hook = alc663_mode5_inithook,
16080         },
16081         [ALC663_ASUS_MODE6] = {
16082                 .mixers = { alc663_two_hp_m2_mixer, alc662_auto_capture_mixer },
16083                 .init_verbs = { alc662_init_verbs,
16084                                 alc663_two_hp_amic_m2_init_verbs },
16085                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16086                 .hp_nid = 0x03,
16087                 .dac_nids = alc662_dac_nids,
16088                 .dig_out_nid = ALC662_DIGOUT_NID,
16089                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16090                 .channel_mode = alc662_3ST_2ch_modes,
16091                 .input_mux = &alc662_eeepc_capture_source,
16092                 .unsol_event = alc663_mode6_unsol_event,
16093                 .init_hook = alc663_mode6_inithook,
16094         },
16095 };
16096
16097
16098 /*
16099  * BIOS auto configuration
16100  */
16101
16102 /* add playback controls from the parsed DAC table */
16103 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16104                                              const struct auto_pin_cfg *cfg)
16105 {
16106         char name[32];
16107         static const char *chname[4] = {
16108                 "Front", "Surround", NULL /*CLFE*/, "Side"
16109         };
16110         hda_nid_t nid;
16111         int i, err;
16112
16113         for (i = 0; i < cfg->line_outs; i++) {
16114                 if (!spec->multiout.dac_nids[i])
16115                         continue;
16116                 nid = alc880_idx_to_dac(i);
16117                 if (i == 2) {
16118                         /* Center/LFE */
16119                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16120                                           "Center Playback Volume",
16121                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16122                                                               HDA_OUTPUT));
16123                         if (err < 0)
16124                                 return err;
16125                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16126                                           "LFE Playback Volume",
16127                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16128                                                               HDA_OUTPUT));
16129                         if (err < 0)
16130                                 return err;
16131                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16132                                           "Center Playback Switch",
16133                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16134                                                               HDA_INPUT));
16135                         if (err < 0)
16136                                 return err;
16137                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16138                                           "LFE Playback Switch",
16139                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16140                                                               HDA_INPUT));
16141                         if (err < 0)
16142                                 return err;
16143                 } else {
16144                         sprintf(name, "%s Playback Volume", chname[i]);
16145                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16146                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16147                                                               HDA_OUTPUT));
16148                         if (err < 0)
16149                                 return err;
16150                         sprintf(name, "%s Playback Switch", chname[i]);
16151                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16152                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16153                                                     3, 0, HDA_INPUT));
16154                         if (err < 0)
16155                                 return err;
16156                 }
16157         }
16158         return 0;
16159 }
16160
16161 /* add playback controls for speaker and HP outputs */
16162 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16163                                         const char *pfx)
16164 {
16165         hda_nid_t nid;
16166         int err;
16167         char name[32];
16168
16169         if (!pin)
16170                 return 0;
16171
16172         if (pin == 0x17) {
16173                 /* ALC663 has a mono output pin on 0x17 */
16174                 sprintf(name, "%s Playback Switch", pfx);
16175                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16176                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16177                 return err;
16178         }
16179
16180         if (alc880_is_fixed_pin(pin)) {
16181                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16182                 /* printk("DAC nid=%x\n",nid); */
16183                 /* specify the DAC as the extra output */
16184                 if (!spec->multiout.hp_nid)
16185                         spec->multiout.hp_nid = nid;
16186                 else
16187                         spec->multiout.extra_out_nid[0] = nid;
16188                 /* control HP volume/switch on the output mixer amp */
16189                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16190                 sprintf(name, "%s Playback Volume", pfx);
16191                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16192                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16193                 if (err < 0)
16194                         return err;
16195                 sprintf(name, "%s Playback Switch", pfx);
16196                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16197                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16198                 if (err < 0)
16199                         return err;
16200         } else if (alc880_is_multi_pin(pin)) {
16201                 /* set manual connection */
16202                 /* we have only a switch on HP-out PIN */
16203                 sprintf(name, "%s Playback Switch", pfx);
16204                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16205                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16206                 if (err < 0)
16207                         return err;
16208         }
16209         return 0;
16210 }
16211
16212 /* create playback/capture controls for input pins */
16213 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16214                                                 const struct auto_pin_cfg *cfg)
16215 {
16216         struct hda_input_mux *imux = &spec->private_imux;
16217         int i, err, idx;
16218
16219         for (i = 0; i < AUTO_PIN_LAST; i++) {
16220                 if (alc880_is_input_pin(cfg->input_pins[i])) {
16221                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
16222                         err = new_analog_input(spec, cfg->input_pins[i],
16223                                                auto_pin_cfg_labels[i],
16224                                                idx, 0x0b);
16225                         if (err < 0)
16226                                 return err;
16227                         imux->items[imux->num_items].label =
16228                                 auto_pin_cfg_labels[i];
16229                         imux->items[imux->num_items].index =
16230                                 alc880_input_pin_idx(cfg->input_pins[i]);
16231                         imux->num_items++;
16232                 }
16233         }
16234         return 0;
16235 }
16236
16237 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16238                                               hda_nid_t nid, int pin_type,
16239                                               int dac_idx)
16240 {
16241         alc_set_pin_output(codec, nid, pin_type);
16242         /* need the manual connection? */
16243         if (alc880_is_multi_pin(nid)) {
16244                 struct alc_spec *spec = codec->spec;
16245                 int idx = alc880_multi_pin_idx(nid);
16246                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16247                                     AC_VERB_SET_CONNECT_SEL,
16248                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16249         }
16250 }
16251
16252 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16253 {
16254         struct alc_spec *spec = codec->spec;
16255         int i;
16256
16257         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16258         for (i = 0; i <= HDA_SIDE; i++) {
16259                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16260                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16261                 if (nid)
16262                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16263                                                           i);
16264         }
16265 }
16266
16267 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16268 {
16269         struct alc_spec *spec = codec->spec;
16270         hda_nid_t pin;
16271
16272         pin = spec->autocfg.hp_pins[0];
16273         if (pin) /* connect to front */
16274                 /* use dac 0 */
16275                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16276         pin = spec->autocfg.speaker_pins[0];
16277         if (pin)
16278                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16279 }
16280
16281 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
16282 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16283
16284 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16285 {
16286         struct alc_spec *spec = codec->spec;
16287         int i;
16288
16289         for (i = 0; i < AUTO_PIN_LAST; i++) {
16290                 hda_nid_t nid = spec->autocfg.input_pins[i];
16291                 if (alc662_is_input_pin(nid)) {
16292                         snd_hda_codec_write(codec, nid, 0,
16293                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
16294                                             (i <= AUTO_PIN_FRONT_MIC ?
16295                                              PIN_VREF80 : PIN_IN));
16296                         if (nid != ALC662_PIN_CD_NID)
16297                                 snd_hda_codec_write(codec, nid, 0,
16298                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16299                                                     AMP_OUT_MUTE);
16300                 }
16301         }
16302 }
16303
16304 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16305
16306 static int alc662_parse_auto_config(struct hda_codec *codec)
16307 {
16308         struct alc_spec *spec = codec->spec;
16309         int err;
16310         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16311
16312         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16313                                            alc662_ignore);
16314         if (err < 0)
16315                 return err;
16316         if (!spec->autocfg.line_outs)
16317                 return 0; /* can't find valid BIOS pin config */
16318
16319         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16320         if (err < 0)
16321                 return err;
16322         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16323         if (err < 0)
16324                 return err;
16325         err = alc662_auto_create_extra_out(spec,
16326                                            spec->autocfg.speaker_pins[0],
16327                                            "Speaker");
16328         if (err < 0)
16329                 return err;
16330         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16331                                            "Headphone");
16332         if (err < 0)
16333                 return err;
16334         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16335         if (err < 0)
16336                 return err;
16337
16338         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16339
16340         if (spec->autocfg.dig_out_pin)
16341                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16342
16343         if (spec->kctl_alloc)
16344                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
16345
16346         spec->num_mux_defs = 1;
16347         spec->input_mux = &spec->private_imux;
16348
16349         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
16350         if (codec->vendor_id == 0x10ec0663)
16351                 spec->init_verbs[spec->num_init_verbs++] =
16352                         alc663_auto_init_verbs;
16353
16354         err = alc_auto_add_mic_boost(codec);
16355         if (err < 0)
16356                 return err;
16357
16358         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
16359         spec->num_mixers++;
16360
16361         store_pin_configs(codec);
16362         return 1;
16363 }
16364
16365 /* additional initialization for auto-configuration model */
16366 static void alc662_auto_init(struct hda_codec *codec)
16367 {
16368         struct alc_spec *spec = codec->spec;
16369         alc662_auto_init_multi_out(codec);
16370         alc662_auto_init_hp_out(codec);
16371         alc662_auto_init_analog_input(codec);
16372         alc662_auto_init_input_src(codec);
16373         if (spec->unsol_event)
16374                 alc_inithook(codec);
16375 }
16376
16377 static int patch_alc662(struct hda_codec *codec)
16378 {
16379         struct alc_spec *spec;
16380         int err, board_config;
16381
16382         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16383         if (!spec)
16384                 return -ENOMEM;
16385
16386         codec->spec = spec;
16387
16388         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16389
16390         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16391                                                   alc662_models,
16392                                                   alc662_cfg_tbl);
16393         if (board_config < 0) {
16394                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16395                        "trying auto-probe from BIOS...\n");
16396                 board_config = ALC662_AUTO;
16397         }
16398
16399         if (board_config == ALC662_AUTO) {
16400                 /* automatic parse from the BIOS config */
16401                 err = alc662_parse_auto_config(codec);
16402                 if (err < 0) {
16403                         alc_free(codec);
16404                         return err;
16405                 } else if (!err) {
16406                         printk(KERN_INFO
16407                                "hda_codec: Cannot set up configuration "
16408                                "from BIOS.  Using base mode...\n");
16409                         board_config = ALC662_3ST_2ch_DIG;
16410                 }
16411         }
16412
16413         if (board_config != ALC662_AUTO)
16414                 setup_preset(spec, &alc662_presets[board_config]);
16415
16416         if (codec->vendor_id == 0x10ec0663) {
16417                 spec->stream_name_analog = "ALC663 Analog";
16418                 spec->stream_name_digital = "ALC663 Digital";
16419         } else if (codec->vendor_id == 0x10ec0272) {
16420                 spec->stream_name_analog = "ALC272 Analog";
16421                 spec->stream_name_digital = "ALC272 Digital";
16422         } else {
16423                 spec->stream_name_analog = "ALC662 Analog";
16424                 spec->stream_name_digital = "ALC662 Digital";
16425         }
16426
16427         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16428         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16429
16430         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16431         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16432
16433         spec->adc_nids = alc662_adc_nids;
16434         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16435         spec->capsrc_nids = alc662_capsrc_nids;
16436
16437         spec->vmaster_nid = 0x02;
16438
16439         codec->patch_ops = alc_patch_ops;
16440         if (board_config == ALC662_AUTO)
16441                 spec->init_hook = alc662_auto_init;
16442 #ifdef CONFIG_SND_HDA_POWER_SAVE
16443         if (!spec->loopback.amplist)
16444                 spec->loopback.amplist = alc662_loopbacks;
16445 #endif
16446
16447         return 0;
16448 }
16449
16450 /*
16451  * patch entries
16452  */
16453 struct hda_codec_preset snd_hda_preset_realtek[] = {
16454         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16455         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16456         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16457         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16458         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16459         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16460         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16461           .patch = patch_alc861 },
16462         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16463         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16464         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16465         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16466           .patch = patch_alc883 },
16467         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16468           .patch = patch_alc662 },
16469         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16470         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16471         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16472         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16473         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16474           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16475         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16476           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16477         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16478         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16479         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16480         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16481           .patch = patch_alc883 },
16482         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16483         {} /* terminator */
16484 };