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_beep.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_TYAN,
 108         ALC262_AUTO,
 109         ALC262_MODEL_LAST /* last tag */
 110 };
 111
 112 /* ALC268 models */
 113 enum {
 114         ALC267_QUANTA_IL1,
 115         ALC268_3ST,
 116         ALC268_TOSHIBA,
 117         ALC268_ACER,
 118         ALC268_ACER_DMIC,
 119         ALC268_ACER_ASPIRE_ONE,
 120         ALC268_DELL,
 121         ALC268_ZEPTO,
 122 #ifdef CONFIG_SND_DEBUG
 123         ALC268_TEST,
 124 #endif
 125         ALC268_AUTO,
 126         ALC268_MODEL_LAST /* last tag */
 127 };
 128
 129 /* ALC269 models */
 130 enum {
 131         ALC269_BASIC,
 132         ALC269_QUANTA_FL1,
 133         ALC269_ASUS_EEEPC_P703,
 134         ALC269_ASUS_EEEPC_P901,
 135         ALC269_FUJITSU,
 136         ALC269_LIFEBOOK,
 137         ALC269_AUTO,
 138         ALC269_MODEL_LAST /* last tag */
 139 };
 140
 141 /* ALC861 models */
 142 enum {
 143         ALC861_3ST,
 144         ALC660_3ST,
 145         ALC861_3ST_DIG,
 146         ALC861_6ST_DIG,
 147         ALC861_UNIWILL_M31,
 148         ALC861_TOSHIBA,
 149         ALC861_ASUS,
 150         ALC861_ASUS_LAPTOP,
 151         ALC861_AUTO,
 152         ALC861_MODEL_LAST,
 153 };
 154
 155 /* ALC861-VD models */
 156 enum {
 157         ALC660VD_3ST,
 158         ALC660VD_3ST_DIG,
 159         ALC660VD_ASUS_V1S,
 160         ALC861VD_3ST,
 161         ALC861VD_3ST_DIG,
 162         ALC861VD_6ST_DIG,
 163         ALC861VD_LENOVO,
 164         ALC861VD_DALLAS,
 165         ALC861VD_HP,
 166         ALC861VD_AUTO,
 167         ALC861VD_MODEL_LAST,
 168 };
 169
 170 /* ALC662 models */
 171 enum {
 172         ALC662_3ST_2ch_DIG,
 173         ALC662_3ST_6ch_DIG,
 174         ALC662_3ST_6ch,
 175         ALC662_5ST_DIG,
 176         ALC662_LENOVO_101E,
 177         ALC662_ASUS_EEEPC_P701,
 178         ALC662_ASUS_EEEPC_EP20,
 179         ALC663_ASUS_M51VA,
 180         ALC663_ASUS_G71V,
 181         ALC663_ASUS_H13,
 182         ALC663_ASUS_G50V,
 183         ALC662_ECS,
 184         ALC663_ASUS_MODE1,
 185         ALC662_ASUS_MODE2,
 186         ALC663_ASUS_MODE3,
 187         ALC663_ASUS_MODE4,
 188         ALC663_ASUS_MODE5,
 189         ALC663_ASUS_MODE6,
 190         ALC662_AUTO,
 191         ALC662_MODEL_LAST,
 192 };
 193
 194 /* ALC882 models */
 195 enum {
 196         ALC882_3ST_DIG,
 197         ALC882_6ST_DIG,
 198         ALC882_ARIMA,
 199         ALC882_W2JC,
 200         ALC882_TARGA,
 201         ALC882_ASUS_A7J,
 202         ALC882_ASUS_A7M,
 203         ALC885_MACPRO,
 204         ALC885_MBP3,
 205         ALC885_IMAC24,
 206         ALC882_AUTO,
 207         ALC882_MODEL_LAST,
 208 };
 209
 210 /* ALC883 models */
 211 enum {
 212         ALC883_3ST_2ch_DIG,
 213         ALC883_3ST_6ch_DIG,
 214         ALC883_3ST_6ch,
 215         ALC883_6ST_DIG,
 216         ALC883_TARGA_DIG,
 217         ALC883_TARGA_2ch_DIG,
 218         ALC883_ACER,
 219         ALC883_ACER_ASPIRE,
 220         ALC888_ACER_ASPIRE_4930G,
 221         ALC883_MEDION,
 222         ALC883_MEDION_MD2,
 223         ALC883_LAPTOP_EAPD,
 224         ALC883_LENOVO_101E_2ch,
 225         ALC883_LENOVO_NB0763,
 226         ALC888_LENOVO_MS7195_DIG,
 227         ALC888_LENOVO_SKY,
 228         ALC883_HAIER_W66,
 229         ALC888_3ST_HP,
 230         ALC888_6ST_DELL,
 231         ALC883_MITAC,
 232         ALC883_CLEVO_M720,
 233         ALC883_FUJITSU_PI2515,
 234         ALC888_FUJITSU_XA3530,
 235         ALC883_3ST_6ch_INTEL,
 236         ALC888_ASUS_M90V,
 237         ALC888_ASUS_EEE1601,
 238         ALC1200_ASUS_P5Q,
 239         ALC883_AUTO,
 240         ALC883_MODEL_LAST,
 241 };
 242
 243 /* styles of capture selection */
 244 enum {
 245         CAPT_MUX = 0,   /* only mux based */
 246         CAPT_MIX,       /* only mixer based */
 247         CAPT_1MUX_MIX,  /* first mux and other mixers */
 248 };
 249
 250 /* for GPIO Poll */
 251 #define GPIO_MASK       0x03
 252
 253 struct alc_spec {
 254         /* codec parameterization */
 255         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 256         unsigned int num_mixers;
 257         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 258         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 259
 260         const struct hda_verb *init_verbs[5];   /* initialization verbs
 261                                                  * don't forget NULL
 262                                                  * termination!
 263                                                  */
 264         unsigned int num_init_verbs;
 265
 266         char *stream_name_analog;       /* analog PCM stream */
 267         struct hda_pcm_stream *stream_analog_playback;
 268         struct hda_pcm_stream *stream_analog_capture;
 269         struct hda_pcm_stream *stream_analog_alt_playback;
 270         struct hda_pcm_stream *stream_analog_alt_capture;
 271
 272         char *stream_name_digital;      /* digital PCM stream */
 273         struct hda_pcm_stream *stream_digital_playback;
 274         struct hda_pcm_stream *stream_digital_capture;
 275
 276         /* playback */
 277         struct hda_multi_out multiout;  /* playback set-up
 278                                          * max_channels, dacs must be set
 279                                          * dig_out_nid and hp_nid are optional
 280                                          */
 281         hda_nid_t alt_dac_nid;
 282         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 283         int dig_out_type;
 284
 285         /* capture */
 286         unsigned int num_adc_nids;
 287         hda_nid_t *adc_nids;
 288         hda_nid_t *capsrc_nids;
 289         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 290         int capture_style;              /* capture style (CAPT_*) */
 291
 292         /* capture source */
 293         unsigned int num_mux_defs;
 294         const struct hda_input_mux *input_mux;
 295         unsigned int cur_mux[3];
 296
 297         /* channel model */
 298         const struct hda_channel_mode *channel_mode;
 299         int num_channel_mode;
 300         int need_dac_fix;
 301
 302         /* PCM information */
 303         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 304
 305         /* dynamic controls, init_verbs and input_mux */
 306         struct auto_pin_cfg autocfg;
 307         struct snd_array kctls;
 308         struct hda_input_mux private_imux[3];
 309         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 310
 311         /* hooks */
 312         void (*init_hook)(struct hda_codec *codec);
 313         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 314
 315         /* for pin sensing */
 316         unsigned int sense_updated: 1;
 317         unsigned int jack_present: 1;
 318         unsigned int master_sw: 1;
 319
 320         /* other flags */
 321         unsigned int no_analog :1; /* digital I/O only */
 322
 323         /* for virtual master */
 324         hda_nid_t vmaster_nid;
 325 #ifdef CONFIG_SND_HDA_POWER_SAVE
 326         struct hda_loopback_check loopback;
 327 #endif
 328
 329         /* for PLL fix */
 330         hda_nid_t pll_nid;
 331         unsigned int pll_coef_idx, pll_coef_bit;
 332 };
 333
 334 /*
 335  * configuration template - to be copied to the spec instance
 336  */
 337 struct alc_config_preset {
 338         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 339                                              * with spec
 340                                              */
 341         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 342         const struct hda_verb *init_verbs[5];
 343         unsigned int num_dacs;
 344         hda_nid_t *dac_nids;
 345         hda_nid_t dig_out_nid;          /* optional */
 346         hda_nid_t hp_nid;               /* optional */
 347         hda_nid_t *slave_dig_outs;
 348         unsigned int num_adc_nids;
 349         hda_nid_t *adc_nids;
 350         hda_nid_t *capsrc_nids;
 351         hda_nid_t dig_in_nid;
 352         unsigned int num_channel_mode;
 353         const struct hda_channel_mode *channel_mode;
 354         int need_dac_fix;
 355         unsigned int num_mux_defs;
 356         const struct hda_input_mux *input_mux;
 357         void (*unsol_event)(struct hda_codec *, unsigned int);
 358         void (*init_hook)(struct hda_codec *);
 359 #ifdef CONFIG_SND_HDA_POWER_SAVE
 360         struct hda_amp_list *loopbacks;
 361 #endif
 362 };
 363
 364
 365 /*
 366  * input MUX handling
 367  */
 368 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 369                              struct snd_ctl_elem_info *uinfo)
 370 {
 371         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 372         struct alc_spec *spec = codec->spec;
 373         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 374         if (mux_idx >= spec->num_mux_defs)
 375                 mux_idx = 0;
 376         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 377 }
 378
 379 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 380                             struct snd_ctl_elem_value *ucontrol)
 381 {
 382         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 383         struct alc_spec *spec = codec->spec;
 384         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 385
 386         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 387         return 0;
 388 }
 389
 390 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 391                             struct snd_ctl_elem_value *ucontrol)
 392 {
 393         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 394         struct alc_spec *spec = codec->spec;
 395         const struct hda_input_mux *imux;
 396         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 397         unsigned int mux_idx;
 398         hda_nid_t nid = spec->capsrc_nids ?
 399                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 400
 401         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 402         imux = &spec->input_mux[mux_idx];
 403
 404         if (spec->capture_style &&
 405             !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
 406                 /* Matrix-mixer style (e.g. ALC882) */
 407                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 408                 unsigned int i, idx;
 409
 410                 idx = ucontrol->value.enumerated.item[0];
 411                 if (idx >= imux->num_items)
 412                         idx = imux->num_items - 1;
 413                 if (*cur_val == idx)
 414                         return 0;
 415                 for (i = 0; i < imux->num_items; i++) {
 416                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 417                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 418                                                  imux->items[i].index,
 419                                                  HDA_AMP_MUTE, v);
 420                 }
 421                 *cur_val = idx;
 422                 return 1;
 423         } else {
 424                 /* MUX style (e.g. ALC880) */
 425                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 426                                              &spec->cur_mux[adc_idx]);
 427         }
 428 }
 429
 430 /*
 431  * channel mode setting
 432  */
 433 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 434                             struct snd_ctl_elem_info *uinfo)
 435 {
 436         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 437         struct alc_spec *spec = codec->spec;
 438         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 439                                     spec->num_channel_mode);
 440 }
 441
 442 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 443                            struct snd_ctl_elem_value *ucontrol)
 444 {
 445         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 446         struct alc_spec *spec = codec->spec;
 447         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 448                                    spec->num_channel_mode,
 449                                    spec->multiout.max_channels);
 450 }
 451
 452 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 453                            struct snd_ctl_elem_value *ucontrol)
 454 {
 455         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 456         struct alc_spec *spec = codec->spec;
 457         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 458                                       spec->num_channel_mode,
 459                                       &spec->multiout.max_channels);
 460         if (err >= 0 && spec->need_dac_fix)
 461                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 462         return err;
 463 }
 464
 465 /*
 466  * Control the mode of pin widget settings via the mixer.  "pc" is used
 467  * instead of "%" to avoid consequences of accidently treating the % as
 468  * being part of a format specifier.  Maximum allowed length of a value is
 469  * 63 characters plus NULL terminator.
 470  *
 471  * Note: some retasking pin complexes seem to ignore requests for input
 472  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 473  * are requested.  Therefore order this list so that this behaviour will not
 474  * cause problems when mixer clients move through the enum sequentially.
 475  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 476  * March 2006.
 477  */
 478 static char *alc_pin_mode_names[] = {
 479         "Mic 50pc bias", "Mic 80pc bias",
 480         "Line in", "Line out", "Headphone out",
 481 };
 482 static unsigned char alc_pin_mode_values[] = {
 483         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 484 };
 485 /* The control can present all 5 options, or it can limit the options based
 486  * in the pin being assumed to be exclusively an input or an output pin.  In
 487  * addition, "input" pins may or may not process the mic bias option
 488  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 489  * accept requests for bias as of chip versions up to March 2006) and/or
 490  * wiring in the computer.
 491  */
 492 #define ALC_PIN_DIR_IN              0x00
 493 #define ALC_PIN_DIR_OUT             0x01
 494 #define ALC_PIN_DIR_INOUT           0x02
 495 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 496 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 497
 498 /* Info about the pin modes supported by the different pin direction modes.
 499  * For each direction the minimum and maximum values are given.
 500  */
 501 static signed char alc_pin_mode_dir_info[5][2] = {
 502         { 0, 2 },    /* ALC_PIN_DIR_IN */
 503         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 504         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 505         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 506         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 507 };
 508 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 509 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 510 #define alc_pin_mode_n_items(_dir) \
 511         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 512
 513 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 514                              struct snd_ctl_elem_info *uinfo)
 515 {
 516         unsigned int item_num = uinfo->value.enumerated.item;
 517         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 518
 519         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 520         uinfo->count = 1;
 521         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 522
 523         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 524                 item_num = alc_pin_mode_min(dir);
 525         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 526         return 0;
 527 }
 528
 529 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 530                             struct snd_ctl_elem_value *ucontrol)
 531 {
 532         unsigned int i;
 533         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 534         hda_nid_t nid = kcontrol->private_value & 0xffff;
 535         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 536         long *valp = ucontrol->value.integer.value;
 537         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 538                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 539                                                  0x00);
 540
 541         /* Find enumerated value for current pinctl setting */
 542         i = alc_pin_mode_min(dir);
 543         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 544                 i++;
 545         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 546         return 0;
 547 }
 548
 549 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 550                             struct snd_ctl_elem_value *ucontrol)
 551 {
 552         signed int change;
 553         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 554         hda_nid_t nid = kcontrol->private_value & 0xffff;
 555         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 556         long val = *ucontrol->value.integer.value;
 557         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 558                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 559                                                  0x00);
 560
 561         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 562                 val = alc_pin_mode_min(dir);
 563
 564         change = pinctl != alc_pin_mode_values[val];
 565         if (change) {
 566                 /* Set pin mode to that requested */
 567                 snd_hda_codec_write_cache(codec, nid, 0,
 568                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 569                                           alc_pin_mode_values[val]);
 570
 571                 /* Also enable the retasking pin's input/output as required
 572                  * for the requested pin mode.  Enum values of 2 or less are
 573                  * input modes.
 574                  *
 575                  * Dynamically switching the input/output buffers probably
 576                  * reduces noise slightly (particularly on input) so we'll
 577                  * do it.  However, having both input and output buffers
 578                  * enabled simultaneously doesn't seem to be problematic if
 579                  * this turns out to be necessary in the future.
 580                  */
 581                 if (val <= 2) {
 582                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 583                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 584                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 585                                                  HDA_AMP_MUTE, 0);
 586                 } else {
 587                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 588                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 589                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 590                                                  HDA_AMP_MUTE, 0);
 591                 }
 592         }
 593         return change;
 594 }
 595
 596 #define ALC_PIN_MODE(xname, nid, dir) \
 597         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 598           .info = alc_pin_mode_info, \
 599           .get = alc_pin_mode_get, \
 600           .put = alc_pin_mode_put, \
 601           .private_value = nid | (dir<<16) }
 602
 603 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 604  * together using a mask with more than one bit set.  This control is
 605  * currently used only by the ALC260 test model.  At this stage they are not
 606  * needed for any "production" models.
 607  */
 608 #ifdef CONFIG_SND_DEBUG
 609 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 610
 611 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 612                              struct snd_ctl_elem_value *ucontrol)
 613 {
 614         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 615         hda_nid_t nid = kcontrol->private_value & 0xffff;
 616         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 617         long *valp = ucontrol->value.integer.value;
 618         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 619                                               AC_VERB_GET_GPIO_DATA, 0x00);
 620
 621         *valp = (val & mask) != 0;
 622         return 0;
 623 }
 624 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 625                              struct snd_ctl_elem_value *ucontrol)
 626 {
 627         signed int change;
 628         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 629         hda_nid_t nid = kcontrol->private_value & 0xffff;
 630         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 631         long val = *ucontrol->value.integer.value;
 632         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 633                                                     AC_VERB_GET_GPIO_DATA,
 634                                                     0x00);
 635
 636         /* Set/unset the masked GPIO bit(s) as needed */
 637         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 638         if (val == 0)
 639                 gpio_data &= ~mask;
 640         else
 641                 gpio_data |= mask;
 642         snd_hda_codec_write_cache(codec, nid, 0,
 643                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 644
 645         return change;
 646 }
 647 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 648         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 649           .info = alc_gpio_data_info, \
 650           .get = alc_gpio_data_get, \
 651           .put = alc_gpio_data_put, \
 652           .private_value = nid | (mask<<16) }
 653 #endif   /* CONFIG_SND_DEBUG */
 654
 655 /* A switch control to allow the enabling of the digital IO pins on the
 656  * ALC260.  This is incredibly simplistic; the intention of this control is
 657  * to provide something in the test model allowing digital outputs to be
 658  * identified if present.  If models are found which can utilise these
 659  * outputs a more complete mixer control can be devised for those models if
 660  * necessary.
 661  */
 662 #ifdef CONFIG_SND_DEBUG
 663 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 664
 665 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 666                               struct snd_ctl_elem_value *ucontrol)
 667 {
 668         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 669         hda_nid_t nid = kcontrol->private_value & 0xffff;
 670         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 671         long *valp = ucontrol->value.integer.value;
 672         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 673                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 674
 675         *valp = (val & mask) != 0;
 676         return 0;
 677 }
 678 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 679                               struct snd_ctl_elem_value *ucontrol)
 680 {
 681         signed int change;
 682         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 683         hda_nid_t nid = kcontrol->private_value & 0xffff;
 684         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 685         long val = *ucontrol->value.integer.value;
 686         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 687                                                     AC_VERB_GET_DIGI_CONVERT_1,
 688                                                     0x00);
 689
 690         /* Set/unset the masked control bit(s) as needed */
 691         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 692         if (val==0)
 693                 ctrl_data &= ~mask;
 694         else
 695                 ctrl_data |= mask;
 696         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 697                                   ctrl_data);
 698
 699         return change;
 700 }
 701 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 702         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 703           .info = alc_spdif_ctrl_info, \
 704           .get = alc_spdif_ctrl_get, \
 705           .put = alc_spdif_ctrl_put, \
 706           .private_value = nid | (mask<<16) }
 707 #endif   /* CONFIG_SND_DEBUG */
 708
 709 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 710  * Again, this is only used in the ALC26x test models to help identify when
 711  * the EAPD line must be asserted for features to work.
 712  */
 713 #ifdef CONFIG_SND_DEBUG
 714 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 715
 716 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 717                               struct snd_ctl_elem_value *ucontrol)
 718 {
 719         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 720         hda_nid_t nid = kcontrol->private_value & 0xffff;
 721         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 722         long *valp = ucontrol->value.integer.value;
 723         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 724                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 725
 726         *valp = (val & mask) != 0;
 727         return 0;
 728 }
 729
 730 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 731                               struct snd_ctl_elem_value *ucontrol)
 732 {
 733         int change;
 734         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 735         hda_nid_t nid = kcontrol->private_value & 0xffff;
 736         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 737         long val = *ucontrol->value.integer.value;
 738         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 739                                                     AC_VERB_GET_EAPD_BTLENABLE,
 740                                                     0x00);
 741
 742         /* Set/unset the masked control bit(s) as needed */
 743         change = (!val ? 0 : mask) != (ctrl_data & mask);
 744         if (!val)
 745                 ctrl_data &= ~mask;
 746         else
 747                 ctrl_data |= mask;
 748         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 749                                   ctrl_data);
 750
 751         return change;
 752 }
 753
 754 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 755         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 756           .info = alc_eapd_ctrl_info, \
 757           .get = alc_eapd_ctrl_get, \
 758           .put = alc_eapd_ctrl_put, \
 759           .private_value = nid | (mask<<16) }
 760 #endif   /* CONFIG_SND_DEBUG */
 761
 762 /*
 763  */
 764 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 765 {
 766         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 767                 return;
 768         spec->mixers[spec->num_mixers++] = mix;
 769 }
 770
 771 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 772 {
 773         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 774                 return;
 775         spec->init_verbs[spec->num_init_verbs++] = verb;
 776 }
 777
 778 #ifdef CONFIG_PROC_FS
 779 /*
 780  * hook for proc
 781  */
 782 static void print_realtek_coef(struct snd_info_buffer *buffer,
 783                                struct hda_codec *codec, hda_nid_t nid)
 784 {
 785         int coeff;
 786
 787         if (nid != 0x20)
 788                 return;
 789         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 790         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 791         coeff = snd_hda_codec_read(codec, nid, 0,
 792                                    AC_VERB_GET_COEF_INDEX, 0);
 793         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 794 }
 795 #else
 796 #define print_realtek_coef      NULL
 797 #endif
 798
 799 /*
 800  * set up from the preset table
 801  */
 802 static void setup_preset(struct alc_spec *spec,
 803                          const struct alc_config_preset *preset)
 804 {
 805         int i;
 806
 807         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 808                 add_mixer(spec, preset->mixers[i]);
 809         spec->cap_mixer = preset->cap_mixer;
 810         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 811              i++)
 812                 add_verb(spec, preset->init_verbs[i]);
 813
 814         spec->channel_mode = preset->channel_mode;
 815         spec->num_channel_mode = preset->num_channel_mode;
 816         spec->need_dac_fix = preset->need_dac_fix;
 817
 818         spec->multiout.max_channels = spec->channel_mode[0].channels;
 819
 820         spec->multiout.num_dacs = preset->num_dacs;
 821         spec->multiout.dac_nids = preset->dac_nids;
 822         spec->multiout.dig_out_nid = preset->dig_out_nid;
 823         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 824         spec->multiout.hp_nid = preset->hp_nid;
 825
 826         spec->num_mux_defs = preset->num_mux_defs;
 827         if (!spec->num_mux_defs)
 828                 spec->num_mux_defs = 1;
 829         spec->input_mux = preset->input_mux;
 830
 831         spec->num_adc_nids = preset->num_adc_nids;
 832         spec->adc_nids = preset->adc_nids;
 833         spec->capsrc_nids = preset->capsrc_nids;
 834         spec->dig_in_nid = preset->dig_in_nid;
 835
 836         spec->unsol_event = preset->unsol_event;
 837         spec->init_hook = preset->init_hook;
 838 #ifdef CONFIG_SND_HDA_POWER_SAVE
 839         spec->loopback.amplist = preset->loopbacks;
 840 #endif
 841 }
 842
 843 /* Enable GPIO mask and set output */
 844 static struct hda_verb alc_gpio1_init_verbs[] = {
 845         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 846         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 847         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 848         { }
 849 };
 850
 851 static struct hda_verb alc_gpio2_init_verbs[] = {
 852         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 853         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 854         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 855         { }
 856 };
 857
 858 static struct hda_verb alc_gpio3_init_verbs[] = {
 859         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 860         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 861         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 862         { }
 863 };
 864
 865 /*
 866  * Fix hardware PLL issue
 867  * On some codecs, the analog PLL gating control must be off while
 868  * the default value is 1.
 869  */
 870 static void alc_fix_pll(struct hda_codec *codec)
 871 {
 872         struct alc_spec *spec = codec->spec;
 873         unsigned int val;
 874
 875         if (!spec->pll_nid)
 876                 return;
 877         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 878                             spec->pll_coef_idx);
 879         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 880                                  AC_VERB_GET_PROC_COEF, 0);
 881         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 882                             spec->pll_coef_idx);
 883         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 884                             val & ~(1 << spec->pll_coef_bit));
 885 }
 886
 887 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 888                              unsigned int coef_idx, unsigned int coef_bit)
 889 {
 890         struct alc_spec *spec = codec->spec;
 891         spec->pll_nid = nid;
 892         spec->pll_coef_idx = coef_idx;
 893         spec->pll_coef_bit = coef_bit;
 894         alc_fix_pll(codec);
 895 }
 896
 897 static void alc_sku_automute(struct hda_codec *codec)
 898 {
 899         struct alc_spec *spec = codec->spec;
 900         unsigned int present;
 901         unsigned int hp_nid = spec->autocfg.hp_pins[0];
 902         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
 903
 904         /* need to execute and sync at first */
 905         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 906         present = snd_hda_codec_read(codec, hp_nid, 0,
 907                                      AC_VERB_GET_PIN_SENSE, 0);
 908         spec->jack_present = (present & 0x80000000) != 0;
 909         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 910                             spec->jack_present ? 0 : PIN_OUT);
 911 }
 912
 913 #if 0 /* it's broken in some acses -- temporarily disabled */
 914 static void alc_mic_automute(struct hda_codec *codec)
 915 {
 916         struct alc_spec *spec = codec->spec;
 917         unsigned int present;
 918         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 919         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 920         unsigned int mix_nid = spec->capsrc_nids[0];
 921         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 922
 923         capsrc_idx_mic = mic_nid - 0x18;
 924         capsrc_idx_fmic = fmic_nid - 0x18;
 925         present = snd_hda_codec_read(codec, mic_nid, 0,
 926                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 927         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 928                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 929         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 930                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 931         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 932                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 933 }
 934 #else
 935 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 936 #endif /* disabled */
 937
 938 /* unsolicited event for HP jack sensing */
 939 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 940 {
 941         if (codec->vendor_id == 0x10ec0880)
 942                 res >>= 28;
 943         else
 944                 res >>= 26;
 945         if (res == ALC880_HP_EVENT)
 946                 alc_sku_automute(codec);
 947
 948         if (res == ALC880_MIC_EVENT)
 949                 alc_mic_automute(codec);
 950 }
 951
 952 static void alc_inithook(struct hda_codec *codec)
 953 {
 954         alc_sku_automute(codec);
 955         alc_mic_automute(codec);
 956 }
 957
 958 /* additional initialization for ALC888 variants */
 959 static void alc888_coef_init(struct hda_codec *codec)
 960 {
 961         unsigned int tmp;
 962
 963         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
 964         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
 965         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
 966         if ((tmp & 0xf0) == 2)
 967                 /* alc888S-VC */
 968                 snd_hda_codec_read(codec, 0x20, 0,
 969                                    AC_VERB_SET_PROC_COEF, 0x830);
 970          else
 971                  /* alc888-VB */
 972                  snd_hda_codec_read(codec, 0x20, 0,
 973                                     AC_VERB_SET_PROC_COEF, 0x3030);
 974 }
 975
 976 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 977  *      31 ~ 16 :       Manufacture ID
 978  *      15 ~ 8  :       SKU ID
 979  *      7  ~ 0  :       Assembly ID
 980  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 981  */
 982 static void alc_subsystem_id(struct hda_codec *codec,
 983                              unsigned int porta, unsigned int porte,
 984                              unsigned int portd)
 985 {
 986         unsigned int ass, tmp, i;
 987         unsigned nid;
 988         struct alc_spec *spec = codec->spec;
 989
 990         ass = codec->subsystem_id & 0xffff;
 991         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
 992                 goto do_sku;
 993
 994         /*
 995          * 31~30        : port conetcivity
 996          * 29~21        : reserve
 997          * 20           : PCBEEP input
 998          * 19~16        : Check sum (15:1)
 999          * 15~1         : Custom
1000          * 0            : override
1001         */
1002         nid = 0x1d;
1003         if (codec->vendor_id == 0x10ec0260)
1004                 nid = 0x17;
1005         ass = snd_hda_codec_get_pincfg(codec, nid);
1006         if (!(ass & 1) && !(ass & 0x100000))
1007                 return;
1008         if ((ass >> 30) != 1)   /* no physical connection */
1009                 return;
1010
1011         /* check sum */
1012         tmp = 0;
1013         for (i = 1; i < 16; i++) {
1014                 if ((ass >> i) & 1)
1015                         tmp++;
1016         }
1017         if (((ass >> 16) & 0xf) != tmp)
1018                 return;
1019 do_sku:
1020         /*
1021          * 0 : override
1022          * 1 :  Swap Jack
1023          * 2 : 0 --> Desktop, 1 --> Laptop
1024          * 3~5 : External Amplifier control
1025          * 7~6 : Reserved
1026         */
1027         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1028         switch (tmp) {
1029         case 1:
1030                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1031                 break;
1032         case 3:
1033                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1034                 break;
1035         case 7:
1036                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1037                 break;
1038         case 5: /* set EAPD output high */
1039                 switch (codec->vendor_id) {
1040                 case 0x10ec0260:
1041                         snd_hda_codec_write(codec, 0x0f, 0,
1042                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1043                         snd_hda_codec_write(codec, 0x10, 0,
1044                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1045                         break;
1046                 case 0x10ec0262:
1047                 case 0x10ec0267:
1048                 case 0x10ec0268:
1049                 case 0x10ec0269:
1050                 case 0x10ec0272:
1051                 case 0x10ec0660:
1052                 case 0x10ec0662:
1053                 case 0x10ec0663:
1054                 case 0x10ec0862:
1055                 case 0x10ec0889:
1056                         snd_hda_codec_write(codec, 0x14, 0,
1057                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1058                         snd_hda_codec_write(codec, 0x15, 0,
1059                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1060                         break;
1061                 }
1062                 switch (codec->vendor_id) {
1063                 case 0x10ec0260:
1064                         snd_hda_codec_write(codec, 0x1a, 0,
1065                                             AC_VERB_SET_COEF_INDEX, 7);
1066                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1067                                                  AC_VERB_GET_PROC_COEF, 0);
1068                         snd_hda_codec_write(codec, 0x1a, 0,
1069                                             AC_VERB_SET_COEF_INDEX, 7);
1070                         snd_hda_codec_write(codec, 0x1a, 0,
1071                                             AC_VERB_SET_PROC_COEF,
1072                                             tmp | 0x2010);
1073                         break;
1074                 case 0x10ec0262:
1075                 case 0x10ec0880:
1076                 case 0x10ec0882:
1077                 case 0x10ec0883:
1078                 case 0x10ec0885:
1079                 case 0x10ec0887:
1080                 case 0x10ec0889:
1081                         snd_hda_codec_write(codec, 0x20, 0,
1082                                             AC_VERB_SET_COEF_INDEX, 7);
1083                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1084                                                  AC_VERB_GET_PROC_COEF, 0);
1085                         snd_hda_codec_write(codec, 0x20, 0,
1086                                             AC_VERB_SET_COEF_INDEX, 7);
1087                         snd_hda_codec_write(codec, 0x20, 0,
1088                                             AC_VERB_SET_PROC_COEF,
1089                                             tmp | 0x2010);
1090                         break;
1091                 case 0x10ec0888:
1092                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1093                         break;
1094                 case 0x10ec0267:
1095                 case 0x10ec0268:
1096                         snd_hda_codec_write(codec, 0x20, 0,
1097                                             AC_VERB_SET_COEF_INDEX, 7);
1098                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1099                                                  AC_VERB_GET_PROC_COEF, 0);
1100                         snd_hda_codec_write(codec, 0x20, 0,
1101                                             AC_VERB_SET_COEF_INDEX, 7);
1102                         snd_hda_codec_write(codec, 0x20, 0,
1103                                             AC_VERB_SET_PROC_COEF,
1104                                             tmp | 0x3000);
1105                         break;
1106                 }
1107         default:
1108                 break;
1109         }
1110
1111         /* is laptop or Desktop and enable the function "Mute internal speaker
1112          * when the external headphone out jack is plugged"
1113          */
1114         if (!(ass & 0x8000))
1115                 return;
1116         /*
1117          * 10~8 : Jack location
1118          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1119          * 14~13: Resvered
1120          * 15   : 1 --> enable the function "Mute internal speaker
1121          *              when the external headphone out jack is plugged"
1122          */
1123         if (!spec->autocfg.speaker_pins[0]) {
1124                 if (spec->autocfg.line_out_pins[0])
1125                         spec->autocfg.speaker_pins[0] =
1126                                 spec->autocfg.line_out_pins[0];
1127                 else
1128                         return;
1129         }
1130
1131         if (!spec->autocfg.hp_pins[0]) {
1132                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1133                 if (tmp == 0)
1134                         spec->autocfg.hp_pins[0] = porta;
1135                 else if (tmp == 1)
1136                         spec->autocfg.hp_pins[0] = porte;
1137                 else if (tmp == 2)
1138                         spec->autocfg.hp_pins[0] = portd;
1139                 else
1140                         return;
1141         }
1142         if (spec->autocfg.hp_pins[0])
1143                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1144                         AC_VERB_SET_UNSOLICITED_ENABLE,
1145                         AC_USRSP_EN | ALC880_HP_EVENT);
1146
1147 #if 0 /* it's broken in some acses -- temporarily disabled */
1148         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1149                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1150                 snd_hda_codec_write(codec,
1151                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1152                         AC_VERB_SET_UNSOLICITED_ENABLE,
1153                         AC_USRSP_EN | ALC880_MIC_EVENT);
1154 #endif /* disabled */
1155
1156         spec->unsol_event = alc_sku_unsol_event;
1157 }
1158
1159 /*
1160  * Fix-up pin default configurations
1161  */
1162
1163 struct alc_pincfg {
1164         hda_nid_t nid;
1165         u32 val;
1166 };
1167
1168 static void alc_fix_pincfg(struct hda_codec *codec,
1169                            const struct snd_pci_quirk *quirk,
1170                            const struct alc_pincfg **pinfix)
1171 {
1172         const struct alc_pincfg *cfg;
1173
1174         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1175         if (!quirk)
1176                 return;
1177
1178         cfg = pinfix[quirk->value];
1179         for (; cfg->nid; cfg++)
1180                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1181 }
1182
1183 /*
1184  * ALC888
1185  */
1186
1187 /*
1188  * 2ch mode
1189  */
1190 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1191 /* Mic-in jack as mic in */
1192         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1193         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1194 /* Line-in jack as Line in */
1195         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1196         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1197 /* Line-Out as Front */
1198         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1199         { } /* end */
1200 };
1201
1202 /*
1203  * 4ch mode
1204  */
1205 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1206 /* Mic-in jack as mic in */
1207         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1208         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1209 /* Line-in jack as Surround */
1210         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1211         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1212 /* Line-Out as Front */
1213         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1214         { } /* end */
1215 };
1216
1217 /*
1218  * 6ch mode
1219  */
1220 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1221 /* Mic-in jack as CLFE */
1222         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1223         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1224 /* Line-in jack as Surround */
1225         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1226         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1227 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1228         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1229         { } /* end */
1230 };
1231
1232 /*
1233  * 8ch mode
1234  */
1235 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1236 /* Mic-in jack as CLFE */
1237         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1238         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1239 /* Line-in jack as Surround */
1240         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1241         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1242 /* Line-Out as Side */
1243         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1244         { } /* end */
1245 };
1246
1247 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1248         { 2, alc888_4ST_ch2_intel_init },
1249         { 4, alc888_4ST_ch4_intel_init },
1250         { 6, alc888_4ST_ch6_intel_init },
1251         { 8, alc888_4ST_ch8_intel_init },
1252 };
1253
1254 /*
1255  * ALC888 Fujitsu Siemens Amillo xa3530
1256  */
1257
1258 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1259 /* Front Mic: set to PIN_IN (empty by default) */
1260         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1261 /* Connect Internal HP to Front */
1262         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1263         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1264         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1265 /* Connect Bass HP to Front */
1266         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1267         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1268         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1269 /* Connect Line-Out side jack (SPDIF) to Side */
1270         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1271         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1272         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1273 /* Connect Mic jack to CLFE */
1274         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1275         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1276         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1277 /* Connect Line-in jack to Surround */
1278         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1279         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1280         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1281 /* Connect HP out jack to Front */
1282         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1283         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1284         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1285 /* Enable unsolicited event for HP jack and Line-out jack */
1286         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1287         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1288         {}
1289 };
1290
1291 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1292 {
1293         unsigned int present;
1294         unsigned int bits;
1295         /* Line out presence */
1296         present = snd_hda_codec_read(codec, 0x17, 0,
1297                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1298         /* HP out presence */
1299         present = present || snd_hda_codec_read(codec, 0x1b, 0,
1300                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1301         bits = present ? HDA_AMP_MUTE : 0;
1302         /* Toggle internal speakers muting */
1303         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1304                                  HDA_AMP_MUTE, bits);
1305         /* Toggle internal bass muting */
1306         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1307                                  HDA_AMP_MUTE, bits);
1308 }
1309
1310 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1311                 unsigned int res)
1312 {
1313         if (res >> 26 == ALC880_HP_EVENT)
1314                 alc888_fujitsu_xa3530_automute(codec);
1315 }
1316
1317
1318 /*
1319  * ALC888 Acer Aspire 4930G model
1320  */
1321
1322 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1323 /* Front Mic: set to PIN_IN (empty by default) */
1324         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1325 /* Unselect Front Mic by default in input mixer 3 */
1326         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1327 /* Enable unsolicited event for HP jack */
1328         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1329 /* Connect Internal HP to front */
1330         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1331         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1332         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1333 /* Connect HP out to front */
1334         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1335         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1336         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1337         { }
1338 };
1339
1340 static struct hda_input_mux alc888_2_capture_sources[2] = {
1341         /* Front mic only available on one ADC */
1342         {
1343                 .num_items = 4,
1344                 .items = {
1345                         { "Mic", 0x0 },
1346                         { "Line", 0x2 },
1347                         { "CD", 0x4 },
1348                         { "Front Mic", 0xb },
1349                 },
1350         },
1351         {
1352                 .num_items = 3,
1353                 .items = {
1354                         { "Mic", 0x0 },
1355                         { "Line", 0x2 },
1356                         { "CD", 0x4 },
1357                 },
1358         }
1359 };
1360
1361 static struct snd_kcontrol_new alc888_base_mixer[] = {
1362         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1363         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1364         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1365         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1366         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1367                 HDA_OUTPUT),
1368         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1369         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1370         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1371         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1372         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1373         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1374         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1375         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1376         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1377         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1378         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1379         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1380         { } /* end */
1381 };
1382
1383 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1384 {
1385         unsigned int present;
1386         unsigned int bits;
1387         present = snd_hda_codec_read(codec, 0x15, 0,
1388                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1389         bits = present ? HDA_AMP_MUTE : 0;
1390         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1391                                  HDA_AMP_MUTE, bits);
1392 }
1393
1394 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1395                 unsigned int res)
1396 {
1397         if (res >> 26 == ALC880_HP_EVENT)
1398                 alc888_acer_aspire_4930g_automute(codec);
1399 }
1400
1401 /*
1402  * ALC880 3-stack model
1403  *
1404  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1405  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1406  *                 F-Mic = 0x1b, HP = 0x19
1407  */
1408
1409 static hda_nid_t alc880_dac_nids[4] = {
1410         /* front, rear, clfe, rear_surr */
1411         0x02, 0x05, 0x04, 0x03
1412 };
1413
1414 static hda_nid_t alc880_adc_nids[3] = {
1415         /* ADC0-2 */
1416         0x07, 0x08, 0x09,
1417 };
1418
1419 /* The datasheet says the node 0x07 is connected from inputs,
1420  * but it shows zero connection in the real implementation on some devices.
1421  * Note: this is a 915GAV bug, fixed on 915GLV
1422  */
1423 static hda_nid_t alc880_adc_nids_alt[2] = {
1424         /* ADC1-2 */
1425         0x08, 0x09,
1426 };
1427
1428 #define ALC880_DIGOUT_NID       0x06
1429 #define ALC880_DIGIN_NID        0x0a
1430
1431 static struct hda_input_mux alc880_capture_source = {
1432         .num_items = 4,
1433         .items = {
1434                 { "Mic", 0x0 },
1435                 { "Front Mic", 0x3 },
1436                 { "Line", 0x2 },
1437                 { "CD", 0x4 },
1438         },
1439 };
1440
1441 /* channel source setting (2/6 channel selection for 3-stack) */
1442 /* 2ch mode */
1443 static struct hda_verb alc880_threestack_ch2_init[] = {
1444         /* set line-in to input, mute it */
1445         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1446         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1447         /* set mic-in to input vref 80%, mute it */
1448         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1449         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1450         { } /* end */
1451 };
1452
1453 /* 6ch mode */
1454 static struct hda_verb alc880_threestack_ch6_init[] = {
1455         /* set line-in to output, unmute it */
1456         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1457         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1458         /* set mic-in to output, unmute it */
1459         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1460         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1461         { } /* end */
1462 };
1463
1464 static struct hda_channel_mode alc880_threestack_modes[2] = {
1465         { 2, alc880_threestack_ch2_init },
1466         { 6, alc880_threestack_ch6_init },
1467 };
1468
1469 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1470         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1471         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1472         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1473         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1474         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1475         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1476         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1477         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1478         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1479         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1480         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1481         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1482         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1483         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1484         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1485         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1486         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1487         {
1488                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1489                 .name = "Channel Mode",
1490                 .info = alc_ch_mode_info,
1491                 .get = alc_ch_mode_get,
1492                 .put = alc_ch_mode_put,
1493         },
1494         { } /* end */
1495 };
1496
1497 /* capture mixer elements */
1498 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1499                             struct snd_ctl_elem_info *uinfo)
1500 {
1501         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1502         struct alc_spec *spec = codec->spec;
1503         int err;
1504
1505         mutex_lock(&codec->control_mutex);
1506         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1507                                                       HDA_INPUT);
1508         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1509         mutex_unlock(&codec->control_mutex);
1510         return err;
1511 }
1512
1513 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1514                            unsigned int size, unsigned int __user *tlv)
1515 {
1516         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1517         struct alc_spec *spec = codec->spec;
1518         int err;
1519
1520         mutex_lock(&codec->control_mutex);
1521         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1522                                                       HDA_INPUT);
1523         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1524         mutex_unlock(&codec->control_mutex);
1525         return err;
1526 }
1527
1528 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1529                              struct snd_ctl_elem_value *ucontrol);
1530
1531 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1532                                  struct snd_ctl_elem_value *ucontrol,
1533                                  getput_call_t func)
1534 {
1535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536         struct alc_spec *spec = codec->spec;
1537         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1538         int err;
1539
1540         mutex_lock(&codec->control_mutex);
1541         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1542                                                       3, 0, HDA_INPUT);
1543         err = func(kcontrol, ucontrol);
1544         mutex_unlock(&codec->control_mutex);
1545         return err;
1546 }
1547
1548 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1549                            struct snd_ctl_elem_value *ucontrol)
1550 {
1551         return alc_cap_getput_caller(kcontrol, ucontrol,
1552                                      snd_hda_mixer_amp_volume_get);
1553 }
1554
1555 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1556                            struct snd_ctl_elem_value *ucontrol)
1557 {
1558         return alc_cap_getput_caller(kcontrol, ucontrol,
1559                                      snd_hda_mixer_amp_volume_put);
1560 }
1561
1562 /* capture mixer elements */
1563 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1564
1565 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1566                           struct snd_ctl_elem_value *ucontrol)
1567 {
1568         return alc_cap_getput_caller(kcontrol, ucontrol,
1569                                      snd_hda_mixer_amp_switch_get);
1570 }
1571
1572 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1573                           struct snd_ctl_elem_value *ucontrol)
1574 {
1575         return alc_cap_getput_caller(kcontrol, ucontrol,
1576                                      snd_hda_mixer_amp_switch_put);
1577 }
1578
1579 #define DEFINE_CAPMIX(num) \
1580 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1581         { \
1582                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1583                 .name = "Capture Switch", \
1584                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1585                 .count = num, \
1586                 .info = alc_cap_sw_info, \
1587                 .get = alc_cap_sw_get, \
1588                 .put = alc_cap_sw_put, \
1589         }, \
1590         { \
1591                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1592                 .name = "Capture Volume", \
1593                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1594                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1595                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1596                 .count = num, \
1597                 .info = alc_cap_vol_info, \
1598                 .get = alc_cap_vol_get, \
1599                 .put = alc_cap_vol_put, \
1600                 .tlv = { .c = alc_cap_vol_tlv }, \
1601         }, \
1602         { \
1603                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1604                 /* .name = "Capture Source", */ \
1605                 .name = "Input Source", \
1606                 .count = num, \
1607                 .info = alc_mux_enum_info, \
1608                 .get = alc_mux_enum_get, \
1609                 .put = alc_mux_enum_put, \
1610         }, \
1611         { } /* end */ \
1612 }
1613
1614 /* up to three ADCs */
1615 DEFINE_CAPMIX(1);
1616 DEFINE_CAPMIX(2);
1617 DEFINE_CAPMIX(3);
1618
1619
1620 /*
1621  * ALC880 5-stack model
1622  *
1623  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1624  *      Side = 0x02 (0xd)
1625  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1626  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1627  */
1628
1629 /* additional mixers to alc880_three_stack_mixer */
1630 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1631         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1632         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1633         { } /* end */
1634 };
1635
1636 /* channel source setting (6/8 channel selection for 5-stack) */
1637 /* 6ch mode */
1638 static struct hda_verb alc880_fivestack_ch6_init[] = {
1639         /* set line-in to input, mute it */
1640         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1641         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1642         { } /* end */
1643 };
1644
1645 /* 8ch mode */
1646 static struct hda_verb alc880_fivestack_ch8_init[] = {
1647         /* set line-in to output, unmute it */
1648         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1649         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1650         { } /* end */
1651 };
1652
1653 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1654         { 6, alc880_fivestack_ch6_init },
1655         { 8, alc880_fivestack_ch8_init },
1656 };
1657
1658
1659 /*
1660  * ALC880 6-stack model
1661  *
1662  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1663  *      Side = 0x05 (0x0f)
1664  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1665  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1666  */
1667
1668 static hda_nid_t alc880_6st_dac_nids[4] = {
1669         /* front, rear, clfe, rear_surr */
1670         0x02, 0x03, 0x04, 0x05
1671 };
1672
1673 static struct hda_input_mux alc880_6stack_capture_source = {
1674         .num_items = 4,
1675         .items = {
1676                 { "Mic", 0x0 },
1677                 { "Front Mic", 0x1 },
1678                 { "Line", 0x2 },
1679                 { "CD", 0x4 },
1680         },
1681 };
1682
1683 /* fixed 8-channels */
1684 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1685         { 8, NULL },
1686 };
1687
1688 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1689         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1690         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1691         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1692         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1693         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1694         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1695         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1696         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1697         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1698         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1699         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1700         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1701         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1702         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1703         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1704         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1705         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1706         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1707         {
1708                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1709                 .name = "Channel Mode",
1710                 .info = alc_ch_mode_info,
1711                 .get = alc_ch_mode_get,
1712                 .put = alc_ch_mode_put,
1713         },
1714         { } /* end */
1715 };
1716
1717
1718 /*
1719  * ALC880 W810 model
1720  *
1721  * W810 has rear IO for:
1722  * Front (DAC 02)
1723  * Surround (DAC 03)
1724  * Center/LFE (DAC 04)
1725  * Digital out (06)
1726  *
1727  * The system also has a pair of internal speakers, and a headphone jack.
1728  * These are both connected to Line2 on the codec, hence to DAC 02.
1729  *
1730  * There is a variable resistor to control the speaker or headphone
1731  * volume. This is a hardware-only device without a software API.
1732  *
1733  * Plugging headphones in will disable the internal speakers. This is
1734  * implemented in hardware, not via the driver using jack sense. In
1735  * a similar fashion, plugging into the rear socket marked "front" will
1736  * disable both the speakers and headphones.
1737  *
1738  * For input, there's a microphone jack, and an "audio in" jack.
1739  * These may not do anything useful with this driver yet, because I
1740  * haven't setup any initialization verbs for these yet...
1741  */
1742
1743 static hda_nid_t alc880_w810_dac_nids[3] = {
1744         /* front, rear/surround, clfe */
1745         0x02, 0x03, 0x04
1746 };
1747
1748 /* fixed 6 channels */
1749 static struct hda_channel_mode alc880_w810_modes[1] = {
1750         { 6, NULL }
1751 };
1752
1753 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1754 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1755         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1756         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1757         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1758         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1759         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1760         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1761         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1762         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1763         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1764         { } /* end */
1765 };
1766
1767
1768 /*
1769  * Z710V model
1770  *
1771  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1772  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1773  *                 Line = 0x1a
1774  */
1775
1776 static hda_nid_t alc880_z71v_dac_nids[1] = {
1777         0x02
1778 };
1779 #define ALC880_Z71V_HP_DAC      0x03
1780
1781 /* fixed 2 channels */
1782 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1783         { 2, NULL }
1784 };
1785
1786 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1787         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1788         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1789         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1790         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1791         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1792         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1793         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1794         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1795         { } /* end */
1796 };
1797
1798
1799 /*
1800  * ALC880 F1734 model
1801  *
1802  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1803  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1804  */
1805
1806 static hda_nid_t alc880_f1734_dac_nids[1] = {
1807         0x03
1808 };
1809 #define ALC880_F1734_HP_DAC     0x02
1810
1811 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1812         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1813         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1814         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1815         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1816         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1817         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1818         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1819         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1820         { } /* end */
1821 };
1822
1823 static struct hda_input_mux alc880_f1734_capture_source = {
1824         .num_items = 2,
1825         .items = {
1826                 { "Mic", 0x1 },
1827                 { "CD", 0x4 },
1828         },
1829 };
1830
1831
1832 /*
1833  * ALC880 ASUS model
1834  *
1835  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1836  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1837  *  Mic = 0x18, Line = 0x1a
1838  */
1839
1840 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1841 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1842
1843 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1844         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1845         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1846         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1847         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1848         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1849         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1850         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1851         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1852         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1853         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1854         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1855         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1856         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1857         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1858         {
1859                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1860                 .name = "Channel Mode",
1861                 .info = alc_ch_mode_info,
1862                 .get = alc_ch_mode_get,
1863                 .put = alc_ch_mode_put,
1864         },
1865         { } /* end */
1866 };
1867
1868 /*
1869  * ALC880 ASUS W1V model
1870  *
1871  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1872  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1873  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1874  */
1875
1876 /* additional mixers to alc880_asus_mixer */
1877 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1878         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1879         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1880         { } /* end */
1881 };
1882
1883 /* TCL S700 */
1884 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1885         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1886         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1887         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1888         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1889         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1890         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1891         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1892         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1893         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1894         { } /* end */
1895 };
1896
1897 /* Uniwill */
1898 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1899         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1900         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1901         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1902         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1903         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1904         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1905         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1906         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1907         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1908         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1909         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1910         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1911         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1912         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1913         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1914         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1915         {
1916                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1917                 .name = "Channel Mode",
1918                 .info = alc_ch_mode_info,
1919                 .get = alc_ch_mode_get,
1920                 .put = alc_ch_mode_put,
1921         },
1922         { } /* end */
1923 };
1924
1925 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1926         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1927         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1928         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1929         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1930         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1931         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1932         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1933         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1934         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1935         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1936         { } /* end */
1937 };
1938
1939 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1940         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1941         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1942         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1943         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1944         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1945         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1946         { } /* end */
1947 };
1948
1949 /*
1950  * virtual master controls
1951  */
1952
1953 /*
1954  * slave controls for virtual master
1955  */
1956 static const char *alc_slave_vols[] = {
1957         "Front Playback Volume",
1958         "Surround Playback Volume",
1959         "Center Playback Volume",
1960         "LFE Playback Volume",
1961         "Side Playback Volume",
1962         "Headphone Playback Volume",
1963         "Speaker Playback Volume",
1964         "Mono Playback Volume",
1965         "Line-Out Playback Volume",
1966         "PCM Playback Volume",
1967         NULL,
1968 };
1969
1970 static const char *alc_slave_sws[] = {
1971         "Front Playback Switch",
1972         "Surround Playback Switch",
1973         "Center Playback Switch",
1974         "LFE Playback Switch",
1975         "Side Playback Switch",
1976         "Headphone Playback Switch",
1977         "Speaker Playback Switch",
1978         "Mono Playback Switch",
1979         "IEC958 Playback Switch",
1980         NULL,
1981 };
1982
1983 /*
1984  * build control elements
1985  */
1986
1987 static void alc_free_kctls(struct hda_codec *codec);
1988
1989 /* additional beep mixers; the actual parameters are overwritten at build */
1990 static struct snd_kcontrol_new alc_beep_mixer[] = {
1991         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1992         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
1993         { } /* end */
1994 };
1995
1996 static int alc_build_controls(struct hda_codec *codec)
1997 {
1998         struct alc_spec *spec = codec->spec;
1999         int err;
2000         int i;
2001
2002         for (i = 0; i < spec->num_mixers; i++) {
2003                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2004                 if (err < 0)
2005                         return err;
2006         }
2007         if (spec->cap_mixer) {
2008                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2009                 if (err < 0)
2010                         return err;
2011         }
2012         if (spec->multiout.dig_out_nid) {
2013                 err = snd_hda_create_spdif_out_ctls(codec,
2014                                                     spec->multiout.dig_out_nid);
2015                 if (err < 0)
2016                         return err;
2017                 if (!spec->no_analog) {
2018                         err = snd_hda_create_spdif_share_sw(codec,
2019                                                             &spec->multiout);
2020                         if (err < 0)
2021                                 return err;
2022                         spec->multiout.share_spdif = 1;
2023                 }
2024         }
2025         if (spec->dig_in_nid) {
2026                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2027                 if (err < 0)
2028                         return err;
2029         }
2030
2031         /* create beep controls if needed */
2032         if (spec->beep_amp) {
2033                 struct snd_kcontrol_new *knew;
2034                 for (knew = alc_beep_mixer; knew->name; knew++) {
2035                         struct snd_kcontrol *kctl;
2036                         kctl = snd_ctl_new1(knew, codec);
2037                         if (!kctl)
2038                                 return -ENOMEM;
2039                         kctl->private_value = spec->beep_amp;
2040                         err = snd_hda_ctl_add(codec, kctl);
2041                         if (err < 0)
2042                                 return err;
2043                 }
2044         }
2045
2046         /* if we have no master control, let's create it */
2047         if (!spec->no_analog &&
2048             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2049                 unsigned int vmaster_tlv[4];
2050                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2051                                         HDA_OUTPUT, vmaster_tlv);
2052                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2053                                           vmaster_tlv, alc_slave_vols);
2054                 if (err < 0)
2055                         return err;
2056         }
2057         if (!spec->no_analog &&
2058             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2059                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2060                                           NULL, alc_slave_sws);
2061                 if (err < 0)
2062                         return err;
2063         }
2064
2065         alc_free_kctls(codec); /* no longer needed */
2066         return 0;
2067 }
2068
2069
2070 /*
2071  * initialize the codec volumes, etc
2072  */
2073
2074 /*
2075  * generic initialization of ADC, input mixers and output mixers
2076  */
2077 static struct hda_verb alc880_volume_init_verbs[] = {
2078         /*
2079          * Unmute ADC0-2 and set the default input to mic-in
2080          */
2081         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2082         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2083         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2084         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2085         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2086         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2087
2088         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2089          * mixer widget
2090          * Note: PASD motherboards uses the Line In 2 as the input for front
2091          * panel mic (mic 2)
2092          */
2093         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2094         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2095         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2096         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2097         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2098         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2099         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2101
2102         /*
2103          * Set up output mixers (0x0c - 0x0f)
2104          */
2105         /* set vol=0 to output mixers */
2106         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2107         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2108         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2109         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2110         /* set up input amps for analog loopback */
2111         /* Amp Indices: DAC = 0, mixer = 1 */
2112         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2113         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2114         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2115         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2116         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2117         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2118         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2119         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2120
2121         { }
2122 };
2123
2124 /*
2125  * 3-stack pin configuration:
2126  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2127  */
2128 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2129         /*
2130          * preset connection lists of input pins
2131          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2132          */
2133         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2134         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2135         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2136
2137         /*
2138          * Set pin mode and muting
2139          */
2140         /* set front pin widgets 0x14 for output */
2141         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2142         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2143         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2144         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2145         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2146         /* Mic2 (as headphone out) for HP output */
2147         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2148         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2149         /* Line In pin widget for input */
2150         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2151         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2152         /* Line2 (as front mic) pin widget for input and vref at 80% */
2153         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2154         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2155         /* CD pin widget for input */
2156         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2157
2158         { }
2159 };
2160
2161 /*
2162  * 5-stack pin configuration:
2163  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2164  * line-in/side = 0x1a, f-mic = 0x1b
2165  */
2166 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2167         /*
2168          * preset connection lists of input pins
2169          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2170          */
2171         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2172         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2173
2174         /*
2175          * Set pin mode and muting
2176          */
2177         /* set pin widgets 0x14-0x17 for output */
2178         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2179         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2180         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2181         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2182         /* unmute pins for output (no gain on this amp) */
2183         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2184         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2185         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2186         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2187
2188         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2189         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2190         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2191         /* Mic2 (as headphone out) for HP output */
2192         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2193         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2194         /* Line In pin widget for input */
2195         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2196         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2197         /* Line2 (as front mic) pin widget for input and vref at 80% */
2198         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2199         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2200         /* CD pin widget for input */
2201         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2202
2203         { }
2204 };
2205
2206 /*
2207  * W810 pin configuration:
2208  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2209  */
2210 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2211         /* hphone/speaker input selector: front DAC */
2212         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2213
2214         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2215         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2216         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2217         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2218         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2219         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2220
2221         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2222         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2223
2224         { }
2225 };
2226
2227 /*
2228  * Z71V pin configuration:
2229  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2230  */
2231 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2232         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2233         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2234         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2235         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2236
2237         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2238         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2239         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2240         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2241
2242         { }
2243 };
2244
2245 /*
2246  * 6-stack pin configuration:
2247  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2248  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2249  */
2250 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2251         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2252
2253         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2254         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2255         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2256         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2257         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2258         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2259         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2260         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2261
2262         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2263         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2264         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2265         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2266         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2267         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2268         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2269         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2270         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2271
2272         { }
2273 };
2274
2275 /*
2276  * Uniwill pin configuration:
2277  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2278  * line = 0x1a
2279  */
2280 static struct hda_verb alc880_uniwill_init_verbs[] = {
2281         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2282
2283         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2284         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2285         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2286         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2287         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2288         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2289         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2290         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2291         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2292         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2293         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2294         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2295         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2296         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2297
2298         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2299         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2300         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2301         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2302         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2303         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2304         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2305         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2306         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2307
2308         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2309         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2310
2311         { }
2312 };
2313
2314 /*
2315 * Uniwill P53
2316 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2317  */
2318 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2319         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2320
2321         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2322         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2323         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2324         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2325         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2326         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2327         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2328         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2329         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2330         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2331         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2332         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2333
2334         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2335         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2336         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2337         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2338         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2339         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2340
2341         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2342         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2343
2344         { }
2345 };
2346
2347 static struct hda_verb alc880_beep_init_verbs[] = {
2348         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2349         { }
2350 };
2351
2352 /* toggle speaker-output according to the hp-jack state */
2353 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2354 {
2355         unsigned int present;
2356         unsigned char bits;
2357
2358         present = snd_hda_codec_read(codec, 0x14, 0,
2359                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2360         bits = present ? HDA_AMP_MUTE : 0;
2361         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2362                                  HDA_AMP_MUTE, bits);
2363         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2364                                  HDA_AMP_MUTE, bits);
2365 }
2366
2367 /* auto-toggle front mic */
2368 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2369 {
2370         unsigned int present;
2371         unsigned char bits;
2372
2373         present = snd_hda_codec_read(codec, 0x18, 0,
2374                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2375         bits = present ? HDA_AMP_MUTE : 0;
2376         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2377 }
2378
2379 static void alc880_uniwill_automute(struct hda_codec *codec)
2380 {
2381         alc880_uniwill_hp_automute(codec);
2382         alc880_uniwill_mic_automute(codec);
2383 }
2384
2385 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2386                                        unsigned int res)
2387 {
2388         /* Looks like the unsol event is incompatible with the standard
2389          * definition.  4bit tag is placed at 28 bit!
2390          */
2391         switch (res >> 28) {
2392         case ALC880_HP_EVENT:
2393                 alc880_uniwill_hp_automute(codec);
2394                 break;
2395         case ALC880_MIC_EVENT:
2396                 alc880_uniwill_mic_automute(codec);
2397                 break;
2398         }
2399 }
2400
2401 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2402 {
2403         unsigned int present;
2404         unsigned char bits;
2405
2406         present = snd_hda_codec_read(codec, 0x14, 0,
2407                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2408         bits = present ? HDA_AMP_MUTE : 0;
2409         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2410 }
2411
2412 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2413 {
2414         unsigned int present;
2415
2416         present = snd_hda_codec_read(codec, 0x21, 0,
2417                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2418         present &= HDA_AMP_VOLMASK;
2419         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2420                                  HDA_AMP_VOLMASK, present);
2421         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2422                                  HDA_AMP_VOLMASK, present);
2423 }
2424
2425 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2426                                            unsigned int res)
2427 {
2428         /* Looks like the unsol event is incompatible with the standard
2429          * definition.  4bit tag is placed at 28 bit!
2430          */
2431         if ((res >> 28) == ALC880_HP_EVENT)
2432                 alc880_uniwill_p53_hp_automute(codec);
2433         if ((res >> 28) == ALC880_DCVOL_EVENT)
2434                 alc880_uniwill_p53_dcvol_automute(codec);
2435 }
2436
2437 /*
2438  * F1734 pin configuration:
2439  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2440  */
2441 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2442         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2443         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2444         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2445         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2446         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2447
2448         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2449         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2450         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2451         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2452
2453         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2454         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2455         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2456         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2457         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2458         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2459         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2460         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2461         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2462
2463         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2464         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2465
2466         { }
2467 };
2468
2469 /*
2470  * ASUS pin configuration:
2471  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2472  */
2473 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2474         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2475         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2476         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2477         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2478
2479         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2480         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2481         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2482         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2483         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2484         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2485         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2486         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2487
2488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2489         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2490         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2491         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2492         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2493         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2494         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2495         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2496         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2497
2498         { }
2499 };
2500
2501 /* Enable GPIO mask and set output */
2502 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2503 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2504
2505 /* Clevo m520g init */
2506 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2507         /* headphone output */
2508         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2509         /* line-out */
2510         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2511         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2512         /* Line-in */
2513         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2514         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2515         /* CD */
2516         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2517         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2518         /* Mic1 (rear panel) */
2519         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2520         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2521         /* Mic2 (front panel) */
2522         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2523         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2524         /* headphone */
2525         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2526         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2527         /* change to EAPD mode */
2528         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2529         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2530
2531         { }
2532 };
2533
2534 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2535         /* change to EAPD mode */
2536         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2537         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2538
2539         /* Headphone output */
2540         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2541         /* Front output*/
2542         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2543         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2544
2545         /* Line In pin widget for input */
2546         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2547         /* CD pin widget for input */
2548         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2549         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2550         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2551
2552         /* change to EAPD mode */
2553         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2554         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2555
2556         { }
2557 };
2558
2559 /*
2560  * LG m1 express dual
2561  *
2562  * Pin assignment:
2563  *   Rear Line-In/Out (blue): 0x14
2564  *   Build-in Mic-In: 0x15
2565  *   Speaker-out: 0x17
2566  *   HP-Out (green): 0x1b
2567  *   Mic-In/Out (red): 0x19
2568  *   SPDIF-Out: 0x1e
2569  */
2570
2571 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2572 static hda_nid_t alc880_lg_dac_nids[3] = {
2573         0x05, 0x02, 0x03
2574 };
2575
2576 /* seems analog CD is not working */
2577 static struct hda_input_mux alc880_lg_capture_source = {
2578         .num_items = 3,
2579         .items = {
2580                 { "Mic", 0x1 },
2581                 { "Line", 0x5 },
2582                 { "Internal Mic", 0x6 },
2583         },
2584 };
2585
2586 /* 2,4,6 channel modes */
2587 static struct hda_verb alc880_lg_ch2_init[] = {
2588         /* set line-in and mic-in to input */
2589         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2590         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2591         { }
2592 };
2593
2594 static struct hda_verb alc880_lg_ch4_init[] = {
2595         /* set line-in to out and mic-in to input */
2596         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2597         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2598         { }
2599 };
2600
2601 static struct hda_verb alc880_lg_ch6_init[] = {
2602         /* set line-in and mic-in to output */
2603         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2604         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2605         { }
2606 };
2607
2608 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2609         { 2, alc880_lg_ch2_init },
2610         { 4, alc880_lg_ch4_init },
2611         { 6, alc880_lg_ch6_init },
2612 };
2613
2614 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2615         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2616         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2617         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2618         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2619         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2620         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2621         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2622         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2623         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2624         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2625         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2626         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2627         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2628         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2629         {
2630                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2631                 .name = "Channel Mode",
2632                 .info = alc_ch_mode_info,
2633                 .get = alc_ch_mode_get,
2634                 .put = alc_ch_mode_put,
2635         },
2636         { } /* end */
2637 };
2638
2639 static struct hda_verb alc880_lg_init_verbs[] = {
2640         /* set capture source to mic-in */
2641         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2642         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2643         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2644         /* mute all amp mixer inputs */
2645         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2646         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2647         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2648         /* line-in to input */
2649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2650         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2651         /* built-in mic */
2652         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2653         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2654         /* speaker-out */
2655         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2656         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2657         /* mic-in to input */
2658         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2659         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2660         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2661         /* HP-out */
2662         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2663         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2664         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2665         /* jack sense */
2666         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2667         { }
2668 };
2669
2670 /* toggle speaker-output according to the hp-jack state */
2671 static void alc880_lg_automute(struct hda_codec *codec)
2672 {
2673         unsigned int present;
2674         unsigned char bits;
2675
2676         present = snd_hda_codec_read(codec, 0x1b, 0,
2677                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2678         bits = present ? HDA_AMP_MUTE : 0;
2679         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2680                                  HDA_AMP_MUTE, bits);
2681 }
2682
2683 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2684 {
2685         /* Looks like the unsol event is incompatible with the standard
2686          * definition.  4bit tag is placed at 28 bit!
2687          */
2688         if ((res >> 28) == 0x01)
2689                 alc880_lg_automute(codec);
2690 }
2691
2692 /*
2693  * LG LW20
2694  *
2695  * Pin assignment:
2696  *   Speaker-out: 0x14
2697  *   Mic-In: 0x18
2698  *   Built-in Mic-In: 0x19
2699  *   Line-In: 0x1b
2700  *   HP-Out: 0x1a
2701  *   SPDIF-Out: 0x1e
2702  */
2703
2704 static struct hda_input_mux alc880_lg_lw_capture_source = {
2705         .num_items = 3,
2706         .items = {
2707                 { "Mic", 0x0 },
2708                 { "Internal Mic", 0x1 },
2709                 { "Line In", 0x2 },
2710         },
2711 };
2712
2713 #define alc880_lg_lw_modes alc880_threestack_modes
2714
2715 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2716         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2717         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2718         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2719         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2720         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2721         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2722         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2723         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2724         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2725         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2726         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2727         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2728         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2729         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2730         {
2731                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2732                 .name = "Channel Mode",
2733                 .info = alc_ch_mode_info,
2734                 .get = alc_ch_mode_get,
2735                 .put = alc_ch_mode_put,
2736         },
2737         { } /* end */
2738 };
2739
2740 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2741         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2742         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2743         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2744
2745         /* set capture source to mic-in */
2746         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2747         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2748         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2749         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2750         /* speaker-out */
2751         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2752         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2753         /* HP-out */
2754         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2755         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2756         /* mic-in to input */
2757         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2758         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2759         /* built-in mic */
2760         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2761         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2762         /* jack sense */
2763         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2764         { }
2765 };
2766
2767 /* toggle speaker-output according to the hp-jack state */
2768 static void alc880_lg_lw_automute(struct hda_codec *codec)
2769 {
2770         unsigned int present;
2771         unsigned char bits;
2772
2773         present = snd_hda_codec_read(codec, 0x1b, 0,
2774                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2775         bits = present ? HDA_AMP_MUTE : 0;
2776         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2777                                  HDA_AMP_MUTE, bits);
2778 }
2779
2780 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2781 {
2782         /* Looks like the unsol event is incompatible with the standard
2783          * definition.  4bit tag is placed at 28 bit!
2784          */
2785         if ((res >> 28) == 0x01)
2786                 alc880_lg_lw_automute(codec);
2787 }
2788
2789 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2790         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2791         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2792         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2793         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2794         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2795         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2796         { } /* end */
2797 };
2798
2799 static struct hda_input_mux alc880_medion_rim_capture_source = {
2800         .num_items = 2,
2801         .items = {
2802                 { "Mic", 0x0 },
2803                 { "Internal Mic", 0x1 },
2804         },
2805 };
2806
2807 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2808         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2809
2810         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2811         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2812
2813         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2814         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2815         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2816         /* Mic2 (as headphone out) for HP output */
2817         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2818         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2819         /* Internal Speaker */
2820         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2821         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2822
2823         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2824         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2825
2826         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2827         { }
2828 };
2829
2830 /* toggle speaker-output according to the hp-jack state */
2831 static void alc880_medion_rim_automute(struct hda_codec *codec)
2832 {
2833         unsigned int present;
2834         unsigned char bits;
2835
2836         present = snd_hda_codec_read(codec, 0x14, 0,
2837                                      AC_VERB_GET_PIN_SENSE, 0)
2838                 & AC_PINSENSE_PRESENCE;
2839         bits = present ? HDA_AMP_MUTE : 0;
2840         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2841                                  HDA_AMP_MUTE, bits);
2842         if (present)
2843                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2844         else
2845                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2846 }
2847
2848 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2849                                           unsigned int res)
2850 {
2851         /* Looks like the unsol event is incompatible with the standard
2852          * definition.  4bit tag is placed at 28 bit!
2853          */
2854         if ((res >> 28) == ALC880_HP_EVENT)
2855                 alc880_medion_rim_automute(codec);
2856 }
2857
2858 #ifdef CONFIG_SND_HDA_POWER_SAVE
2859 static struct hda_amp_list alc880_loopbacks[] = {
2860         { 0x0b, HDA_INPUT, 0 },
2861         { 0x0b, HDA_INPUT, 1 },
2862         { 0x0b, HDA_INPUT, 2 },
2863         { 0x0b, HDA_INPUT, 3 },
2864         { 0x0b, HDA_INPUT, 4 },
2865         { } /* end */
2866 };
2867
2868 static struct hda_amp_list alc880_lg_loopbacks[] = {
2869         { 0x0b, HDA_INPUT, 1 },
2870         { 0x0b, HDA_INPUT, 6 },
2871         { 0x0b, HDA_INPUT, 7 },
2872         { } /* end */
2873 };
2874 #endif
2875
2876 /*
2877  * Common callbacks
2878  */
2879
2880 static int alc_init(struct hda_codec *codec)
2881 {
2882         struct alc_spec *spec = codec->spec;
2883         unsigned int i;
2884
2885         alc_fix_pll(codec);
2886         if (codec->vendor_id == 0x10ec0888)
2887                 alc888_coef_init(codec);
2888
2889         for (i = 0; i < spec->num_init_verbs; i++)
2890                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2891
2892         if (spec->init_hook)
2893                 spec->init_hook(codec);
2894
2895         return 0;
2896 }
2897
2898 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2899 {
2900         struct alc_spec *spec = codec->spec;
2901
2902         if (spec->unsol_event)
2903                 spec->unsol_event(codec, res);
2904 }
2905
2906 #ifdef CONFIG_SND_HDA_POWER_SAVE
2907 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2908 {
2909         struct alc_spec *spec = codec->spec;
2910         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2911 }
2912 #endif
2913
2914 /*
2915  * Analog playback callbacks
2916  */
2917 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2918                                     struct hda_codec *codec,
2919                                     struct snd_pcm_substream *substream)
2920 {
2921         struct alc_spec *spec = codec->spec;
2922         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2923                                              hinfo);
2924 }
2925
2926 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2927                                        struct hda_codec *codec,
2928                                        unsigned int stream_tag,
2929                                        unsigned int format,
2930                                        struct snd_pcm_substream *substream)
2931 {
2932         struct alc_spec *spec = codec->spec;
2933         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2934                                                 stream_tag, format, substream);
2935 }
2936
2937 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2938                                        struct hda_codec *codec,
2939                                        struct snd_pcm_substream *substream)
2940 {
2941         struct alc_spec *spec = codec->spec;
2942         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2943 }
2944
2945 /*
2946  * Digital out
2947  */
2948 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2949                                         struct hda_codec *codec,
2950                                         struct snd_pcm_substream *substream)
2951 {
2952         struct alc_spec *spec = codec->spec;
2953         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2954 }
2955
2956 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2957                                            struct hda_codec *codec,
2958                                            unsigned int stream_tag,
2959                                            unsigned int format,
2960                                            struct snd_pcm_substream *substream)
2961 {
2962         struct alc_spec *spec = codec->spec;
2963         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2964                                              stream_tag, format, substream);
2965 }
2966
2967 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2968                                            struct hda_codec *codec,
2969                                            struct snd_pcm_substream *substream)
2970 {
2971         struct alc_spec *spec = codec->spec;
2972         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2973 }
2974
2975 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2976                                          struct hda_codec *codec,
2977                                          struct snd_pcm_substream *substream)
2978 {
2979         struct alc_spec *spec = codec->spec;
2980         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2981 }
2982
2983 /*
2984  * Analog capture
2985  */
2986 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2987                                       struct hda_codec *codec,
2988                                       unsigned int stream_tag,
2989                                       unsigned int format,
2990                                       struct snd_pcm_substream *substream)
2991 {
2992         struct alc_spec *spec = codec->spec;
2993
2994         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2995                                    stream_tag, 0, format);
2996         return 0;
2997 }
2998
2999 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3000                                       struct hda_codec *codec,
3001                                       struct snd_pcm_substream *substream)
3002 {
3003         struct alc_spec *spec = codec->spec;
3004
3005         snd_hda_codec_cleanup_stream(codec,
3006                                      spec->adc_nids[substream->number + 1]);
3007         return 0;
3008 }
3009
3010
3011 /*
3012  */
3013 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3014         .substreams = 1,
3015         .channels_min = 2,
3016         .channels_max = 8,
3017         /* NID is set in alc_build_pcms */
3018         .ops = {
3019                 .open = alc880_playback_pcm_open,
3020                 .prepare = alc880_playback_pcm_prepare,
3021                 .cleanup = alc880_playback_pcm_cleanup
3022         },
3023 };
3024
3025 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3026         .substreams = 1,
3027         .channels_min = 2,
3028         .channels_max = 2,
3029         /* NID is set in alc_build_pcms */
3030 };
3031
3032 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3033         .substreams = 1,
3034         .channels_min = 2,
3035         .channels_max = 2,
3036         /* NID is set in alc_build_pcms */
3037 };
3038
3039 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3040         .substreams = 2, /* can be overridden */
3041         .channels_min = 2,
3042         .channels_max = 2,
3043         /* NID is set in alc_build_pcms */
3044         .ops = {
3045                 .prepare = alc880_alt_capture_pcm_prepare,
3046                 .cleanup = alc880_alt_capture_pcm_cleanup
3047         },
3048 };
3049
3050 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3051         .substreams = 1,
3052         .channels_min = 2,
3053         .channels_max = 2,
3054         /* NID is set in alc_build_pcms */
3055         .ops = {
3056                 .open = alc880_dig_playback_pcm_open,
3057                 .close = alc880_dig_playback_pcm_close,
3058                 .prepare = alc880_dig_playback_pcm_prepare,
3059                 .cleanup = alc880_dig_playback_pcm_cleanup
3060         },
3061 };
3062
3063 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3064         .substreams = 1,
3065         .channels_min = 2,
3066         .channels_max = 2,
3067         /* NID is set in alc_build_pcms */
3068 };
3069
3070 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3071 static struct hda_pcm_stream alc_pcm_null_stream = {
3072         .substreams = 0,
3073         .channels_min = 0,
3074         .channels_max = 0,
3075 };
3076
3077 static int alc_build_pcms(struct hda_codec *codec)
3078 {
3079         struct alc_spec *spec = codec->spec;
3080         struct hda_pcm *info = spec->pcm_rec;
3081         int i;
3082
3083         codec->num_pcms = 1;
3084         codec->pcm_info = info;
3085
3086         if (spec->no_analog)
3087                 goto skip_analog;
3088
3089         info->name = spec->stream_name_analog;
3090         if (spec->stream_analog_playback) {
3091                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3092                         return -EINVAL;
3093                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3094                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3095         }
3096         if (spec->stream_analog_capture) {
3097                 if (snd_BUG_ON(!spec->adc_nids))
3098                         return -EINVAL;
3099                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3100                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3101         }
3102
3103         if (spec->channel_mode) {
3104                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3105                 for (i = 0; i < spec->num_channel_mode; i++) {
3106                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3107                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3108                         }
3109                 }
3110         }
3111
3112  skip_analog:
3113         /* SPDIF for stream index #1 */
3114         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3115                 codec->num_pcms = 2;
3116                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3117                 info = spec->pcm_rec + 1;
3118                 info->name = spec->stream_name_digital;
3119                 if (spec->dig_out_type)
3120                         info->pcm_type = spec->dig_out_type;
3121                 else
3122                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3123                 if (spec->multiout.dig_out_nid &&
3124                     spec->stream_digital_playback) {
3125                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3126                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3127                 }
3128                 if (spec->dig_in_nid &&
3129                     spec->stream_digital_capture) {
3130                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3131                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3132                 }
3133                 /* FIXME: do we need this for all Realtek codec models? */
3134                 codec->spdif_status_reset = 1;
3135         }
3136
3137         if (spec->no_analog)
3138                 return 0;
3139
3140         /* If the use of more than one ADC is requested for the current
3141          * model, configure a second analog capture-only PCM.
3142          */
3143         /* Additional Analaog capture for index #2 */
3144         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3145             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3146                 codec->num_pcms = 3;
3147                 info = spec->pcm_rec + 2;
3148                 info->name = spec->stream_name_analog;
3149                 if (spec->alt_dac_nid) {
3150                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3151                                 *spec->stream_analog_alt_playback;
3152                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3153                                 spec->alt_dac_nid;
3154                 } else {
3155                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3156                                 alc_pcm_null_stream;
3157                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3158                 }
3159                 if (spec->num_adc_nids > 1) {
3160                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3161                                 *spec->stream_analog_alt_capture;
3162                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3163                                 spec->adc_nids[1];
3164                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3165                                 spec->num_adc_nids - 1;
3166                 } else {
3167                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3168                                 alc_pcm_null_stream;
3169                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3170                 }
3171         }
3172
3173         return 0;
3174 }
3175
3176 static void alc_free_kctls(struct hda_codec *codec)
3177 {
3178         struct alc_spec *spec = codec->spec;
3179
3180         if (spec->kctls.list) {
3181                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3182                 int i;
3183                 for (i = 0; i < spec->kctls.used; i++)
3184                         kfree(kctl[i].name);
3185         }
3186         snd_array_free(&spec->kctls);
3187 }
3188
3189 static void alc_free(struct hda_codec *codec)
3190 {
3191         struct alc_spec *spec = codec->spec;
3192
3193         if (!spec)
3194                 return;
3195
3196         alc_free_kctls(codec);
3197         kfree(spec);
3198         snd_hda_detach_beep_device(codec);
3199 }
3200
3201 #ifdef SND_HDA_NEEDS_RESUME
3202 static int alc_resume(struct hda_codec *codec)
3203 {
3204         codec->patch_ops.init(codec);
3205         snd_hda_codec_resume_amp(codec);
3206         snd_hda_codec_resume_cache(codec);
3207         return 0;
3208 }
3209 #endif
3210
3211 /*
3212  */
3213 static struct hda_codec_ops alc_patch_ops = {
3214         .build_controls = alc_build_controls,
3215         .build_pcms = alc_build_pcms,
3216         .init = alc_init,
3217         .free = alc_free,
3218         .unsol_event = alc_unsol_event,
3219 #ifdef SND_HDA_NEEDS_RESUME
3220         .resume = alc_resume,
3221 #endif
3222 #ifdef CONFIG_SND_HDA_POWER_SAVE
3223         .check_power_status = alc_check_power_status,
3224 #endif
3225 };
3226
3227
3228 /*
3229  * Test configuration for debugging
3230  *
3231  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3232  * enum controls.
3233  */
3234 #ifdef CONFIG_SND_DEBUG
3235 static hda_nid_t alc880_test_dac_nids[4] = {
3236         0x02, 0x03, 0x04, 0x05
3237 };
3238
3239 static struct hda_input_mux alc880_test_capture_source = {
3240         .num_items = 7,
3241         .items = {
3242                 { "In-1", 0x0 },
3243                 { "In-2", 0x1 },
3244                 { "In-3", 0x2 },
3245                 { "In-4", 0x3 },
3246                 { "CD", 0x4 },
3247                 { "Front", 0x5 },
3248                 { "Surround", 0x6 },
3249         },
3250 };
3251
3252 static struct hda_channel_mode alc880_test_modes[4] = {
3253         { 2, NULL },
3254         { 4, NULL },
3255         { 6, NULL },
3256         { 8, NULL },
3257 };
3258
3259 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3260                                  struct snd_ctl_elem_info *uinfo)
3261 {
3262         static char *texts[] = {
3263                 "N/A", "Line Out", "HP Out",
3264                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3265         };
3266         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3267         uinfo->count = 1;
3268         uinfo->value.enumerated.items = 8;
3269         if (uinfo->value.enumerated.item >= 8)
3270                 uinfo->value.enumerated.item = 7;
3271         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3272         return 0;
3273 }
3274
3275 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3276                                 struct snd_ctl_elem_value *ucontrol)
3277 {
3278         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3279         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3280         unsigned int pin_ctl, item = 0;
3281
3282         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3283                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3284         if (pin_ctl & AC_PINCTL_OUT_EN) {
3285                 if (pin_ctl & AC_PINCTL_HP_EN)
3286                         item = 2;
3287                 else
3288                         item = 1;
3289         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3290                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3291                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3292                 case AC_PINCTL_VREF_50:  item = 4; break;
3293                 case AC_PINCTL_VREF_GRD: item = 5; break;
3294                 case AC_PINCTL_VREF_80:  item = 6; break;
3295                 case AC_PINCTL_VREF_100: item = 7; break;
3296                 }
3297         }
3298         ucontrol->value.enumerated.item[0] = item;
3299         return 0;
3300 }
3301
3302 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3303                                 struct snd_ctl_elem_value *ucontrol)
3304 {
3305         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3306         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3307         static unsigned int ctls[] = {
3308                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3309                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3310                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3311                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3312                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3313                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3314         };
3315         unsigned int old_ctl, new_ctl;
3316
3317         old_ctl = snd_hda_codec_read(codec, nid, 0,
3318                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3319         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3320         if (old_ctl != new_ctl) {
3321                 int val;
3322                 snd_hda_codec_write_cache(codec, nid, 0,
3323                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3324                                           new_ctl);
3325                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3326                         HDA_AMP_MUTE : 0;
3327                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3328                                          HDA_AMP_MUTE, val);
3329                 return 1;
3330         }
3331         return 0;
3332 }
3333
3334 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3335                                  struct snd_ctl_elem_info *uinfo)
3336 {
3337         static char *texts[] = {
3338                 "Front", "Surround", "CLFE", "Side"
3339         };
3340         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3341         uinfo->count = 1;
3342         uinfo->value.enumerated.items = 4;
3343         if (uinfo->value.enumerated.item >= 4)
3344                 uinfo->value.enumerated.item = 3;
3345         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3346         return 0;
3347 }
3348
3349 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3350                                 struct snd_ctl_elem_value *ucontrol)
3351 {
3352         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3353         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3354         unsigned int sel;
3355
3356         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3357         ucontrol->value.enumerated.item[0] = sel & 3;
3358         return 0;
3359 }
3360
3361 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3362                                 struct snd_ctl_elem_value *ucontrol)
3363 {
3364         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3365         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3366         unsigned int sel;
3367
3368         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3369         if (ucontrol->value.enumerated.item[0] != sel) {
3370                 sel = ucontrol->value.enumerated.item[0] & 3;
3371                 snd_hda_codec_write_cache(codec, nid, 0,
3372                                           AC_VERB_SET_CONNECT_SEL, sel);
3373                 return 1;
3374         }
3375         return 0;
3376 }
3377
3378 #define PIN_CTL_TEST(xname,nid) {                       \
3379                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3380                         .name = xname,                 \
3381                         .info = alc_test_pin_ctl_info, \
3382                         .get = alc_test_pin_ctl_get,   \
3383                         .put = alc_test_pin_ctl_put,   \
3384                         .private_value = nid           \
3385                         }
3386
3387 #define PIN_SRC_TEST(xname,nid) {                       \
3388                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3389                         .name = xname,                 \
3390                         .info = alc_test_pin_src_info, \
3391                         .get = alc_test_pin_src_get,   \
3392                         .put = alc_test_pin_src_put,   \
3393                         .private_value = nid           \
3394                         }
3395
3396 static struct snd_kcontrol_new alc880_test_mixer[] = {
3397         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3398         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3399         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3400         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3401         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3402         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3403         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3404         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3405         PIN_CTL_TEST("Front Pin Mode", 0x14),
3406         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3407         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3408         PIN_CTL_TEST("Side Pin Mode", 0x17),
3409         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3410         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3411         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3412         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3413         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3414         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3415         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3416         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3417         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3418         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3419         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3420         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3421         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3422         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3423         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3424         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3425         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3426         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3427         {
3428                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3429                 .name = "Channel Mode",
3430                 .info = alc_ch_mode_info,
3431                 .get = alc_ch_mode_get,
3432                 .put = alc_ch_mode_put,
3433         },
3434         { } /* end */
3435 };
3436
3437 static struct hda_verb alc880_test_init_verbs[] = {
3438         /* Unmute inputs of 0x0c - 0x0f */
3439         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3440         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3441         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3442         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3443         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3444         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3445         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3446         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3447         /* Vol output for 0x0c-0x0f */
3448         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3449         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3450         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3451         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3452         /* Set output pins 0x14-0x17 */
3453         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3454         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3455         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3456         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3457         /* Unmute output pins 0x14-0x17 */
3458         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3459         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3460         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3461         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3462         /* Set input pins 0x18-0x1c */
3463         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3464         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3465         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3466         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3467         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3468         /* Mute input pins 0x18-0x1b */
3469         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3470         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3471         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3472         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3473         /* ADC set up */
3474         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3475         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3476         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3477         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3478         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3479         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3480         /* Analog input/passthru */
3481         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3482         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3483         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3485         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3486         { }
3487 };
3488 #endif
3489
3490 /*
3491  */
3492
3493 static const char *alc880_models[ALC880_MODEL_LAST] = {
3494         [ALC880_3ST]            = "3stack",
3495         [ALC880_TCL_S700]       = "tcl",
3496         [ALC880_3ST_DIG]        = "3stack-digout",
3497         [ALC880_CLEVO]          = "clevo",
3498         [ALC880_5ST]            = "5stack",
3499         [ALC880_5ST_DIG]        = "5stack-digout",
3500         [ALC880_W810]           = "w810",
3501         [ALC880_Z71V]           = "z71v",
3502         [ALC880_6ST]            = "6stack",
3503         [ALC880_6ST_DIG]        = "6stack-digout",
3504         [ALC880_ASUS]           = "asus",
3505         [ALC880_ASUS_W1V]       = "asus-w1v",
3506         [ALC880_ASUS_DIG]       = "asus-dig",
3507         [ALC880_ASUS_DIG2]      = "asus-dig2",
3508         [ALC880_UNIWILL_DIG]    = "uniwill",
3509         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3510         [ALC880_FUJITSU]        = "fujitsu",
3511         [ALC880_F1734]          = "F1734",
3512         [ALC880_LG]             = "lg",
3513         [ALC880_LG_LW]          = "lg-lw",
3514         [ALC880_MEDION_RIM]     = "medion",
3515 #ifdef CONFIG_SND_DEBUG
3516         [ALC880_TEST]           = "test",
3517 #endif
3518         [ALC880_AUTO]           = "auto",
3519 };
3520
3521 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3522         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3523         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3524         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3525         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3526         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3527         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3528         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3529         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3530         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3531         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3532         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3533         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3534         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3535         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3536         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3537         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3538         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3539         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3540         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3541         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3542         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3543         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3544         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3545         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3546         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3547         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3548         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3549         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3550         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3551         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3552         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3553         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3554         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3555         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3556         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3557         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3558         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3559         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3560         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3561         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3562         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3563         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3564         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3565         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3566         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3567         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3568         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3569         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3570         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3571         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3572         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3573         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3574         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3575         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3576         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3577         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3578         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3579         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3580         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3581         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3582         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3583         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3584         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3585         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3586         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3587         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3588         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3589         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3590         /* default Intel */
3591         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3592         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3593         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3594         {}
3595 };
3596
3597 /*
3598  * ALC880 codec presets
3599  */
3600 static struct alc_config_preset alc880_presets[] = {
3601         [ALC880_3ST] = {
3602                 .mixers = { alc880_three_stack_mixer },
3603                 .init_verbs = { alc880_volume_init_verbs,
3604                                 alc880_pin_3stack_init_verbs },
3605                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3606                 .dac_nids = alc880_dac_nids,
3607                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3608                 .channel_mode = alc880_threestack_modes,
3609                 .need_dac_fix = 1,
3610                 .input_mux = &alc880_capture_source,
3611         },
3612         [ALC880_3ST_DIG] = {
3613                 .mixers = { alc880_three_stack_mixer },
3614                 .init_verbs = { alc880_volume_init_verbs,
3615                                 alc880_pin_3stack_init_verbs },
3616                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3617                 .dac_nids = alc880_dac_nids,
3618                 .dig_out_nid = ALC880_DIGOUT_NID,
3619                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3620                 .channel_mode = alc880_threestack_modes,
3621                 .need_dac_fix = 1,
3622                 .input_mux = &alc880_capture_source,
3623         },
3624         [ALC880_TCL_S700] = {
3625                 .mixers = { alc880_tcl_s700_mixer },
3626                 .init_verbs = { alc880_volume_init_verbs,
3627                                 alc880_pin_tcl_S700_init_verbs,
3628                                 alc880_gpio2_init_verbs },
3629                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3630                 .dac_nids = alc880_dac_nids,
3631                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3632                 .num_adc_nids = 1, /* single ADC */
3633                 .hp_nid = 0x03,
3634                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3635                 .channel_mode = alc880_2_jack_modes,
3636                 .input_mux = &alc880_capture_source,
3637         },
3638         [ALC880_5ST] = {
3639                 .mixers = { alc880_three_stack_mixer,
3640                             alc880_five_stack_mixer},
3641                 .init_verbs = { alc880_volume_init_verbs,
3642                                 alc880_pin_5stack_init_verbs },
3643                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3644                 .dac_nids = alc880_dac_nids,
3645                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3646                 .channel_mode = alc880_fivestack_modes,
3647                 .input_mux = &alc880_capture_source,
3648         },
3649         [ALC880_5ST_DIG] = {
3650                 .mixers = { alc880_three_stack_mixer,
3651                             alc880_five_stack_mixer },
3652                 .init_verbs = { alc880_volume_init_verbs,
3653                                 alc880_pin_5stack_init_verbs },
3654                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3655                 .dac_nids = alc880_dac_nids,
3656                 .dig_out_nid = ALC880_DIGOUT_NID,
3657                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3658                 .channel_mode = alc880_fivestack_modes,
3659                 .input_mux = &alc880_capture_source,
3660         },
3661         [ALC880_6ST] = {
3662                 .mixers = { alc880_six_stack_mixer },
3663                 .init_verbs = { alc880_volume_init_verbs,
3664                                 alc880_pin_6stack_init_verbs },
3665                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3666                 .dac_nids = alc880_6st_dac_nids,
3667                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3668                 .channel_mode = alc880_sixstack_modes,
3669                 .input_mux = &alc880_6stack_capture_source,
3670         },
3671         [ALC880_6ST_DIG] = {
3672                 .mixers = { alc880_six_stack_mixer },
3673                 .init_verbs = { alc880_volume_init_verbs,
3674                                 alc880_pin_6stack_init_verbs },
3675                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3676                 .dac_nids = alc880_6st_dac_nids,
3677                 .dig_out_nid = ALC880_DIGOUT_NID,
3678                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3679                 .channel_mode = alc880_sixstack_modes,
3680                 .input_mux = &alc880_6stack_capture_source,
3681         },
3682         [ALC880_W810] = {
3683                 .mixers = { alc880_w810_base_mixer },
3684                 .init_verbs = { alc880_volume_init_verbs,
3685                                 alc880_pin_w810_init_verbs,
3686                                 alc880_gpio2_init_verbs },
3687                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3688                 .dac_nids = alc880_w810_dac_nids,
3689                 .dig_out_nid = ALC880_DIGOUT_NID,
3690                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3691                 .channel_mode = alc880_w810_modes,
3692                 .input_mux = &alc880_capture_source,
3693         },
3694         [ALC880_Z71V] = {
3695                 .mixers = { alc880_z71v_mixer },
3696                 .init_verbs = { alc880_volume_init_verbs,
3697                                 alc880_pin_z71v_init_verbs },
3698                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3699                 .dac_nids = alc880_z71v_dac_nids,
3700                 .dig_out_nid = ALC880_DIGOUT_NID,
3701                 .hp_nid = 0x03,
3702                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3703                 .channel_mode = alc880_2_jack_modes,
3704                 .input_mux = &alc880_capture_source,
3705         },
3706         [ALC880_F1734] = {
3707                 .mixers = { alc880_f1734_mixer },
3708                 .init_verbs = { alc880_volume_init_verbs,
3709                                 alc880_pin_f1734_init_verbs },
3710                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3711                 .dac_nids = alc880_f1734_dac_nids,
3712                 .hp_nid = 0x02,
3713                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3714                 .channel_mode = alc880_2_jack_modes,
3715                 .input_mux = &alc880_f1734_capture_source,
3716                 .unsol_event = alc880_uniwill_p53_unsol_event,
3717                 .init_hook = alc880_uniwill_p53_hp_automute,
3718         },
3719         [ALC880_ASUS] = {
3720                 .mixers = { alc880_asus_mixer },
3721                 .init_verbs = { alc880_volume_init_verbs,
3722                                 alc880_pin_asus_init_verbs,
3723                                 alc880_gpio1_init_verbs },
3724                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3725                 .dac_nids = alc880_asus_dac_nids,
3726                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3727                 .channel_mode = alc880_asus_modes,
3728                 .need_dac_fix = 1,
3729                 .input_mux = &alc880_capture_source,
3730         },
3731         [ALC880_ASUS_DIG] = {
3732                 .mixers = { alc880_asus_mixer },
3733                 .init_verbs = { alc880_volume_init_verbs,
3734                                 alc880_pin_asus_init_verbs,
3735                                 alc880_gpio1_init_verbs },
3736                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3737                 .dac_nids = alc880_asus_dac_nids,
3738                 .dig_out_nid = ALC880_DIGOUT_NID,
3739                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3740                 .channel_mode = alc880_asus_modes,
3741                 .need_dac_fix = 1,
3742                 .input_mux = &alc880_capture_source,
3743         },
3744         [ALC880_ASUS_DIG2] = {
3745                 .mixers = { alc880_asus_mixer },
3746                 .init_verbs = { alc880_volume_init_verbs,
3747                                 alc880_pin_asus_init_verbs,
3748                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3749                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3750                 .dac_nids = alc880_asus_dac_nids,
3751                 .dig_out_nid = ALC880_DIGOUT_NID,
3752                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3753                 .channel_mode = alc880_asus_modes,
3754                 .need_dac_fix = 1,
3755                 .input_mux = &alc880_capture_source,
3756         },
3757         [ALC880_ASUS_W1V] = {
3758                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3759                 .init_verbs = { alc880_volume_init_verbs,
3760                                 alc880_pin_asus_init_verbs,
3761                                 alc880_gpio1_init_verbs },
3762                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3763                 .dac_nids = alc880_asus_dac_nids,
3764                 .dig_out_nid = ALC880_DIGOUT_NID,
3765                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3766                 .channel_mode = alc880_asus_modes,
3767                 .need_dac_fix = 1,
3768                 .input_mux = &alc880_capture_source,
3769         },
3770         [ALC880_UNIWILL_DIG] = {
3771                 .mixers = { alc880_asus_mixer },
3772                 .init_verbs = { alc880_volume_init_verbs,
3773                                 alc880_pin_asus_init_verbs },
3774                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3775                 .dac_nids = alc880_asus_dac_nids,
3776                 .dig_out_nid = ALC880_DIGOUT_NID,
3777                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3778                 .channel_mode = alc880_asus_modes,
3779                 .need_dac_fix = 1,
3780                 .input_mux = &alc880_capture_source,
3781         },
3782         [ALC880_UNIWILL] = {
3783                 .mixers = { alc880_uniwill_mixer },
3784                 .init_verbs = { alc880_volume_init_verbs,
3785                                 alc880_uniwill_init_verbs },
3786                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3787                 .dac_nids = alc880_asus_dac_nids,
3788                 .dig_out_nid = ALC880_DIGOUT_NID,
3789                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3790                 .channel_mode = alc880_threestack_modes,
3791                 .need_dac_fix = 1,
3792                 .input_mux = &alc880_capture_source,
3793                 .unsol_event = alc880_uniwill_unsol_event,
3794                 .init_hook = alc880_uniwill_automute,
3795         },
3796         [ALC880_UNIWILL_P53] = {
3797                 .mixers = { alc880_uniwill_p53_mixer },
3798                 .init_verbs = { alc880_volume_init_verbs,
3799                                 alc880_uniwill_p53_init_verbs },
3800                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3801                 .dac_nids = alc880_asus_dac_nids,
3802                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3803                 .channel_mode = alc880_threestack_modes,
3804                 .input_mux = &alc880_capture_source,
3805                 .unsol_event = alc880_uniwill_p53_unsol_event,
3806                 .init_hook = alc880_uniwill_p53_hp_automute,
3807         },
3808         [ALC880_FUJITSU] = {
3809                 .mixers = { alc880_fujitsu_mixer },
3810                 .init_verbs = { alc880_volume_init_verbs,
3811                                 alc880_uniwill_p53_init_verbs,
3812                                 alc880_beep_init_verbs },
3813                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3814                 .dac_nids = alc880_dac_nids,
3815                 .dig_out_nid = ALC880_DIGOUT_NID,
3816                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3817                 .channel_mode = alc880_2_jack_modes,
3818                 .input_mux = &alc880_capture_source,
3819                 .unsol_event = alc880_uniwill_p53_unsol_event,
3820                 .init_hook = alc880_uniwill_p53_hp_automute,
3821         },
3822         [ALC880_CLEVO] = {
3823                 .mixers = { alc880_three_stack_mixer },
3824                 .init_verbs = { alc880_volume_init_verbs,
3825                                 alc880_pin_clevo_init_verbs },
3826                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3827                 .dac_nids = alc880_dac_nids,
3828                 .hp_nid = 0x03,
3829                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3830                 .channel_mode = alc880_threestack_modes,
3831                 .need_dac_fix = 1,
3832                 .input_mux = &alc880_capture_source,
3833         },
3834         [ALC880_LG] = {
3835                 .mixers = { alc880_lg_mixer },
3836                 .init_verbs = { alc880_volume_init_verbs,
3837                                 alc880_lg_init_verbs },
3838                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3839                 .dac_nids = alc880_lg_dac_nids,
3840                 .dig_out_nid = ALC880_DIGOUT_NID,
3841                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3842                 .channel_mode = alc880_lg_ch_modes,
3843                 .need_dac_fix = 1,
3844                 .input_mux = &alc880_lg_capture_source,
3845                 .unsol_event = alc880_lg_unsol_event,
3846                 .init_hook = alc880_lg_automute,
3847 #ifdef CONFIG_SND_HDA_POWER_SAVE
3848                 .loopbacks = alc880_lg_loopbacks,
3849 #endif
3850         },
3851         [ALC880_LG_LW] = {
3852                 .mixers = { alc880_lg_lw_mixer },
3853                 .init_verbs = { alc880_volume_init_verbs,
3854                                 alc880_lg_lw_init_verbs },
3855                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3856                 .dac_nids = alc880_dac_nids,
3857                 .dig_out_nid = ALC880_DIGOUT_NID,
3858                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3859                 .channel_mode = alc880_lg_lw_modes,
3860                 .input_mux = &alc880_lg_lw_capture_source,
3861                 .unsol_event = alc880_lg_lw_unsol_event,
3862                 .init_hook = alc880_lg_lw_automute,
3863         },
3864         [ALC880_MEDION_RIM] = {
3865                 .mixers = { alc880_medion_rim_mixer },
3866                 .init_verbs = { alc880_volume_init_verbs,
3867                                 alc880_medion_rim_init_verbs,
3868                                 alc_gpio2_init_verbs },
3869                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3870                 .dac_nids = alc880_dac_nids,
3871                 .dig_out_nid = ALC880_DIGOUT_NID,
3872                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3873                 .channel_mode = alc880_2_jack_modes,
3874                 .input_mux = &alc880_medion_rim_capture_source,
3875                 .unsol_event = alc880_medion_rim_unsol_event,
3876                 .init_hook = alc880_medion_rim_automute,
3877         },
3878 #ifdef CONFIG_SND_DEBUG
3879         [ALC880_TEST] = {
3880                 .mixers = { alc880_test_mixer },
3881                 .init_verbs = { alc880_test_init_verbs },
3882                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3883                 .dac_nids = alc880_test_dac_nids,
3884                 .dig_out_nid = ALC880_DIGOUT_NID,
3885                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3886                 .channel_mode = alc880_test_modes,
3887                 .input_mux = &alc880_test_capture_source,
3888         },
3889 #endif
3890 };
3891
3892 /*
3893  * Automatic parse of I/O pins from the BIOS configuration
3894  */
3895
3896 enum {
3897         ALC_CTL_WIDGET_VOL,
3898         ALC_CTL_WIDGET_MUTE,
3899         ALC_CTL_BIND_MUTE,
3900 };
3901 static struct snd_kcontrol_new alc880_control_templates[] = {
3902         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3903         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3904         HDA_BIND_MUTE(NULL, 0, 0, 0),
3905 };
3906
3907 /* add dynamic controls */
3908 static int add_control(struct alc_spec *spec, int type, const char *name,
3909                        unsigned long val)
3910 {
3911         struct snd_kcontrol_new *knew;
3912
3913         snd_array_init(&spec->kctls, sizeof(*knew), 32);
3914         knew = snd_array_new(&spec->kctls);
3915         if (!knew)
3916                 return -ENOMEM;
3917         *knew = alc880_control_templates[type];
3918         knew->name = kstrdup(name, GFP_KERNEL);
3919         if (!knew->name)
3920                 return -ENOMEM;
3921         knew->private_value = val;
3922         return 0;
3923 }
3924
3925 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3926 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3927 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3928 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3929 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3930 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3931 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3932 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3933 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3934 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3935 #define ALC880_PIN_CD_NID               0x1c
3936
3937 /* fill in the dac_nids table from the parsed pin configuration */
3938 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3939                                      const struct auto_pin_cfg *cfg)
3940 {
3941         hda_nid_t nid;
3942         int assigned[4];
3943         int i, j;
3944
3945         memset(assigned, 0, sizeof(assigned));
3946         spec->multiout.dac_nids = spec->private_dac_nids;
3947
3948         /* check the pins hardwired to audio widget */
3949         for (i = 0; i < cfg->line_outs; i++) {
3950                 nid = cfg->line_out_pins[i];
3951                 if (alc880_is_fixed_pin(nid)) {
3952                         int idx = alc880_fixed_pin_idx(nid);
3953                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3954                         assigned[idx] = 1;
3955                 }
3956         }
3957         /* left pins can be connect to any audio widget */
3958         for (i = 0; i < cfg->line_outs; i++) {
3959                 nid = cfg->line_out_pins[i];
3960                 if (alc880_is_fixed_pin(nid))
3961                         continue;
3962                 /* search for an empty channel */
3963                 for (j = 0; j < cfg->line_outs; j++) {
3964                         if (!assigned[j]) {
3965                                 spec->multiout.dac_nids[i] =
3966                                         alc880_idx_to_dac(j);
3967                                 assigned[j] = 1;
3968                                 break;
3969                         }
3970                 }
3971         }
3972         spec->multiout.num_dacs = cfg->line_outs;
3973         return 0;
3974 }
3975
3976 /* add playback controls from the parsed DAC table */
3977 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3978                                              const struct auto_pin_cfg *cfg)
3979 {
3980         char name[32];
3981         static const char *chname[4] = {
3982                 "Front", "Surround", NULL /*CLFE*/, "Side"
3983         };
3984         hda_nid_t nid;
3985         int i, err;
3986
3987         for (i = 0; i < cfg->line_outs; i++) {
3988                 if (!spec->multiout.dac_nids[i])
3989                         continue;
3990                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
3991                 if (i == 2) {
3992                         /* Center/LFE */
3993                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
3994                                           "Center Playback Volume",
3995                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
3996                                                               HDA_OUTPUT));
3997                         if (err < 0)
3998                                 return err;
3999                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4000                                           "LFE Playback Volume",
4001                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4002                                                               HDA_OUTPUT));
4003                         if (err < 0)
4004                                 return err;
4005                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4006                                           "Center Playback Switch",
4007                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4008                                                               HDA_INPUT));
4009                         if (err < 0)
4010                                 return err;
4011                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4012                                           "LFE Playback Switch",
4013                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4014                                                               HDA_INPUT));
4015                         if (err < 0)
4016                                 return err;
4017                 } else {
4018                         sprintf(name, "%s Playback Volume", chname[i]);
4019                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4020                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4021                                                               HDA_OUTPUT));
4022                         if (err < 0)
4023                                 return err;
4024                         sprintf(name, "%s Playback Switch", chname[i]);
4025                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4026                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4027                                                               HDA_INPUT));
4028                         if (err < 0)
4029                                 return err;
4030                 }
4031         }
4032         return 0;
4033 }
4034
4035 /* add playback controls for speaker and HP outputs */
4036 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4037                                         const char *pfx)
4038 {
4039         hda_nid_t nid;
4040         int err;
4041         char name[32];
4042
4043         if (!pin)
4044                 return 0;
4045
4046         if (alc880_is_fixed_pin(pin)) {
4047                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4048                 /* specify the DAC as the extra output */
4049                 if (!spec->multiout.hp_nid)
4050                         spec->multiout.hp_nid = nid;
4051                 else
4052                         spec->multiout.extra_out_nid[0] = nid;
4053                 /* control HP volume/switch on the output mixer amp */
4054                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4055                 sprintf(name, "%s Playback Volume", pfx);
4056                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4057                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4058                 if (err < 0)
4059                         return err;
4060                 sprintf(name, "%s Playback Switch", pfx);
4061                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4062                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4063                 if (err < 0)
4064                         return err;
4065         } else if (alc880_is_multi_pin(pin)) {
4066                 /* set manual connection */
4067                 /* we have only a switch on HP-out PIN */
4068                 sprintf(name, "%s Playback Switch", pfx);
4069                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4070                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4071                 if (err < 0)
4072                         return err;
4073         }
4074         return 0;
4075 }
4076
4077 /* create input playback/capture controls for the given pin */
4078 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4079                             const char *ctlname,
4080                             int idx, hda_nid_t mix_nid)
4081 {
4082         char name[32];
4083         int err;
4084
4085         sprintf(name, "%s Playback Volume", ctlname);
4086         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4087                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4088         if (err < 0)
4089                 return err;
4090         sprintf(name, "%s Playback Switch", ctlname);
4091         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4092                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4093         if (err < 0)
4094                 return err;
4095         return 0;
4096 }
4097
4098 /* create playback/capture controls for input pins */
4099 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4100                                                 const struct auto_pin_cfg *cfg)
4101 {
4102         struct hda_input_mux *imux = &spec->private_imux[0];
4103         int i, err, idx;
4104
4105         for (i = 0; i < AUTO_PIN_LAST; i++) {
4106                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4107                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4108                         err = new_analog_input(spec, cfg->input_pins[i],
4109                                                auto_pin_cfg_labels[i],
4110                                                idx, 0x0b);
4111                         if (err < 0)
4112                                 return err;
4113                         imux->items[imux->num_items].label =
4114                                 auto_pin_cfg_labels[i];
4115                         imux->items[imux->num_items].index =
4116                                 alc880_input_pin_idx(cfg->input_pins[i]);
4117                         imux->num_items++;
4118                 }
4119         }
4120         return 0;
4121 }
4122
4123 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4124                                unsigned int pin_type)
4125 {
4126         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4127                             pin_type);
4128         /* unmute pin */
4129         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4130                             AMP_OUT_UNMUTE);
4131 }
4132
4133 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4134                                               hda_nid_t nid, int pin_type,
4135                                               int dac_idx)
4136 {
4137         alc_set_pin_output(codec, nid, pin_type);
4138         /* need the manual connection? */
4139         if (alc880_is_multi_pin(nid)) {
4140                 struct alc_spec *spec = codec->spec;
4141                 int idx = alc880_multi_pin_idx(nid);
4142                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4143                                     AC_VERB_SET_CONNECT_SEL,
4144                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4145         }
4146 }
4147
4148 static int get_pin_type(int line_out_type)
4149 {
4150         if (line_out_type == AUTO_PIN_HP_OUT)
4151                 return PIN_HP;
4152         else
4153                 return PIN_OUT;
4154 }
4155
4156 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4157 {
4158         struct alc_spec *spec = codec->spec;
4159         int i;
4160
4161         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4162         for (i = 0; i < spec->autocfg.line_outs; i++) {
4163                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4164                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4165                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4166         }
4167 }
4168
4169 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4170 {
4171         struct alc_spec *spec = codec->spec;
4172         hda_nid_t pin;
4173
4174         pin = spec->autocfg.speaker_pins[0];
4175         if (pin) /* connect to front */
4176                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4177         pin = spec->autocfg.hp_pins[0];
4178         if (pin) /* connect to front */
4179                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4180 }
4181
4182 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4183 {
4184         struct alc_spec *spec = codec->spec;
4185         int i;
4186
4187         for (i = 0; i < AUTO_PIN_LAST; i++) {
4188                 hda_nid_t nid = spec->autocfg.input_pins[i];
4189                 if (alc880_is_input_pin(nid)) {
4190                         snd_hda_codec_write(codec, nid, 0,
4191                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
4192                                             i <= AUTO_PIN_FRONT_MIC ?
4193                                             PIN_VREF80 : PIN_IN);
4194                         if (nid != ALC880_PIN_CD_NID)
4195                                 snd_hda_codec_write(codec, nid, 0,
4196                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4197                                                     AMP_OUT_MUTE);
4198                 }
4199         }
4200 }
4201
4202 /* parse the BIOS configuration and set up the alc_spec */
4203 /* return 1 if successful, 0 if the proper config is not found,
4204  * or a negative error code
4205  */
4206 static int alc880_parse_auto_config(struct hda_codec *codec)
4207 {
4208         struct alc_spec *spec = codec->spec;
4209         int i, err;
4210         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4211
4212         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4213                                            alc880_ignore);
4214         if (err < 0)
4215                 return err;
4216         if (!spec->autocfg.line_outs)
4217                 return 0; /* can't find valid BIOS pin config */
4218
4219         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4220         if (err < 0)
4221                 return err;
4222         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4223         if (err < 0)
4224                 return err;
4225         err = alc880_auto_create_extra_out(spec,
4226                                            spec->autocfg.speaker_pins[0],
4227                                            "Speaker");
4228         if (err < 0)
4229                 return err;
4230         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4231                                            "Headphone");
4232         if (err < 0)
4233                 return err;
4234         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4235         if (err < 0)
4236                 return err;
4237
4238         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4239
4240         /* check multiple SPDIF-out (for recent codecs) */
4241         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4242                 hda_nid_t dig_nid;
4243                 err = snd_hda_get_connections(codec,
4244                                               spec->autocfg.dig_out_pins[i],
4245                                               &dig_nid, 1);
4246                 if (err < 0)
4247                         continue;
4248                 if (!i)
4249                         spec->multiout.dig_out_nid = dig_nid;
4250                 else {
4251                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4252                         spec->slave_dig_outs[i - 1] = dig_nid;
4253                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4254                                 break;
4255                 }
4256         }
4257         if (spec->autocfg.dig_in_pin)
4258                 spec->dig_in_nid = ALC880_DIGIN_NID;
4259
4260         if (spec->kctls.list)
4261                 add_mixer(spec, spec->kctls.list);
4262
4263         add_verb(spec, alc880_volume_init_verbs);
4264
4265         spec->num_mux_defs = 1;
4266         spec->input_mux = &spec->private_imux[0];
4267
4268         return 1;
4269 }
4270
4271 /* additional initialization for auto-configuration model */
4272 static void alc880_auto_init(struct hda_codec *codec)
4273 {
4274         struct alc_spec *spec = codec->spec;
4275         alc880_auto_init_multi_out(codec);
4276         alc880_auto_init_extra_out(codec);
4277         alc880_auto_init_analog_input(codec);
4278         if (spec->unsol_event)
4279                 alc_inithook(codec);
4280 }
4281
4282 static void set_capture_mixer(struct alc_spec *spec)
4283 {
4284         static struct snd_kcontrol_new *caps[3] = {
4285                 alc_capture_mixer1,
4286                 alc_capture_mixer2,
4287                 alc_capture_mixer3,
4288         };
4289         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
4290                 spec->cap_mixer = caps[spec->num_adc_nids - 1];
4291 }
4292
4293 #define set_beep_amp(spec, nid, idx, dir) \
4294         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4295
4296 /*
4297  * OK, here we have finally the patch for ALC880
4298  */
4299
4300 static int patch_alc880(struct hda_codec *codec)
4301 {
4302         struct alc_spec *spec;
4303         int board_config;
4304         int err;
4305
4306         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4307         if (spec == NULL)
4308                 return -ENOMEM;
4309
4310         codec->spec = spec;
4311
4312         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4313                                                   alc880_models,
4314                                                   alc880_cfg_tbl);
4315         if (board_config < 0) {
4316                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4317                        "trying auto-probe from BIOS...\n");
4318                 board_config = ALC880_AUTO;
4319         }
4320
4321         if (board_config == ALC880_AUTO) {
4322                 /* automatic parse from the BIOS config */
4323                 err = alc880_parse_auto_config(codec);
4324                 if (err < 0) {
4325                         alc_free(codec);
4326                         return err;
4327                 } else if (!err) {
4328                         printk(KERN_INFO
4329                                "hda_codec: Cannot set up configuration "
4330                                "from BIOS.  Using 3-stack mode...\n");
4331                         board_config = ALC880_3ST;
4332                 }
4333         }
4334
4335         err = snd_hda_attach_beep_device(codec, 0x1);
4336         if (err < 0) {
4337                 alc_free(codec);
4338                 return err;
4339         }
4340
4341         if (board_config != ALC880_AUTO)
4342                 setup_preset(spec, &alc880_presets[board_config]);
4343
4344         spec->stream_name_analog = "ALC880 Analog";
4345         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4346         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4347         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4348
4349         spec->stream_name_digital = "ALC880 Digital";
4350         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4351         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4352
4353         if (!spec->adc_nids && spec->input_mux) {
4354                 /* check whether NID 0x07 is valid */
4355                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4356                 /* get type */
4357                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4358                 if (wcap != AC_WID_AUD_IN) {
4359                         spec->adc_nids = alc880_adc_nids_alt;
4360                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4361                 } else {
4362                         spec->adc_nids = alc880_adc_nids;
4363                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4364                 }
4365         }
4366         set_capture_mixer(spec);
4367         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4368
4369         spec->vmaster_nid = 0x0c;
4370
4371         codec->patch_ops = alc_patch_ops;
4372         if (board_config == ALC880_AUTO)
4373                 spec->init_hook = alc880_auto_init;
4374 #ifdef CONFIG_SND_HDA_POWER_SAVE
4375         if (!spec->loopback.amplist)
4376                 spec->loopback.amplist = alc880_loopbacks;
4377 #endif
4378         codec->proc_widget_hook = print_realtek_coef;
4379
4380         return 0;
4381 }
4382
4383
4384 /*
4385  * ALC260 support
4386  */
4387
4388 static hda_nid_t alc260_dac_nids[1] = {
4389         /* front */
4390         0x02,
4391 };
4392
4393 static hda_nid_t alc260_adc_nids[1] = {
4394         /* ADC0 */
4395         0x04,
4396 };
4397
4398 static hda_nid_t alc260_adc_nids_alt[1] = {
4399         /* ADC1 */
4400         0x05,
4401 };
4402
4403 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4404  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4405  */
4406 static hda_nid_t alc260_dual_adc_nids[2] = {
4407         /* ADC0, ADC1 */
4408         0x04, 0x05
4409 };
4410
4411 #define ALC260_DIGOUT_NID       0x03
4412 #define ALC260_DIGIN_NID        0x06
4413
4414 static struct hda_input_mux alc260_capture_source = {
4415         .num_items = 4,
4416         .items = {
4417                 { "Mic", 0x0 },
4418                 { "Front Mic", 0x1 },
4419                 { "Line", 0x2 },
4420                 { "CD", 0x4 },
4421         },
4422 };
4423
4424 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4425  * headphone jack and the internal CD lines since these are the only pins at
4426  * which audio can appear.  For flexibility, also allow the option of
4427  * recording the mixer output on the second ADC (ADC0 doesn't have a
4428  * connection to the mixer output).
4429  */
4430 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4431         {
4432                 .num_items = 3,
4433                 .items = {
4434                         { "Mic/Line", 0x0 },
4435                         { "CD", 0x4 },
4436                         { "Headphone", 0x2 },
4437                 },
4438         },
4439         {
4440                 .num_items = 4,
4441                 .items = {
4442                         { "Mic/Line", 0x0 },
4443                         { "CD", 0x4 },
4444                         { "Headphone", 0x2 },
4445                         { "Mixer", 0x5 },
4446                 },
4447         },
4448
4449 };
4450
4451 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4452  * the Fujitsu S702x, but jacks are marked differently.
4453  */
4454 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4455         {
4456                 .num_items = 4,
4457                 .items = {
4458                         { "Mic", 0x0 },
4459                         { "Line", 0x2 },
4460                         { "CD", 0x4 },
4461                         { "Headphone", 0x5 },
4462                 },
4463         },
4464         {
4465                 .num_items = 5,
4466                 .items = {
4467                         { "Mic", 0x0 },
4468                         { "Line", 0x2 },
4469                         { "CD", 0x4 },
4470                         { "Headphone", 0x6 },
4471                         { "Mixer", 0x5 },
4472                 },
4473         },
4474 };
4475 /*
4476  * This is just place-holder, so there's something for alc_build_pcms to look
4477  * at when it calculates the maximum number of channels. ALC260 has no mixer
4478  * element which allows changing the channel mode, so the verb list is
4479  * never used.
4480  */
4481 static struct hda_channel_mode alc260_modes[1] = {
4482         { 2, NULL },
4483 };
4484
4485
4486 /* Mixer combinations
4487  *
4488  * basic: base_output + input + pc_beep + capture
4489  * HP: base_output + input + capture_alt
4490  * HP_3013: hp_3013 + input + capture
4491  * fujitsu: fujitsu + capture
4492  * acer: acer + capture
4493  */
4494
4495 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4496         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4497         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4498         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4499         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4500         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4501         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4502         { } /* end */
4503 };
4504
4505 static struct snd_kcontrol_new alc260_input_mixer[] = {
4506         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4507         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4508         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4509         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4510         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4511         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4512         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4513         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4514         { } /* end */
4515 };
4516
4517 /* update HP, line and mono out pins according to the master switch */
4518 static void alc260_hp_master_update(struct hda_codec *codec,
4519                                     hda_nid_t hp, hda_nid_t line,
4520                                     hda_nid_t mono)
4521 {
4522         struct alc_spec *spec = codec->spec;
4523         unsigned int val = spec->master_sw ? PIN_HP : 0;
4524         /* change HP and line-out pins */
4525         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4526                             val);
4527         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4528                             val);
4529         /* mono (speaker) depending on the HP jack sense */
4530         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4531         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4532                             val);
4533 }
4534
4535 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4536                                    struct snd_ctl_elem_value *ucontrol)
4537 {
4538         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4539         struct alc_spec *spec = codec->spec;
4540         *ucontrol->value.integer.value = spec->master_sw;
4541         return 0;
4542 }
4543
4544 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4545                                    struct snd_ctl_elem_value *ucontrol)
4546 {
4547         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4548         struct alc_spec *spec = codec->spec;
4549         int val = !!*ucontrol->value.integer.value;
4550         hda_nid_t hp, line, mono;
4551
4552         if (val == spec->master_sw)
4553                 return 0;
4554         spec->master_sw = val;
4555         hp = (kcontrol->private_value >> 16) & 0xff;
4556         line = (kcontrol->private_value >> 8) & 0xff;
4557         mono = kcontrol->private_value & 0xff;
4558         alc260_hp_master_update(codec, hp, line, mono);
4559         return 1;
4560 }
4561
4562 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4563         {
4564                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4565                 .name = "Master Playback Switch",
4566                 .info = snd_ctl_boolean_mono_info,
4567                 .get = alc260_hp_master_sw_get,
4568                 .put = alc260_hp_master_sw_put,
4569                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4570         },
4571         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4572         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4573         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4574         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4575         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4576                               HDA_OUTPUT),
4577         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4578         { } /* end */
4579 };
4580
4581 static struct hda_verb alc260_hp_unsol_verbs[] = {
4582         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4583         {},
4584 };
4585
4586 static void alc260_hp_automute(struct hda_codec *codec)
4587 {
4588         struct alc_spec *spec = codec->spec;
4589         unsigned int present;
4590
4591         present = snd_hda_codec_read(codec, 0x10, 0,
4592                                      AC_VERB_GET_PIN_SENSE, 0);
4593         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4594         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4595 }
4596
4597 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4598 {
4599         if ((res >> 26) == ALC880_HP_EVENT)
4600                 alc260_hp_automute(codec);
4601 }
4602
4603 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4604         {
4605                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4606                 .name = "Master Playback Switch",
4607                 .info = snd_ctl_boolean_mono_info,
4608                 .get = alc260_hp_master_sw_get,
4609                 .put = alc260_hp_master_sw_put,
4610                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4611         },
4612         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4613         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4614         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4615         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4616         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4617         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4618         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4619         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4620         { } /* end */
4621 };
4622
4623 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4624         .ops = &snd_hda_bind_vol,
4625         .values = {
4626                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4627                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4628                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4629                 0
4630         },
4631 };
4632
4633 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4634         .ops = &snd_hda_bind_sw,
4635         .values = {
4636                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4637                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4638                 0
4639         },
4640 };
4641
4642 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4643         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4644         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4645         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4646         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4647         { } /* end */
4648 };
4649
4650 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4651         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4652         {},
4653 };
4654
4655 static void alc260_hp_3013_automute(struct hda_codec *codec)
4656 {
4657         struct alc_spec *spec = codec->spec;
4658         unsigned int present;
4659
4660         present = snd_hda_codec_read(codec, 0x15, 0,
4661                                      AC_VERB_GET_PIN_SENSE, 0);
4662         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4663         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4664 }
4665
4666 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4667                                        unsigned int res)
4668 {
4669         if ((res >> 26) == ALC880_HP_EVENT)
4670                 alc260_hp_3013_automute(codec);
4671 }
4672
4673 static void alc260_hp_3012_automute(struct hda_codec *codec)
4674 {
4675         unsigned int present, bits;
4676
4677         present = snd_hda_codec_read(codec, 0x10, 0,
4678                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4679
4680         bits = present ? 0 : PIN_OUT;
4681         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4682                             bits);
4683         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4684                             bits);
4685         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4686                             bits);
4687 }
4688
4689 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4690                                        unsigned int res)
4691 {
4692         if ((res >> 26) == ALC880_HP_EVENT)
4693                 alc260_hp_3012_automute(codec);
4694 }
4695
4696 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4697  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4698  */
4699 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4700         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4701         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4702         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4703         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4704         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4705         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4706         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4707         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4708         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4709         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4710         { } /* end */
4711 };
4712
4713 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4714  * versions of the ALC260 don't act on requests to enable mic bias from NID
4715  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4716  * datasheet doesn't mention this restriction.  At this stage it's not clear
4717  * whether this behaviour is intentional or is a hardware bug in chip
4718  * revisions available in early 2006.  Therefore for now allow the
4719  * "Headphone Jack Mode" control to span all choices, but if it turns out
4720  * that the lack of mic bias for this NID is intentional we could change the
4721  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4722  *
4723  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4724  * don't appear to make the mic bias available from the "line" jack, even
4725  * though the NID used for this jack (0x14) can supply it.  The theory is
4726  * that perhaps Acer have included blocking capacitors between the ALC260
4727  * and the output jack.  If this turns out to be the case for all such
4728  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4729  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4730  *
4731  * The C20x Tablet series have a mono internal speaker which is controlled
4732  * via the chip's Mono sum widget and pin complex, so include the necessary
4733  * controls for such models.  On models without a "mono speaker" the control
4734  * won't do anything.
4735  */
4736 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4737         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4738         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4739         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4740         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4741                               HDA_OUTPUT),
4742         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4743                            HDA_INPUT),
4744         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4745         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4746         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4747         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4748         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4749         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4750         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4751         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4752         { } /* end */
4753 };
4754
4755 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4756  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4757  */
4758 static struct snd_kcontrol_new alc260_will_mixer[] = {
4759         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4760         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4761         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4762         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4763         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4764         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4765         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4766         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4767         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4768         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4769         { } /* end */
4770 };
4771
4772 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4773  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4774  */
4775 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4776         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4777         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4778         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4779         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4780         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4781         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4782         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4783         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4784         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4785         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4786         { } /* end */
4787 };
4788
4789 /*
4790  * initialization verbs
4791  */
4792 static struct hda_verb alc260_init_verbs[] = {
4793         /* Line In pin widget for input */
4794         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4795         /* CD pin widget for input */
4796         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4797         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4798         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4799         /* Mic2 (front panel) pin widget for input and vref at 80% */
4800         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4801         /* LINE-2 is used for line-out in rear */
4802         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4803         /* select line-out */
4804         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4805         /* LINE-OUT pin */
4806         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4807         /* enable HP */
4808         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4809         /* enable Mono */
4810         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4811         /* mute capture amp left and right */
4812         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4813         /* set connection select to line in (default select for this ADC) */
4814         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4815         /* mute capture amp left and right */
4816         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4817         /* set connection select to line in (default select for this ADC) */
4818         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4819         /* set vol=0 Line-Out mixer amp left and right */
4820         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4821         /* unmute pin widget amp left and right (no gain on this amp) */
4822         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4823         /* set vol=0 HP mixer amp left and right */
4824         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4825         /* unmute pin widget amp left and right (no gain on this amp) */
4826         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4827         /* set vol=0 Mono mixer amp left and right */
4828         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4829         /* unmute pin widget amp left and right (no gain on this amp) */
4830         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4831         /* unmute LINE-2 out pin */
4832         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4833         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4834          * Line In 2 = 0x03
4835          */
4836         /* mute analog inputs */
4837         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4838         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4839         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4840         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4841         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4842         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4843         /* mute Front out path */
4844         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4845         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4846         /* mute Headphone out path */
4847         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4848         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4849         /* mute Mono out path */
4850         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4851         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4852         { }
4853 };
4854
4855 #if 0 /* should be identical with alc260_init_verbs? */
4856 static struct hda_verb alc260_hp_init_verbs[] = {
4857         /* Headphone and output */
4858         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4859         /* mono output */
4860         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4861         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4862         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4863         /* Mic2 (front panel) pin widget for input and vref at 80% */
4864         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4865         /* Line In pin widget for input */
4866         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4867         /* Line-2 pin widget for output */
4868         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4869         /* CD pin widget for input */
4870         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4871         /* unmute amp left and right */
4872         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4873         /* set connection select to line in (default select for this ADC) */
4874         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4875         /* unmute Line-Out mixer amp left and right (volume = 0) */
4876         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4877         /* mute pin widget amp left and right (no gain on this amp) */
4878         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4879         /* unmute HP mixer amp left and right (volume = 0) */
4880         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4881         /* mute pin widget amp left and right (no gain on this amp) */
4882         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4883         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4884          * Line In 2 = 0x03
4885          */
4886         /* mute analog inputs */
4887         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4888         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4889         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4890         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4891         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4892         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4893         /* Unmute Front out path */
4894         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4895         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4896         /* Unmute Headphone out path */
4897         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4898         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4899         /* Unmute Mono out path */
4900         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4901         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4902         { }
4903 };
4904 #endif
4905
4906 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4907         /* Line out and output */
4908         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4909         /* mono output */
4910         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4911         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4912         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4913         /* Mic2 (front panel) pin widget for input and vref at 80% */
4914         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4915         /* Line In pin widget for input */
4916         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4917         /* Headphone pin widget for output */
4918         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4919         /* CD pin widget for input */
4920         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4921         /* unmute amp left and right */
4922         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4923         /* set connection select to line in (default select for this ADC) */
4924         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4925         /* unmute Line-Out mixer amp left and right (volume = 0) */
4926         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4927         /* mute pin widget amp left and right (no gain on this amp) */
4928         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4929         /* unmute HP mixer amp left and right (volume = 0) */
4930         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4931         /* mute pin widget amp left and right (no gain on this amp) */
4932         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4933         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4934          * Line In 2 = 0x03
4935          */
4936         /* mute analog inputs */
4937         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4938         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4939         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4940         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4941         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4942         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4943         /* Unmute Front out path */
4944         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4945         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4946         /* Unmute Headphone out path */
4947         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4948         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4949         /* Unmute Mono out path */
4950         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4951         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4952         { }
4953 };
4954
4955 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4956  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4957  * audio = 0x16, internal speaker = 0x10.
4958  */
4959 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4960         /* Disable all GPIOs */
4961         {0x01, AC_VERB_SET_GPIO_MASK, 0},
4962         /* Internal speaker is connected to headphone pin */
4963         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4964         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4965         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4966         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4967         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4968         /* Ensure all other unused pins are disabled and muted. */
4969         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4970         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4971         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4972         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4973         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4974         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4975         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4976         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4977
4978         /* Disable digital (SPDIF) pins */
4979         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4980         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4981
4982         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4983          * when acting as an output.
4984          */
4985         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4986
4987         /* Start with output sum widgets muted and their output gains at min */
4988         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4989         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4990         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4991         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4992         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4993         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4994         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4995         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4996         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4997
4998         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
4999         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5000         /* Unmute Line1 pin widget output buffer since it starts as an output.
5001          * If the pin mode is changed by the user the pin mode control will
5002          * take care of enabling the pin's input/output buffers as needed.
5003          * Therefore there's no need to enable the input buffer at this
5004          * stage.
5005          */
5006         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5007         /* Unmute input buffer of pin widget used for Line-in (no equiv
5008          * mixer ctrl)
5009          */
5010         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5011
5012         /* Mute capture amp left and right */
5013         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5014         /* Set ADC connection select to match default mixer setting - line
5015          * in (on mic1 pin)
5016          */
5017         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5018
5019         /* Do the same for the second ADC: mute capture input amp and
5020          * set ADC connection to line in (on mic1 pin)
5021          */
5022         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5023         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5024
5025         /* Mute all inputs to mixer widget (even unconnected ones) */
5026         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5027         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5028         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5029         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5030         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5031         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5032         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5033         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5034
5035         { }
5036 };
5037
5038 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5039  * similar laptops (adapted from Fujitsu init verbs).
5040  */
5041 static struct hda_verb alc260_acer_init_verbs[] = {
5042         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5043          * the headphone jack.  Turn this on and rely on the standard mute
5044          * methods whenever the user wants to turn these outputs off.
5045          */
5046         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5047         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5048         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5049         /* Internal speaker/Headphone jack is connected to Line-out pin */
5050         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5051         /* Internal microphone/Mic jack is connected to Mic1 pin */
5052         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5053         /* Line In jack is connected to Line1 pin */
5054         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5055         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5056         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5057         /* Ensure all other unused pins are disabled and muted. */
5058         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5059         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5060         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5061         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5062         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5063         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5064         /* Disable digital (SPDIF) pins */
5065         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5066         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5067
5068         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5069          * bus when acting as outputs.
5070          */
5071         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5072         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5073
5074         /* Start with output sum widgets muted and their output gains at min */
5075         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5076         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5077         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5078         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5079         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5080         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5081         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5082         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5083         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5084
5085         /* Unmute Line-out pin widget amp left and right
5086          * (no equiv mixer ctrl)
5087          */
5088         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5089         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5090         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5091         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5092          * inputs. If the pin mode is changed by the user the pin mode control
5093          * will take care of enabling the pin's input/output buffers as needed.
5094          * Therefore there's no need to enable the input buffer at this
5095          * stage.
5096          */
5097         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5098         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5099
5100         /* Mute capture amp left and right */
5101         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5102         /* Set ADC connection select to match default mixer setting - mic
5103          * (on mic1 pin)
5104          */
5105         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5106
5107         /* Do similar with the second ADC: mute capture input amp and
5108          * set ADC connection to mic to match ALSA's default state.
5109          */
5110         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5111         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5112
5113         /* Mute all inputs to mixer widget (even unconnected ones) */
5114         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5116         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5117         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5118         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5119         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5120         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5121         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5122
5123         { }
5124 };
5125
5126 static struct hda_verb alc260_will_verbs[] = {
5127         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5128         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5129         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5130         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5131         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5132         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5133         {}
5134 };
5135
5136 static struct hda_verb alc260_replacer_672v_verbs[] = {
5137         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5138         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5139         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5140
5141         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5142         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5143         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5144
5145         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5146         {}
5147 };
5148
5149 /* toggle speaker-output according to the hp-jack state */
5150 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5151 {
5152         unsigned int present;
5153
5154         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5155         present = snd_hda_codec_read(codec, 0x0f, 0,
5156                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5157         if (present) {
5158                 snd_hda_codec_write_cache(codec, 0x01, 0,
5159                                           AC_VERB_SET_GPIO_DATA, 1);
5160                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5161                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5162                                           PIN_HP);
5163         } else {
5164                 snd_hda_codec_write_cache(codec, 0x01, 0,
5165                                           AC_VERB_SET_GPIO_DATA, 0);
5166                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5167                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5168                                           PIN_OUT);
5169         }
5170 }
5171
5172 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5173                                        unsigned int res)
5174 {
5175         if ((res >> 26) == ALC880_HP_EVENT)
5176                 alc260_replacer_672v_automute(codec);
5177 }
5178
5179 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5180         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5181         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5182         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5183         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5184         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5185         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5186         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5187         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5188         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5189         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5190         {}
5191 };
5192
5193 /* Test configuration for debugging, modelled after the ALC880 test
5194  * configuration.
5195  */
5196 #ifdef CONFIG_SND_DEBUG
5197 static hda_nid_t alc260_test_dac_nids[1] = {
5198         0x02,
5199 };
5200 static hda_nid_t alc260_test_adc_nids[2] = {
5201         0x04, 0x05,
5202 };
5203 /* For testing the ALC260, each input MUX needs its own definition since
5204  * the signal assignments are different.  This assumes that the first ADC
5205  * is NID 0x04.
5206  */
5207 static struct hda_input_mux alc260_test_capture_sources[2] = {
5208         {
5209                 .num_items = 7,
5210                 .items = {
5211                         { "MIC1 pin", 0x0 },
5212                         { "MIC2 pin", 0x1 },
5213                         { "LINE1 pin", 0x2 },
5214                         { "LINE2 pin", 0x3 },
5215                         { "CD pin", 0x4 },
5216                         { "LINE-OUT pin", 0x5 },
5217                         { "HP-OUT pin", 0x6 },
5218                 },
5219         },
5220         {
5221                 .num_items = 8,
5222                 .items = {
5223                         { "MIC1 pin", 0x0 },
5224                         { "MIC2 pin", 0x1 },
5225                         { "LINE1 pin", 0x2 },
5226                         { "LINE2 pin", 0x3 },
5227                         { "CD pin", 0x4 },
5228                         { "Mixer", 0x5 },
5229                         { "LINE-OUT pin", 0x6 },
5230                         { "HP-OUT pin", 0x7 },
5231                 },
5232         },
5233 };
5234 static struct snd_kcontrol_new alc260_test_mixer[] = {
5235         /* Output driver widgets */
5236         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5237         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5238         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5239         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5240         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5241         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5242
5243         /* Modes for retasking pin widgets
5244          * Note: the ALC260 doesn't seem to act on requests to enable mic
5245          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5246          * mention this restriction.  At this stage it's not clear whether
5247          * this behaviour is intentional or is a hardware bug in chip
5248          * revisions available at least up until early 2006.  Therefore for
5249          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5250          * choices, but if it turns out that the lack of mic bias for these
5251          * NIDs is intentional we could change their modes from
5252          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5253          */
5254         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5255         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5256         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5257         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5258         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5259         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5260
5261         /* Loopback mixer controls */
5262         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5263         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5264         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5265         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5266         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5267         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5268         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5269         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5270         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5271         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5272         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5273         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5274         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5275         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5276
5277         /* Controls for GPIO pins, assuming they are configured as outputs */
5278         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5279         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5280         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5281         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5282
5283         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5284          * is ambigious as to which NID is which; testing on laptops which
5285          * make this output available should provide clarification.
5286          */
5287         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5288         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5289
5290         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5291          * this output to turn on an external amplifier.
5292          */
5293         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5294         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5295
5296         { } /* end */
5297 };
5298 static struct hda_verb alc260_test_init_verbs[] = {
5299         /* Enable all GPIOs as outputs with an initial value of 0 */
5300         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5301         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5302         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5303
5304         /* Enable retasking pins as output, initially without power amp */
5305         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5306         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5307         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5308         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5309         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5310         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5311
5312         /* Disable digital (SPDIF) pins initially, but users can enable
5313          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5314          * payload also sets the generation to 0, output to be in "consumer"
5315          * PCM format, copyright asserted, no pre-emphasis and no validity
5316          * control.
5317          */
5318         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5319         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5320
5321         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5322          * OUT1 sum bus when acting as an output.
5323          */
5324         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5325         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5326         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5327         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5328
5329         /* Start with output sum widgets muted and their output gains at min */
5330         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5331         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5332         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5333         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5334         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5335         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5336         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5337         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5338         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5339
5340         /* Unmute retasking pin widget output buffers since the default
5341          * state appears to be output.  As the pin mode is changed by the
5342          * user the pin mode control will take care of enabling the pin's
5343          * input/output buffers as needed.
5344          */
5345         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5346         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5347         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5348         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5349         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5350         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5351         /* Also unmute the mono-out pin widget */
5352         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5353
5354         /* Mute capture amp left and right */
5355         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5356         /* Set ADC connection select to match default mixer setting (mic1
5357          * pin)
5358          */
5359         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5360
5361         /* Do the same for the second ADC: mute capture input amp and
5362          * set ADC connection to mic1 pin
5363          */
5364         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5365         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5366
5367         /* Mute all inputs to mixer widget (even unconnected ones) */
5368         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5369         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5370         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5371         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5373         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5374         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5375         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5376
5377         { }
5378 };
5379 #endif
5380
5381 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5382 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5383
5384 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5385 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5386
5387 /*
5388  * for BIOS auto-configuration
5389  */
5390
5391 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5392                                         const char *pfx, int *vol_bits)
5393 {
5394         hda_nid_t nid_vol;
5395         unsigned long vol_val, sw_val;
5396         char name[32];
5397         int err;
5398
5399         if (nid >= 0x0f && nid < 0x11) {
5400                 nid_vol = nid - 0x7;
5401                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5402                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5403         } else if (nid == 0x11) {
5404                 nid_vol = nid - 0x7;
5405                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5406                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5407         } else if (nid >= 0x12 && nid <= 0x15) {
5408                 nid_vol = 0x08;
5409                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5410                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5411         } else
5412                 return 0; /* N/A */
5413
5414         if (!(*vol_bits & (1 << nid_vol))) {
5415                 /* first control for the volume widget */
5416                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5417                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5418                 if (err < 0)
5419                         return err;
5420                 *vol_bits |= (1 << nid_vol);
5421         }
5422         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5423         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5424         if (err < 0)
5425                 return err;
5426         return 1;
5427 }
5428
5429 /* add playback controls from the parsed DAC table */
5430 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5431                                              const struct auto_pin_cfg *cfg)
5432 {
5433         hda_nid_t nid;
5434         int err;
5435         int vols = 0;
5436
5437         spec->multiout.num_dacs = 1;
5438         spec->multiout.dac_nids = spec->private_dac_nids;
5439         spec->multiout.dac_nids[0] = 0x02;
5440
5441         nid = cfg->line_out_pins[0];
5442         if (nid) {
5443                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5444                 if (err < 0)
5445                         return err;
5446         }
5447
5448         nid = cfg->speaker_pins[0];
5449         if (nid) {
5450                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5451                 if (err < 0)
5452                         return err;
5453         }
5454
5455         nid = cfg->hp_pins[0];
5456         if (nid) {
5457                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5458                                                    &vols);
5459                 if (err < 0)
5460                         return err;
5461         }
5462         return 0;
5463 }
5464
5465 /* create playback/capture controls for input pins */
5466 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5467                                                 const struct auto_pin_cfg *cfg)
5468 {
5469         struct hda_input_mux *imux = &spec->private_imux[0];
5470         int i, err, idx;
5471
5472         for (i = 0; i < AUTO_PIN_LAST; i++) {
5473                 if (cfg->input_pins[i] >= 0x12) {
5474                         idx = cfg->input_pins[i] - 0x12;
5475                         err = new_analog_input(spec, cfg->input_pins[i],
5476                                                auto_pin_cfg_labels[i], idx,
5477                                                0x07);
5478                         if (err < 0)
5479                                 return err;
5480                         imux->items[imux->num_items].label =
5481                                 auto_pin_cfg_labels[i];
5482                         imux->items[imux->num_items].index = idx;
5483                         imux->num_items++;
5484                 }
5485                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5486                         idx = cfg->input_pins[i] - 0x09;
5487                         err = new_analog_input(spec, cfg->input_pins[i],
5488                                                auto_pin_cfg_labels[i], idx,
5489                                                0x07);
5490                         if (err < 0)
5491                                 return err;
5492                         imux->items[imux->num_items].label =
5493                                 auto_pin_cfg_labels[i];
5494                         imux->items[imux->num_items].index = idx;
5495                         imux->num_items++;
5496                 }
5497         }
5498         return 0;
5499 }
5500
5501 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5502                                               hda_nid_t nid, int pin_type,
5503                                               int sel_idx)
5504 {
5505         alc_set_pin_output(codec, nid, pin_type);
5506         /* need the manual connection? */
5507         if (nid >= 0x12) {
5508                 int idx = nid - 0x12;
5509                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5510                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5511         }
5512 }
5513
5514 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5515 {
5516         struct alc_spec *spec = codec->spec;
5517         hda_nid_t nid;
5518
5519         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5520         nid = spec->autocfg.line_out_pins[0];
5521         if (nid) {
5522                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5523                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5524         }
5525
5526         nid = spec->autocfg.speaker_pins[0];
5527         if (nid)
5528                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5529
5530         nid = spec->autocfg.hp_pins[0];
5531         if (nid)
5532                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5533 }
5534
5535 #define ALC260_PIN_CD_NID               0x16
5536 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5537 {
5538         struct alc_spec *spec = codec->spec;
5539         int i;
5540
5541         for (i = 0; i < AUTO_PIN_LAST; i++) {
5542                 hda_nid_t nid = spec->autocfg.input_pins[i];
5543                 if (nid >= 0x12) {
5544                         snd_hda_codec_write(codec, nid, 0,
5545                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
5546                                             i <= AUTO_PIN_FRONT_MIC ?
5547                                             PIN_VREF80 : PIN_IN);
5548                         if (nid != ALC260_PIN_CD_NID)
5549                                 snd_hda_codec_write(codec, nid, 0,
5550                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5551                                                     AMP_OUT_MUTE);
5552                 }
5553         }
5554 }
5555
5556 /*
5557  * generic initialization of ADC, input mixers and output mixers
5558  */
5559 static struct hda_verb alc260_volume_init_verbs[] = {
5560         /*
5561          * Unmute ADC0-1 and set the default input to mic-in
5562          */
5563         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5564         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5565         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5566         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5567
5568         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5569          * mixer widget
5570          * Note: PASD motherboards uses the Line In 2 as the input for
5571          * front panel mic (mic 2)
5572          */
5573         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5574         /* mute analog inputs */
5575         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5576         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5577         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5578         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5579         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5580
5581         /*
5582          * Set up output mixers (0x08 - 0x0a)
5583          */
5584         /* set vol=0 to output mixers */
5585         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5586         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5587         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5588         /* set up input amps for analog loopback */
5589         /* Amp Indices: DAC = 0, mixer = 1 */
5590         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5591         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5592         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5593         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5594         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5595         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5596
5597         { }
5598 };
5599
5600 static int alc260_parse_auto_config(struct hda_codec *codec)
5601 {
5602         struct alc_spec *spec = codec->spec;
5603         int err;
5604         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5605
5606         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5607                                            alc260_ignore);
5608         if (err < 0)
5609                 return err;
5610         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5611         if (err < 0)
5612                 return err;
5613         if (!spec->kctls.list)
5614                 return 0; /* can't find valid BIOS pin config */
5615         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5616         if (err < 0)
5617                 return err;
5618
5619         spec->multiout.max_channels = 2;
5620
5621         if (spec->autocfg.dig_outs)
5622                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5623         if (spec->kctls.list)
5624                 add_mixer(spec, spec->kctls.list);
5625
5626         add_verb(spec, alc260_volume_init_verbs);
5627
5628         spec->num_mux_defs = 1;
5629         spec->input_mux = &spec->private_imux[0];
5630
5631         return 1;
5632 }
5633
5634 /* additional initialization for auto-configuration model */
5635 static void alc260_auto_init(struct hda_codec *codec)
5636 {
5637         struct alc_spec *spec = codec->spec;
5638         alc260_auto_init_multi_out(codec);
5639         alc260_auto_init_analog_input(codec);
5640         if (spec->unsol_event)
5641                 alc_inithook(codec);
5642 }
5643
5644 #ifdef CONFIG_SND_HDA_POWER_SAVE
5645 static struct hda_amp_list alc260_loopbacks[] = {
5646         { 0x07, HDA_INPUT, 0 },
5647         { 0x07, HDA_INPUT, 1 },
5648         { 0x07, HDA_INPUT, 2 },
5649         { 0x07, HDA_INPUT, 3 },
5650         { 0x07, HDA_INPUT, 4 },
5651         { } /* end */
5652 };
5653 #endif
5654
5655 /*
5656  * ALC260 configurations
5657  */
5658 static const char *alc260_models[ALC260_MODEL_LAST] = {
5659         [ALC260_BASIC]          = "basic",
5660         [ALC260_HP]             = "hp",
5661         [ALC260_HP_3013]        = "hp-3013",
5662         [ALC260_HP_DC7600]      = "hp-dc7600",
5663         [ALC260_FUJITSU_S702X]  = "fujitsu",
5664         [ALC260_ACER]           = "acer",
5665         [ALC260_WILL]           = "will",
5666         [ALC260_REPLACER_672V]  = "replacer",
5667 #ifdef CONFIG_SND_DEBUG
5668         [ALC260_TEST]           = "test",
5669 #endif
5670         [ALC260_AUTO]           = "auto",
5671 };
5672
5673 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5674         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5675         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5676         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5677         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5678         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5679         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5680         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5681         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5682         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5683         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5684         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5685         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5686         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5687         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5688         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5689         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5690         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5691         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5692         {}
5693 };
5694
5695 static struct alc_config_preset alc260_presets[] = {
5696         [ALC260_BASIC] = {
5697                 .mixers = { alc260_base_output_mixer,
5698                             alc260_input_mixer },
5699                 .init_verbs = { alc260_init_verbs },
5700                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5701                 .dac_nids = alc260_dac_nids,
5702                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5703                 .adc_nids = alc260_adc_nids,
5704                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5705                 .channel_mode = alc260_modes,
5706                 .input_mux = &alc260_capture_source,
5707         },
5708         [ALC260_HP] = {
5709                 .mixers = { alc260_hp_output_mixer,
5710                             alc260_input_mixer },
5711                 .init_verbs = { alc260_init_verbs,
5712                                 alc260_hp_unsol_verbs },
5713                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5714                 .dac_nids = alc260_dac_nids,
5715                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5716                 .adc_nids = alc260_adc_nids_alt,
5717                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5718                 .channel_mode = alc260_modes,
5719                 .input_mux = &alc260_capture_source,
5720                 .unsol_event = alc260_hp_unsol_event,
5721                 .init_hook = alc260_hp_automute,
5722         },
5723         [ALC260_HP_DC7600] = {
5724                 .mixers = { alc260_hp_dc7600_mixer,
5725                             alc260_input_mixer },
5726                 .init_verbs = { alc260_init_verbs,
5727                                 alc260_hp_dc7600_verbs },
5728                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5729                 .dac_nids = alc260_dac_nids,
5730                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5731                 .adc_nids = alc260_adc_nids_alt,
5732                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5733                 .channel_mode = alc260_modes,
5734                 .input_mux = &alc260_capture_source,
5735                 .unsol_event = alc260_hp_3012_unsol_event,
5736                 .init_hook = alc260_hp_3012_automute,
5737         },
5738         [ALC260_HP_3013] = {
5739                 .mixers = { alc260_hp_3013_mixer,
5740                             alc260_input_mixer },
5741                 .init_verbs = { alc260_hp_3013_init_verbs,
5742                                 alc260_hp_3013_unsol_verbs },
5743                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5744                 .dac_nids = alc260_dac_nids,
5745                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5746                 .adc_nids = alc260_adc_nids_alt,
5747                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5748                 .channel_mode = alc260_modes,
5749                 .input_mux = &alc260_capture_source,
5750                 .unsol_event = alc260_hp_3013_unsol_event,
5751                 .init_hook = alc260_hp_3013_automute,
5752         },
5753         [ALC260_FUJITSU_S702X] = {
5754                 .mixers = { alc260_fujitsu_mixer },
5755                 .init_verbs = { alc260_fujitsu_init_verbs },
5756                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5757                 .dac_nids = alc260_dac_nids,
5758                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5759                 .adc_nids = alc260_dual_adc_nids,
5760                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5761                 .channel_mode = alc260_modes,
5762                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5763                 .input_mux = alc260_fujitsu_capture_sources,
5764         },
5765         [ALC260_ACER] = {
5766                 .mixers = { alc260_acer_mixer },
5767                 .init_verbs = { alc260_acer_init_verbs },
5768                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5769                 .dac_nids = alc260_dac_nids,
5770                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5771                 .adc_nids = alc260_dual_adc_nids,
5772                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5773                 .channel_mode = alc260_modes,
5774                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5775                 .input_mux = alc260_acer_capture_sources,
5776         },
5777         [ALC260_WILL] = {
5778                 .mixers = { alc260_will_mixer },
5779                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5780                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5781                 .dac_nids = alc260_dac_nids,
5782                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5783                 .adc_nids = alc260_adc_nids,
5784                 .dig_out_nid = ALC260_DIGOUT_NID,
5785                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5786                 .channel_mode = alc260_modes,
5787                 .input_mux = &alc260_capture_source,
5788         },
5789         [ALC260_REPLACER_672V] = {
5790                 .mixers = { alc260_replacer_672v_mixer },
5791                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5792                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5793                 .dac_nids = alc260_dac_nids,
5794                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5795                 .adc_nids = alc260_adc_nids,
5796                 .dig_out_nid = ALC260_DIGOUT_NID,
5797                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5798                 .channel_mode = alc260_modes,
5799                 .input_mux = &alc260_capture_source,
5800                 .unsol_event = alc260_replacer_672v_unsol_event,
5801                 .init_hook = alc260_replacer_672v_automute,
5802         },
5803 #ifdef CONFIG_SND_DEBUG
5804         [ALC260_TEST] = {
5805                 .mixers = { alc260_test_mixer },
5806                 .init_verbs = { alc260_test_init_verbs },
5807                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5808                 .dac_nids = alc260_test_dac_nids,
5809                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5810                 .adc_nids = alc260_test_adc_nids,
5811                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5812                 .channel_mode = alc260_modes,
5813                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5814                 .input_mux = alc260_test_capture_sources,
5815         },
5816 #endif
5817 };
5818
5819 static int patch_alc260(struct hda_codec *codec)
5820 {
5821         struct alc_spec *spec;
5822         int err, board_config;
5823
5824         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5825         if (spec == NULL)
5826                 return -ENOMEM;
5827
5828         codec->spec = spec;
5829
5830         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5831                                                   alc260_models,
5832                                                   alc260_cfg_tbl);
5833         if (board_config < 0) {
5834                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5835                            "trying auto-probe from BIOS...\n");
5836                 board_config = ALC260_AUTO;
5837         }
5838
5839         if (board_config == ALC260_AUTO) {
5840                 /* automatic parse from the BIOS config */
5841                 err = alc260_parse_auto_config(codec);
5842                 if (err < 0) {
5843                         alc_free(codec);
5844                         return err;
5845                 } else if (!err) {
5846                         printk(KERN_INFO
5847                                "hda_codec: Cannot set up configuration "
5848                                "from BIOS.  Using base mode...\n");
5849                         board_config = ALC260_BASIC;
5850                 }
5851         }
5852
5853         err = snd_hda_attach_beep_device(codec, 0x1);
5854         if (err < 0) {
5855                 alc_free(codec);
5856                 return err;
5857         }
5858
5859         if (board_config != ALC260_AUTO)
5860                 setup_preset(spec, &alc260_presets[board_config]);
5861
5862         spec->stream_name_analog = "ALC260 Analog";
5863         spec->stream_analog_playback = &alc260_pcm_analog_playback;
5864         spec->stream_analog_capture = &alc260_pcm_analog_capture;
5865
5866         spec->stream_name_digital = "ALC260 Digital";
5867         spec->stream_digital_playback = &alc260_pcm_digital_playback;
5868         spec->stream_digital_capture = &alc260_pcm_digital_capture;
5869
5870         if (!spec->adc_nids && spec->input_mux) {
5871                 /* check whether NID 0x04 is valid */
5872                 unsigned int wcap = get_wcaps(codec, 0x04);
5873                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
5874                 /* get type */
5875                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5876                         spec->adc_nids = alc260_adc_nids_alt;
5877                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5878                 } else {
5879                         spec->adc_nids = alc260_adc_nids;
5880                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5881                 }
5882         }
5883         set_capture_mixer(spec);
5884         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
5885
5886         spec->vmaster_nid = 0x08;
5887
5888         codec->patch_ops = alc_patch_ops;
5889         if (board_config == ALC260_AUTO)
5890                 spec->init_hook = alc260_auto_init;
5891 #ifdef CONFIG_SND_HDA_POWER_SAVE
5892         if (!spec->loopback.amplist)
5893                 spec->loopback.amplist = alc260_loopbacks;
5894 #endif
5895         codec->proc_widget_hook = print_realtek_coef;
5896
5897         return 0;
5898 }
5899
5900
5901 /*
5902  * ALC882 support
5903  *
5904  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5905  * configuration.  Each pin widget can choose any input DACs and a mixer.
5906  * Each ADC is connected from a mixer of all inputs.  This makes possible
5907  * 6-channel independent captures.
5908  *
5909  * In addition, an independent DAC for the multi-playback (not used in this
5910  * driver yet).
5911  */
5912 #define ALC882_DIGOUT_NID       0x06
5913 #define ALC882_DIGIN_NID        0x0a
5914
5915 static struct hda_channel_mode alc882_ch_modes[1] = {
5916         { 8, NULL }
5917 };
5918
5919 static hda_nid_t alc882_dac_nids[4] = {
5920         /* front, rear, clfe, rear_surr */
5921         0x02, 0x03, 0x04, 0x05
5922 };
5923
5924 /* identical with ALC880 */
5925 #define alc882_adc_nids         alc880_adc_nids
5926 #define alc882_adc_nids_alt     alc880_adc_nids_alt
5927
5928 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5929 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5930
5931 /* input MUX */
5932 /* FIXME: should be a matrix-type input source selection */
5933
5934 static struct hda_input_mux alc882_capture_source = {
5935         .num_items = 4,
5936         .items = {
5937                 { "Mic", 0x0 },
5938                 { "Front Mic", 0x1 },
5939                 { "Line", 0x2 },
5940                 { "CD", 0x4 },
5941         },
5942 };
5943 /*
5944  * 2ch mode
5945  */
5946 static struct hda_verb alc882_3ST_ch2_init[] = {
5947         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
5948         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5949         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
5950         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
5951         { } /* end */
5952 };
5953
5954 /*
5955  * 6ch mode
5956  */
5957 static struct hda_verb alc882_3ST_ch6_init[] = {
5958         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5959         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5960         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
5961         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5962         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
5963         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
5964         { } /* end */
5965 };
5966
5967 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
5968         { 2, alc882_3ST_ch2_init },
5969         { 6, alc882_3ST_ch6_init },
5970 };
5971
5972 /*
5973  * 6ch mode
5974  */
5975 static struct hda_verb alc882_sixstack_ch6_init[] = {
5976         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
5977         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5978         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5979         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5980         { } /* end */
5981 };
5982
5983 /*
5984  * 8ch mode
5985  */
5986 static struct hda_verb alc882_sixstack_ch8_init[] = {
5987         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5988         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5989         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5990         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
5991         { } /* end */
5992 };
5993
5994 static struct hda_channel_mode alc882_sixstack_modes[2] = {
5995         { 6, alc882_sixstack_ch6_init },
5996         { 8, alc882_sixstack_ch8_init },
5997 };
5998
5999 /*
6000  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6001  */
6002
6003 /*
6004  * 2ch mode
6005  */
6006 static struct hda_verb alc885_mbp_ch2_init[] = {
6007         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6008         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6009         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6010         { } /* end */
6011 };
6012
6013 /*
6014  * 6ch mode
6015  */
6016 static struct hda_verb alc885_mbp_ch6_init[] = {
6017         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6018         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6019         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6020         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6021         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6022         { } /* end */
6023 };
6024
6025 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6026         { 2, alc885_mbp_ch2_init },
6027         { 6, alc885_mbp_ch6_init },
6028 };
6029
6030
6031 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6032  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6033  */
6034 static struct snd_kcontrol_new alc882_base_mixer[] = {
6035         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6036         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6037         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6038         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6039         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6040         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6041         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6042         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6043         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6044         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6045         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6046         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6047         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6048         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6049         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6050         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6051         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6052         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6053         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6054         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6055         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6056         { } /* end */
6057 };
6058
6059 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6060         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6061         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6062         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6063         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6064         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6065         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6066         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6067         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6068         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6069         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6070         { } /* end */
6071 };
6072 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6073         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6074         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6075         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6076         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6077         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6078         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6079         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6080         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6081         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6082         { } /* end */
6083 };
6084
6085 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6086         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6087         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6088         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6089         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6090         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6091         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6092         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6093         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6094         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6095         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6096         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6097         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6098         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6099         { } /* end */
6100 };
6101
6102 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6103  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6104  */
6105 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6106         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6107         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6108         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6109         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6110         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6111         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6112         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6113         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6114         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6115         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6116         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6117         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6118         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6119         { } /* end */
6120 };
6121
6122 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6123         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6124         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6125         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6126         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6127         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6128         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6129         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6130         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6131         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6132         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6133         { } /* end */
6134 };
6135
6136 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6137         {
6138                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6139                 .name = "Channel Mode",
6140                 .info = alc_ch_mode_info,
6141                 .get = alc_ch_mode_get,
6142                 .put = alc_ch_mode_put,
6143         },
6144         { } /* end */
6145 };
6146
6147 static struct hda_verb alc882_init_verbs[] = {
6148         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6149         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6150         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6151         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6152         /* Rear mixer */
6153         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6154         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6155         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6156         /* CLFE mixer */
6157         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6158         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6159         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6160         /* Side mixer */
6161         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6162         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6163         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6164
6165         /* Front Pin: output 0 (0x0c) */
6166         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6167         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6168         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6169         /* Rear Pin: output 1 (0x0d) */
6170         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6171         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6172         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6173         /* CLFE Pin: output 2 (0x0e) */
6174         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6175         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6176         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6177         /* Side Pin: output 3 (0x0f) */
6178         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6179         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6180         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6181         /* Mic (rear) pin: input vref at 80% */
6182         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6183         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6184         /* Front Mic pin: input vref at 80% */
6185         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6186         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6187         /* Line In pin: input */
6188         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6189         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6190         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6191         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6192         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6193         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6194         /* CD pin widget for input */
6195         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6196
6197         /* FIXME: use matrix-type input source selection */
6198         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6199         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6200         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6201         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6202         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6203         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6204         /* Input mixer2 */
6205         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6206         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6207         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6208         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6209         /* Input mixer3 */
6210         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6211         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6212         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6213         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6214         /* ADC1: mute amp left and right */
6215         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6216         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6217         /* ADC2: mute amp left and right */
6218         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6219         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6220         /* ADC3: mute amp left and right */
6221         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6222         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6223
6224         { }
6225 };
6226
6227 static struct hda_verb alc882_eapd_verbs[] = {
6228         /* change to EAPD mode */
6229         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6230         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6231         { }
6232 };
6233
6234 /* Mac Pro test */
6235 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6236         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6237         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6238         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6239         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6240         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6241         /* FIXME: this looks suspicious...
6242         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6243         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6244         */
6245         { } /* end */
6246 };
6247
6248 static struct hda_verb alc882_macpro_init_verbs[] = {
6249         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6250         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6251         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6252         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6253         /* Front Pin: output 0 (0x0c) */
6254         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6255         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6256         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6257         /* Front Mic pin: input vref at 80% */
6258         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6259         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6260         /* Speaker:  output */
6261         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6262         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6263         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6264         /* Headphone output (output 0 - 0x0c) */
6265         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6266         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6267         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6268
6269         /* FIXME: use matrix-type input source selection */
6270         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6271         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6272         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6273         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6274         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6275         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6276         /* Input mixer2 */
6277         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6278         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6279         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6280         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6281         /* Input mixer3 */
6282         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6283         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6284         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6285         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6286         /* ADC1: mute amp left and right */
6287         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6288         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6289         /* ADC2: mute amp left and right */
6290         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6291         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6292         /* ADC3: mute amp left and right */
6293         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6294         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6295
6296         { }
6297 };
6298
6299 /* Macbook Pro rev3 */
6300 static struct hda_verb alc885_mbp3_init_verbs[] = {
6301         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6302         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6303         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6304         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6305         /* Rear mixer */
6306         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6307         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6308         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6309         /* Front Pin: output 0 (0x0c) */
6310         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6311         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6312         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6313         /* HP Pin: output 0 (0x0d) */
6314         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6315         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6316         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6317         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6318         /* Mic (rear) pin: input vref at 80% */
6319         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6320         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6321         /* Front Mic pin: input vref at 80% */
6322         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6323         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6324         /* Line In pin: use output 1 when in LineOut mode */
6325         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6326         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6327         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6328
6329         /* FIXME: use matrix-type input source selection */
6330         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6331         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6332         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6333         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6334         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6335         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6336         /* Input mixer2 */
6337         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6338         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6339         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6340         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6341         /* Input mixer3 */
6342         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6343         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6344         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6345         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6346         /* ADC1: mute amp left and right */
6347         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6348         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6349         /* ADC2: mute amp left and right */
6350         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6351         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6352         /* ADC3: mute amp left and right */
6353         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6354         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6355
6356         { }
6357 };
6358
6359 /* iMac 24 mixer. */
6360 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6361         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6362         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6363         { } /* end */
6364 };
6365
6366 /* iMac 24 init verbs. */
6367 static struct hda_verb alc885_imac24_init_verbs[] = {
6368         /* Internal speakers: output 0 (0x0c) */
6369         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6370         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6371         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6372         /* Internal speakers: output 0 (0x0c) */
6373         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6374         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6375         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6376         /* Headphone: output 0 (0x0c) */
6377         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6378         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6379         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6380         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6381         /* Front Mic: input vref at 80% */
6382         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6383         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6384         { }
6385 };
6386
6387 /* Toggle speaker-output according to the hp-jack state */
6388 static void alc885_imac24_automute(struct hda_codec *codec)
6389 {
6390         unsigned int present;
6391
6392         present = snd_hda_codec_read(codec, 0x14, 0,
6393                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6394         snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6395                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6396         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6397                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6398 }
6399
6400 /* Processes unsolicited events. */
6401 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6402                                       unsigned int res)
6403 {
6404         /* Headphone insertion or removal. */
6405         if ((res >> 26) == ALC880_HP_EVENT)
6406                 alc885_imac24_automute(codec);
6407 }
6408
6409 static void alc885_mbp3_automute(struct hda_codec *codec)
6410 {
6411         unsigned int present;
6412
6413         present = snd_hda_codec_read(codec, 0x15, 0,
6414                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6415         snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6416                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6417         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6418                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6419
6420 }
6421 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6422                                     unsigned int res)
6423 {
6424         /* Headphone insertion or removal. */
6425         if ((res >> 26) == ALC880_HP_EVENT)
6426                 alc885_mbp3_automute(codec);
6427 }
6428
6429
6430 static struct hda_verb alc882_targa_verbs[] = {
6431         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6432         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6433
6434         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6435         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6436
6437         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6438         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6439         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6440
6441         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6442         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6443         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6444         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6445         { } /* end */
6446 };
6447
6448 /* toggle speaker-output according to the hp-jack state */
6449 static void alc882_targa_automute(struct hda_codec *codec)
6450 {
6451         unsigned int present;
6452
6453         present = snd_hda_codec_read(codec, 0x14, 0,
6454                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6455         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6456                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6457         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6458                                   present ? 1 : 3);
6459 }
6460
6461 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6462 {
6463         /* Looks like the unsol event is incompatible with the standard
6464          * definition.  4bit tag is placed at 26 bit!
6465          */
6466         if (((res >> 26) == ALC880_HP_EVENT)) {
6467                 alc882_targa_automute(codec);
6468         }
6469 }
6470
6471 static struct hda_verb alc882_asus_a7j_verbs[] = {
6472         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6473         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6474
6475         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6476         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6477         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6478
6479         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6480         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6481         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6482
6483         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6484         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6485         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6486         { } /* end */
6487 };
6488
6489 static struct hda_verb alc882_asus_a7m_verbs[] = {
6490         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6491         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6492
6493         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6494         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6495         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6496
6497         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6498         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6499         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6500
6501         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6502         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6503         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6504         { } /* end */
6505 };
6506
6507 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6508 {
6509         unsigned int gpiostate, gpiomask, gpiodir;
6510
6511         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6512                                        AC_VERB_GET_GPIO_DATA, 0);
6513
6514         if (!muted)
6515                 gpiostate |= (1 << pin);
6516         else
6517                 gpiostate &= ~(1 << pin);
6518
6519         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6520                                       AC_VERB_GET_GPIO_MASK, 0);
6521         gpiomask |= (1 << pin);
6522
6523         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6524                                      AC_VERB_GET_GPIO_DIRECTION, 0);
6525         gpiodir |= (1 << pin);
6526
6527
6528         snd_hda_codec_write(codec, codec->afg, 0,
6529                             AC_VERB_SET_GPIO_MASK, gpiomask);
6530         snd_hda_codec_write(codec, codec->afg, 0,
6531                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6532
6533         msleep(1);
6534
6535         snd_hda_codec_write(codec, codec->afg, 0,
6536                             AC_VERB_SET_GPIO_DATA, gpiostate);
6537 }
6538
6539 /* set up GPIO at initialization */
6540 static void alc885_macpro_init_hook(struct hda_codec *codec)
6541 {
6542         alc882_gpio_mute(codec, 0, 0);
6543         alc882_gpio_mute(codec, 1, 0);
6544 }
6545
6546 /* set up GPIO and update auto-muting at initialization */
6547 static void alc885_imac24_init_hook(struct hda_codec *codec)
6548 {
6549         alc885_macpro_init_hook(codec);
6550         alc885_imac24_automute(codec);
6551 }
6552
6553 /*
6554  * generic initialization of ADC, input mixers and output mixers
6555  */
6556 static struct hda_verb alc882_auto_init_verbs[] = {
6557         /*
6558          * Unmute ADC0-2 and set the default input to mic-in
6559          */
6560         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6561         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6562         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6563         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6564         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6565         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6566
6567         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6568          * mixer widget
6569          * Note: PASD motherboards uses the Line In 2 as the input for
6570          * front panel mic (mic 2)
6571          */
6572         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6573         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6574         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6575         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6576         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6577         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6578
6579         /*
6580          * Set up output mixers (0x0c - 0x0f)
6581          */
6582         /* set vol=0 to output mixers */
6583         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6585         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6586         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6587         /* set up input amps for analog loopback */
6588         /* Amp Indices: DAC = 0, mixer = 1 */
6589         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6590         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6591         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6592         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6593         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6594         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6595         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6596         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6597         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6598         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6599
6600         /* FIXME: use matrix-type input source selection */
6601         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6602         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6603         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6604         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6605         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6606         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6607         /* Input mixer2 */
6608         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6609         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6610         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6611         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6612         /* Input mixer3 */
6613         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6614         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6615         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6616         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6617
6618         { }
6619 };
6620
6621 #ifdef CONFIG_SND_HDA_POWER_SAVE
6622 #define alc882_loopbacks        alc880_loopbacks
6623 #endif
6624
6625 /* pcm configuration: identiacal with ALC880 */
6626 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
6627 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
6628 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
6629 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
6630
6631 /*
6632  * configuration and preset
6633  */
6634 static const char *alc882_models[ALC882_MODEL_LAST] = {
6635         [ALC882_3ST_DIG]        = "3stack-dig",
6636         [ALC882_6ST_DIG]        = "6stack-dig",
6637         [ALC882_ARIMA]          = "arima",
6638         [ALC882_W2JC]           = "w2jc",
6639         [ALC882_TARGA]          = "targa",
6640         [ALC882_ASUS_A7J]       = "asus-a7j",
6641         [ALC882_ASUS_A7M]       = "asus-a7m",
6642         [ALC885_MACPRO]         = "macpro",
6643         [ALC885_MBP3]           = "mbp3",
6644         [ALC885_IMAC24]         = "imac24",
6645         [ALC882_AUTO]           = "auto",
6646 };
6647
6648 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6649         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6650         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6651         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6652         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6653         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6654         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6655         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6656         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6657         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6658         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6659         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6660         SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6661         {}
6662 };
6663
6664 static struct alc_config_preset alc882_presets[] = {
6665         [ALC882_3ST_DIG] = {
6666                 .mixers = { alc882_base_mixer },
6667                 .init_verbs = { alc882_init_verbs },
6668                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6669                 .dac_nids = alc882_dac_nids,
6670                 .dig_out_nid = ALC882_DIGOUT_NID,
6671                 .dig_in_nid = ALC882_DIGIN_NID,
6672                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6673                 .channel_mode = alc882_ch_modes,
6674                 .need_dac_fix = 1,
6675                 .input_mux = &alc882_capture_source,
6676         },
6677         [ALC882_6ST_DIG] = {
6678                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6679                 .init_verbs = { alc882_init_verbs },
6680                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6681                 .dac_nids = alc882_dac_nids,
6682                 .dig_out_nid = ALC882_DIGOUT_NID,
6683                 .dig_in_nid = ALC882_DIGIN_NID,
6684                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6685                 .channel_mode = alc882_sixstack_modes,
6686                 .input_mux = &alc882_capture_source,
6687         },
6688         [ALC882_ARIMA] = {
6689                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
6690                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6691                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6692                 .dac_nids = alc882_dac_nids,
6693                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6694                 .channel_mode = alc882_sixstack_modes,
6695                 .input_mux = &alc882_capture_source,
6696         },
6697         [ALC882_W2JC] = {
6698                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6699                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6700                                 alc880_gpio1_init_verbs },
6701                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6702                 .dac_nids = alc882_dac_nids,
6703                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6704                 .channel_mode = alc880_threestack_modes,
6705                 .need_dac_fix = 1,
6706                 .input_mux = &alc882_capture_source,
6707                 .dig_out_nid = ALC882_DIGOUT_NID,
6708         },
6709         [ALC885_MBP3] = {
6710                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6711                 .init_verbs = { alc885_mbp3_init_verbs,
6712                                 alc880_gpio1_init_verbs },
6713                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6714                 .dac_nids = alc882_dac_nids,
6715                 .channel_mode = alc885_mbp_6ch_modes,
6716                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6717                 .input_mux = &alc882_capture_source,
6718                 .dig_out_nid = ALC882_DIGOUT_NID,
6719                 .dig_in_nid = ALC882_DIGIN_NID,
6720                 .unsol_event = alc885_mbp3_unsol_event,
6721                 .init_hook = alc885_mbp3_automute,
6722         },
6723         [ALC885_MACPRO] = {
6724                 .mixers = { alc882_macpro_mixer },
6725                 .init_verbs = { alc882_macpro_init_verbs },
6726                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6727                 .dac_nids = alc882_dac_nids,
6728                 .dig_out_nid = ALC882_DIGOUT_NID,
6729                 .dig_in_nid = ALC882_DIGIN_NID,
6730                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6731                 .channel_mode = alc882_ch_modes,
6732                 .input_mux = &alc882_capture_source,
6733                 .init_hook = alc885_macpro_init_hook,
6734         },
6735         [ALC885_IMAC24] = {
6736                 .mixers = { alc885_imac24_mixer },
6737                 .init_verbs = { alc885_imac24_init_verbs },
6738                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6739                 .dac_nids = alc882_dac_nids,
6740                 .dig_out_nid = ALC882_DIGOUT_NID,
6741                 .dig_in_nid = ALC882_DIGIN_NID,
6742                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6743                 .channel_mode = alc882_ch_modes,
6744                 .input_mux = &alc882_capture_source,
6745                 .unsol_event = alc885_imac24_unsol_event,
6746                 .init_hook = alc885_imac24_init_hook,
6747         },
6748         [ALC882_TARGA] = {
6749                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
6750                 .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6751                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6752                 .dac_nids = alc882_dac_nids,
6753                 .dig_out_nid = ALC882_DIGOUT_NID,
6754                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6755                 .adc_nids = alc882_adc_nids,
6756                 .capsrc_nids = alc882_capsrc_nids,
6757                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6758                 .channel_mode = alc882_3ST_6ch_modes,
6759                 .need_dac_fix = 1,
6760                 .input_mux = &alc882_capture_source,
6761                 .unsol_event = alc882_targa_unsol_event,
6762                 .init_hook = alc882_targa_automute,
6763         },
6764         [ALC882_ASUS_A7J] = {
6765                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
6766                 .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6767                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6768                 .dac_nids = alc882_dac_nids,
6769                 .dig_out_nid = ALC882_DIGOUT_NID,
6770                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6771                 .adc_nids = alc882_adc_nids,
6772                 .capsrc_nids = alc882_capsrc_nids,
6773                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6774                 .channel_mode = alc882_3ST_6ch_modes,
6775                 .need_dac_fix = 1,
6776                 .input_mux = &alc882_capture_source,
6777         },
6778         [ALC882_ASUS_A7M] = {
6779                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6780                 .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6781                                 alc880_gpio1_init_verbs,
6782                                 alc882_asus_a7m_verbs },
6783                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
6784                 .dac_nids = alc882_dac_nids,
6785                 .dig_out_nid = ALC882_DIGOUT_NID,
6786                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6787                 .channel_mode = alc880_threestack_modes,
6788                 .need_dac_fix = 1,
6789                 .input_mux = &alc882_capture_source,
6790         },
6791 };
6792
6793
6794 /*
6795  * Pin config fixes
6796  */
6797 enum {
6798         PINFIX_ABIT_AW9D_MAX
6799 };
6800
6801 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6802         { 0x15, 0x01080104 }, /* side */
6803         { 0x16, 0x01011012 }, /* rear */
6804         { 0x17, 0x01016011 }, /* clfe */
6805         { }
6806 };
6807
6808 static const struct alc_pincfg *alc882_pin_fixes[] = {
6809         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6810 };
6811
6812 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6813         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6814         {}
6815 };
6816
6817 /*
6818  * BIOS auto configuration
6819  */
6820 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6821                                               hda_nid_t nid, int pin_type,
6822                                               int dac_idx)
6823 {
6824         /* set as output */
6825         struct alc_spec *spec = codec->spec;
6826         int idx;
6827
6828         alc_set_pin_output(codec, nid, pin_type);
6829         if (spec->multiout.dac_nids[dac_idx] == 0x25)
6830                 idx = 4;
6831         else
6832                 idx = spec->multiout.dac_nids[dac_idx] - 2;
6833         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
6834
6835 }
6836
6837 static void alc882_auto_init_multi_out(struct hda_codec *codec)
6838 {
6839         struct alc_spec *spec = codec->spec;
6840         int i;
6841
6842         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
6843         for (i = 0; i <= HDA_SIDE; i++) {
6844                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
6845                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6846                 if (nid)
6847                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
6848                                                           i);
6849         }
6850 }
6851
6852 static void alc882_auto_init_hp_out(struct hda_codec *codec)
6853 {
6854         struct alc_spec *spec = codec->spec;
6855         hda_nid_t pin;
6856
6857         pin = spec->autocfg.hp_pins[0];
6858         if (pin) /* connect to front */
6859                 /* use dac 0 */
6860                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
6861         pin = spec->autocfg.speaker_pins[0];
6862         if (pin)
6863                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
6864 }
6865
6866 #define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
6867 #define ALC882_PIN_CD_NID               ALC880_PIN_CD_NID
6868
6869 static void alc882_auto_init_analog_input(struct hda_codec *codec)
6870 {
6871         struct alc_spec *spec = codec->spec;
6872         int i;
6873
6874         for (i = 0; i < AUTO_PIN_LAST; i++) {
6875                 hda_nid_t nid = spec->autocfg.input_pins[i];
6876                 unsigned int vref;
6877                 if (!nid)
6878                         continue;
6879                 vref = PIN_IN;
6880                 if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
6881                         unsigned int pincap;
6882                         pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
6883                         if ((pincap >> AC_PINCAP_VREF_SHIFT) &
6884                             AC_PINCAP_VREF_80)
6885                                 vref = PIN_VREF80;
6886                 }
6887                 snd_hda_codec_write(codec, nid, 0,
6888                                     AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
6889                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
6890                         snd_hda_codec_write(codec, nid, 0,
6891                                             AC_VERB_SET_AMP_GAIN_MUTE,
6892                                             AMP_OUT_MUTE);
6893         }
6894 }
6895
6896 static void alc882_auto_init_input_src(struct hda_codec *codec)
6897 {
6898         struct alc_spec *spec = codec->spec;
6899         int c;
6900
6901         for (c = 0; c < spec->num_adc_nids; c++) {
6902                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
6903                 hda_nid_t nid = spec->capsrc_nids[c];
6904                 unsigned int mux_idx;
6905                 const struct hda_input_mux *imux;
6906                 int conns, mute, idx, item;
6907
6908                 conns = snd_hda_get_connections(codec, nid, conn_list,
6909                                                 ARRAY_SIZE(conn_list));
6910                 if (conns < 0)
6911                         continue;
6912                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
6913                 imux = &spec->input_mux[mux_idx];
6914                 for (idx = 0; idx < conns; idx++) {
6915                         /* if the current connection is the selected one,
6916                          * unmute it as default - otherwise mute it
6917                          */
6918                         mute = AMP_IN_MUTE(idx);
6919                         for (item = 0; item < imux->num_items; item++) {
6920                                 if (imux->items[item].index == idx) {
6921                                         if (spec->cur_mux[c] == item)
6922                                                 mute = AMP_IN_UNMUTE(idx);
6923                                         break;
6924                                 }
6925                         }
6926                         /* check if we have a selector or mixer
6927                          * we could check for the widget type instead, but
6928                          * just check for Amp-In presence (in case of mixer
6929                          * without amp-in there is something wrong, this
6930                          * function shouldn't be used or capsrc nid is wrong)
6931                          */
6932                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
6933                                 snd_hda_codec_write(codec, nid, 0,
6934                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6935                                                     mute);
6936                         else if (mute != AMP_IN_MUTE(idx))
6937                                 snd_hda_codec_write(codec, nid, 0,
6938                                                     AC_VERB_SET_CONNECT_SEL,
6939                                                     idx);
6940                 }
6941         }
6942 }
6943
6944 /* add mic boosts if needed */
6945 static int alc_auto_add_mic_boost(struct hda_codec *codec)
6946 {
6947         struct alc_spec *spec = codec->spec;
6948         int err;
6949         hda_nid_t nid;
6950
6951         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
6952         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6953                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6954                                   "Mic Boost",
6955                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6956                 if (err < 0)
6957                         return err;
6958         }
6959         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
6960         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
6961                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
6962                                   "Front Mic Boost",
6963                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
6964                 if (err < 0)
6965                         return err;
6966         }
6967         return 0;
6968 }
6969
6970 /* almost identical with ALC880 parser... */
6971 static int alc882_parse_auto_config(struct hda_codec *codec)
6972 {
6973         struct alc_spec *spec = codec->spec;
6974         int err = alc880_parse_auto_config(codec);
6975
6976         if (err < 0)
6977                 return err;
6978         else if (!err)
6979                 return 0; /* no config found */
6980
6981         err = alc_auto_add_mic_boost(codec);
6982         if (err < 0)
6983                 return err;
6984
6985         /* hack - override the init verbs */
6986         spec->init_verbs[0] = alc882_auto_init_verbs;
6987
6988         return 1; /* config found */
6989 }
6990
6991 /* additional initialization for auto-configuration model */
6992 static void alc882_auto_init(struct hda_codec *codec)
6993 {
6994         struct alc_spec *spec = codec->spec;
6995         alc882_auto_init_multi_out(codec);
6996         alc882_auto_init_hp_out(codec);
6997         alc882_auto_init_analog_input(codec);
6998         alc882_auto_init_input_src(codec);
6999         if (spec->unsol_event)
7000                 alc_inithook(codec);
7001 }
7002
7003 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7004
7005 static int patch_alc882(struct hda_codec *codec)
7006 {
7007         struct alc_spec *spec;
7008         int err, board_config;
7009
7010         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7011         if (spec == NULL)
7012                 return -ENOMEM;
7013
7014         codec->spec = spec;
7015
7016         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7017                                                   alc882_models,
7018                                                   alc882_cfg_tbl);
7019
7020         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7021                 /* Pick up systems that don't supply PCI SSID */
7022                 switch (codec->subsystem_id) {
7023                 case 0x106b0c00: /* Mac Pro */
7024                         board_config = ALC885_MACPRO;
7025                         break;
7026                 case 0x106b1000: /* iMac 24 */
7027                 case 0x106b2800: /* AppleTV */
7028                 case 0x106b3e00: /* iMac 24 Aluminium */
7029                         board_config = ALC885_IMAC24;
7030                         break;
7031                 case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7032                 case 0x106b00a4: /* MacbookPro4,1 */
7033                 case 0x106b2c00: /* Macbook Pro rev3 */
7034                 case 0x106b3600: /* Macbook 3.1 */
7035                 case 0x106b3800: /* MacbookPro4,1 - latter revision */
7036                         board_config = ALC885_MBP3;
7037                         break;
7038                 default:
7039                         /* ALC889A is handled better as ALC888-compatible */
7040                         if (codec->revision_id == 0x100101 ||
7041                             codec->revision_id == 0x100103) {
7042                                 alc_free(codec);
7043                                 return patch_alc883(codec);
7044                         }
7045                         printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
7046                                          "trying auto-probe from BIOS...\n");
7047                         board_config = ALC882_AUTO;
7048                 }
7049         }
7050
7051         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7052
7053         if (board_config == ALC882_AUTO) {
7054                 /* automatic parse from the BIOS config */
7055                 err = alc882_parse_auto_config(codec);
7056                 if (err < 0) {
7057                         alc_free(codec);
7058                         return err;
7059                 } else if (!err) {
7060                         printk(KERN_INFO
7061                                "hda_codec: Cannot set up configuration "
7062                                "from BIOS.  Using base mode...\n");
7063                         board_config = ALC882_3ST_DIG;
7064                 }
7065         }
7066
7067         err = snd_hda_attach_beep_device(codec, 0x1);
7068         if (err < 0) {
7069                 alc_free(codec);
7070                 return err;
7071         }
7072
7073         if (board_config != ALC882_AUTO)
7074                 setup_preset(spec, &alc882_presets[board_config]);
7075
7076         if (codec->vendor_id == 0x10ec0885) {
7077                 spec->stream_name_analog = "ALC885 Analog";
7078                 spec->stream_name_digital = "ALC885 Digital";
7079         } else {
7080                 spec->stream_name_analog = "ALC882 Analog";
7081                 spec->stream_name_digital = "ALC882 Digital";
7082         }
7083
7084         spec->stream_analog_playback = &alc882_pcm_analog_playback;
7085         spec->stream_analog_capture = &alc882_pcm_analog_capture;
7086         /* FIXME: setup DAC5 */
7087         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7088         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7089
7090         spec->stream_digital_playback = &alc882_pcm_digital_playback;
7091         spec->stream_digital_capture = &alc882_pcm_digital_capture;
7092
7093         spec->capture_style = CAPT_MIX; /* matrix-style capture */
7094         if (!spec->adc_nids && spec->input_mux) {
7095                 /* check whether NID 0x07 is valid */
7096                 unsigned int wcap = get_wcaps(codec, 0x07);
7097                 /* get type */
7098                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7099                 if (wcap != AC_WID_AUD_IN) {
7100                         spec->adc_nids = alc882_adc_nids_alt;
7101                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7102                         spec->capsrc_nids = alc882_capsrc_nids_alt;
7103                 } else {
7104                         spec->adc_nids = alc882_adc_nids;
7105                         spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7106                         spec->capsrc_nids = alc882_capsrc_nids;
7107                 }
7108         }
7109         set_capture_mixer(spec);
7110         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7111
7112         spec->vmaster_nid = 0x0c;
7113
7114         codec->patch_ops = alc_patch_ops;
7115         if (board_config == ALC882_AUTO)
7116                 spec->init_hook = alc882_auto_init;
7117 #ifdef CONFIG_SND_HDA_POWER_SAVE
7118         if (!spec->loopback.amplist)
7119                 spec->loopback.amplist = alc882_loopbacks;
7120 #endif
7121         codec->proc_widget_hook = print_realtek_coef;
7122
7123         return 0;
7124 }
7125
7126 /*
7127  * ALC883 support
7128  *
7129  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7130  * configuration.  Each pin widget can choose any input DACs and a mixer.
7131  * Each ADC is connected from a mixer of all inputs.  This makes possible
7132  * 6-channel independent captures.
7133  *
7134  * In addition, an independent DAC for the multi-playback (not used in this
7135  * driver yet).
7136  */
7137 #define ALC883_DIGOUT_NID       0x06
7138 #define ALC883_DIGIN_NID        0x0a
7139
7140 #define ALC1200_DIGOUT_NID      0x10
7141
7142 static hda_nid_t alc883_dac_nids[4] = {
7143         /* front, rear, clfe, rear_surr */
7144         0x02, 0x03, 0x04, 0x05
7145 };
7146
7147 static hda_nid_t alc883_adc_nids[2] = {
7148         /* ADC1-2 */
7149         0x08, 0x09,
7150 };
7151
7152 static hda_nid_t alc883_adc_nids_alt[1] = {
7153         /* ADC1 */
7154         0x08,
7155 };
7156
7157 static hda_nid_t alc883_adc_nids_rev[2] = {
7158         /* ADC2-1 */
7159         0x09, 0x08
7160 };
7161
7162 #define alc889_adc_nids         alc880_adc_nids
7163
7164 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7165
7166 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7167
7168 #define alc889_capsrc_nids      alc882_capsrc_nids
7169
7170 /* input MUX */
7171 /* FIXME: should be a matrix-type input source selection */
7172
7173 static struct hda_input_mux alc883_capture_source = {
7174         .num_items = 4,
7175         .items = {
7176                 { "Mic", 0x0 },
7177                 { "Front Mic", 0x1 },
7178                 { "Line", 0x2 },
7179                 { "CD", 0x4 },
7180         },
7181 };
7182
7183 static struct hda_input_mux alc883_3stack_6ch_intel = {
7184         .num_items = 4,
7185         .items = {
7186                 { "Mic", 0x1 },
7187                 { "Front Mic", 0x0 },
7188                 { "Line", 0x2 },
7189                 { "CD", 0x4 },
7190         },
7191 };
7192
7193 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7194         .num_items = 2,
7195         .items = {
7196                 { "Mic", 0x1 },
7197                 { "Line", 0x2 },
7198         },
7199 };
7200
7201 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7202         .num_items = 4,
7203         .items = {
7204                 { "Mic", 0x0 },
7205                 { "iMic", 0x1 },
7206                 { "Line", 0x2 },
7207                 { "CD", 0x4 },
7208         },
7209 };
7210
7211 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7212         .num_items = 2,
7213         .items = {
7214                 { "Mic", 0x0 },
7215                 { "Int Mic", 0x1 },
7216         },
7217 };
7218
7219 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7220         .num_items = 3,
7221         .items = {
7222                 { "Mic", 0x0 },
7223                 { "Front Mic", 0x1 },
7224                 { "Line", 0x4 },
7225         },
7226 };
7227
7228 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7229         .num_items = 2,
7230         .items = {
7231                 { "Mic", 0x0 },
7232                 { "Line", 0x2 },
7233         },
7234 };
7235
7236 /*
7237  * 2ch mode
7238  */
7239 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7240         { 2, NULL }
7241 };
7242
7243 /*
7244  * 2ch mode
7245  */
7246 static struct hda_verb alc883_3ST_ch2_init[] = {
7247         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7248         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7249         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7250         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7251         { } /* end */
7252 };
7253
7254 /*
7255  * 4ch mode
7256  */
7257 static struct hda_verb alc883_3ST_ch4_init[] = {
7258         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7259         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7260         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7261         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7262         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7263         { } /* end */
7264 };
7265
7266 /*
7267  * 6ch mode
7268  */
7269 static struct hda_verb alc883_3ST_ch6_init[] = {
7270         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7271         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7272         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7273         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7274         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7275         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7276         { } /* end */
7277 };
7278
7279 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7280         { 2, alc883_3ST_ch2_init },
7281         { 4, alc883_3ST_ch4_init },
7282         { 6, alc883_3ST_ch6_init },
7283 };
7284
7285 /*
7286  * 2ch mode
7287  */
7288 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7289         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7290         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7291         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7292         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7293         { } /* end */
7294 };
7295
7296 /*
7297  * 4ch mode
7298  */
7299 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7300         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7301         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7302         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7303         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7304         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7305         { } /* end */
7306 };
7307
7308 /*
7309  * 6ch mode
7310  */
7311 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7312         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7313         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7314         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7315         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7316         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7317         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7318         { } /* end */
7319 };
7320
7321 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7322         { 2, alc883_3ST_ch2_intel_init },
7323         { 4, alc883_3ST_ch4_intel_init },
7324         { 6, alc883_3ST_ch6_intel_init },
7325 };
7326
7327 /*
7328  * 6ch mode
7329  */
7330 static struct hda_verb alc883_sixstack_ch6_init[] = {
7331         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7332         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7333         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7334         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7335         { } /* end */
7336 };
7337
7338 /*
7339  * 8ch mode
7340  */
7341 static struct hda_verb alc883_sixstack_ch8_init[] = {
7342         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7343         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7344         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7345         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7346         { } /* end */
7347 };
7348
7349 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7350         { 6, alc883_sixstack_ch6_init },
7351         { 8, alc883_sixstack_ch8_init },
7352 };
7353
7354 static struct hda_verb alc883_medion_eapd_verbs[] = {
7355         /* eanable EAPD on medion laptop */
7356         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7357         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7358         { }
7359 };
7360
7361 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7362  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7363  */
7364
7365 static struct snd_kcontrol_new alc883_base_mixer[] = {
7366         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7367         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7368         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7369         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7370         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7371         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7372         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7373         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7374         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7375         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7376         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7377         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7378         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7379         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7380         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7381         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7382         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7383         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7384         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7385         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7386         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7387         { } /* end */
7388 };
7389
7390 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7391         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7392         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7393         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7394         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7395         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7396         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7397         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7398         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7399         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7400         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7401         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7402         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7403         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7404         { } /* end */
7405 };
7406
7407 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7408         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7409         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7410         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7411         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7412         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7413         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7414         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7415         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7416         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7417         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7418         { } /* end */
7419 };
7420
7421 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7422         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7423         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7424         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7425         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7426         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7427         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7428         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7429         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7430         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7431         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7432         { } /* end */
7433 };
7434
7435 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7436         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7437         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7438         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7439         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7440         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7441         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7442         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7443         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7444         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7445         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7446         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7447         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7448         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7449         { } /* end */
7450 };
7451
7452 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7453         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7454         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7455         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7456         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7457         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7458         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7459         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7460         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7461         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7462         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7463         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7464         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7465         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7466         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7467         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7468         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7469         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7470         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7471         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7472         { } /* end */
7473 };
7474
7475 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7476         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7477         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7478         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7479         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7480         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7481                               HDA_OUTPUT),
7482         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7483         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7484         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7485         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7486         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7487         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7488         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7489         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7490         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7491         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7492         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7493         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7494         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7495         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7496         { } /* end */
7497 };
7498
7499 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7500         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7501         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7502         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7503         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7504         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7505         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7506         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7507         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7508         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7509         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7510         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7511         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7512         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7513         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7514         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7515         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7516         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7517         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7518         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7519         { } /* end */
7520 };
7521
7522 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7523         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7524         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7525         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7526         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7527         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7528         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7529         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7530         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7531         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7532         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7533         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7534         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7535         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7536         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7537         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7538         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7539         { } /* end */
7540 };
7541
7542 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7543         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7544         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7545         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7546         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7547         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7548         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7549         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7550         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7551         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7552         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7553         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7554         { } /* end */
7555 };
7556
7557 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7558         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7559         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7560         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7561         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7562         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7563         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7564         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7565         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7566         { } /* end */
7567 };
7568
7569 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7570         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7571         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7572         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7573         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7574         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7575         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7576         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7577         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7578         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7579         { } /* end */
7580 };
7581
7582 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7583         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7584         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7585         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7586         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7587         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7588         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7589         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7590         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7591         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7592         { } /* end */
7593 };
7594
7595 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7596         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7597         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7598         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7599         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7600         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7601         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7602         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7603         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7604         { } /* end */
7605 };
7606
7607 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7608         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7609         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7610         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7611         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7612         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7613                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7614         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7615         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7616         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7617         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7618         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7619         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7620         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7621         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7622         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7623         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7624         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7625         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7626         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7627         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7628         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7629         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7630         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7631         { } /* end */
7632 };
7633
7634 static struct hda_bind_ctls alc883_bind_cap_vol = {
7635         .ops = &snd_hda_bind_vol,
7636         .values = {
7637                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7638                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7639                 0
7640         },
7641 };
7642
7643 static struct hda_bind_ctls alc883_bind_cap_switch = {
7644         .ops = &snd_hda_bind_sw,
7645         .values = {
7646                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7647                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7648                 0
7649         },
7650 };
7651
7652 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7653         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7654         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7655         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7656         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7657         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7658         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7659         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7660         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7661         { } /* end */
7662 };
7663
7664 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7665         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7666         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7667         {
7668                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7669                 /* .name = "Capture Source", */
7670                 .name = "Input Source",
7671                 .count = 1,
7672                 .info = alc_mux_enum_info,
7673                 .get = alc_mux_enum_get,
7674                 .put = alc_mux_enum_put,
7675         },
7676         { } /* end */
7677 };
7678
7679 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7680         {
7681                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7682                 .name = "Channel Mode",
7683                 .info = alc_ch_mode_info,
7684                 .get = alc_ch_mode_get,
7685                 .put = alc_ch_mode_put,
7686         },
7687         { } /* end */
7688 };
7689
7690 static struct hda_verb alc883_init_verbs[] = {
7691         /* ADC1: mute amp left and right */
7692         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7693         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7694         /* ADC2: mute amp left and right */
7695         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7696         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7697         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7698         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7699         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7700         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7701         /* Rear mixer */
7702         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7703         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7704         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7705         /* CLFE mixer */
7706         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7707         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7708         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7709         /* Side mixer */
7710         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7711         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7712         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7713
7714         /* mute analog input loopbacks */
7715         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7716         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7717         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7718         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7719         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7720
7721         /* Front Pin: output 0 (0x0c) */
7722         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7723         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7724         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7725         /* Rear Pin: output 1 (0x0d) */
7726         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7727         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7728         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7729         /* CLFE Pin: output 2 (0x0e) */
7730         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7731         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7732         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7733         /* Side Pin: output 3 (0x0f) */
7734         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7735         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7736         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7737         /* Mic (rear) pin: input vref at 80% */
7738         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7739         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7740         /* Front Mic pin: input vref at 80% */
7741         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7742         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7743         /* Line In pin: input */
7744         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7745         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7746         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7747         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7748         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7749         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7750         /* CD pin widget for input */
7751         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7752
7753         /* FIXME: use matrix-type input source selection */
7754         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7755         /* Input mixer2 */
7756         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7757         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7758         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7759         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7760         /* Input mixer3 */
7761         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7762         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7763         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7764         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7765         { }
7766 };
7767
7768 /* toggle speaker-output according to the hp-jack state */
7769 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7770 {
7771         unsigned int present;
7772
7773         present = snd_hda_codec_read(codec, 0x15, 0,
7774                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7775         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7776                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7777         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7778                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7779 }
7780
7781 /* auto-toggle front mic */
7782 /*
7783 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7784 {
7785         unsigned int present;
7786         unsigned char bits;
7787
7788         present = snd_hda_codec_read(codec, 0x18, 0,
7789                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7790         bits = present ? HDA_AMP_MUTE : 0;
7791         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7792 }
7793 */
7794
7795 static void alc883_mitac_automute(struct hda_codec *codec)
7796 {
7797         alc883_mitac_hp_automute(codec);
7798         /* alc883_mitac_mic_automute(codec); */
7799 }
7800
7801 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7802                                            unsigned int res)
7803 {
7804         switch (res >> 26) {
7805         case ALC880_HP_EVENT:
7806                 alc883_mitac_hp_automute(codec);
7807                 break;
7808         case ALC880_MIC_EVENT:
7809                 /* alc883_mitac_mic_automute(codec); */
7810                 break;
7811         }
7812 }
7813
7814 static struct hda_verb alc883_mitac_verbs[] = {
7815         /* HP */
7816         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7817         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7818         /* Subwoofer */
7819         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7820         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7821
7822         /* enable unsolicited event */
7823         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7824         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7825
7826         { } /* end */
7827 };
7828
7829 static struct hda_verb alc883_clevo_m720_verbs[] = {
7830         /* HP */
7831         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7832         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7833         /* Int speaker */
7834         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7835         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7836
7837         /* enable unsolicited event */
7838         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7839         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7840
7841         { } /* end */
7842 };
7843
7844 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7845         /* HP */
7846         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7847         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7848         /* Subwoofer */
7849         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7850         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7851
7852         /* enable unsolicited event */
7853         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7854
7855         { } /* end */
7856 };
7857
7858 static struct hda_verb alc883_tagra_verbs[] = {
7859         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7860         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7861
7862         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7863         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7864
7865         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7866         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7867         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7868
7869         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7870         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
7871         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
7872         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
7873
7874         { } /* end */
7875 };
7876
7877 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7878         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7879         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7880         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7881         { } /* end */
7882 };
7883
7884 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7885         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7886         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7887         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7888         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7889         { } /* end */
7890 };
7891
7892 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7893         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7894         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7895         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7896         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7897         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7898         { } /* end */
7899 };
7900
7901 static struct hda_verb alc883_haier_w66_verbs[] = {
7902         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7903         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7904
7905         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7906
7907         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7908         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7909         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7910         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7911         { } /* end */
7912 };
7913
7914 static struct hda_verb alc888_lenovo_sky_verbs[] = {
7915         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7916         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7917         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7918         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7919         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7920         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7921         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7922         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7923         { } /* end */
7924 };
7925
7926 static struct hda_verb alc888_3st_hp_verbs[] = {
7927         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7928         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7929         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7930         { }
7931 };
7932
7933 static struct hda_verb alc888_6st_dell_verbs[] = {
7934         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7935         { }
7936 };
7937
7938 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7939         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7940         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7941         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7942         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7943         { }
7944 };
7945
7946 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7947         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7948         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7949         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7950         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7951         { }
7952 };
7953
7954 static struct hda_channel_mode alc888_3st_hp_modes[2] = {
7955         { 2, alc888_3st_hp_2ch_init },
7956         { 6, alc888_3st_hp_6ch_init },
7957 };
7958
7959 /* toggle front-jack and RCA according to the hp-jack state */
7960 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7961 {
7962         unsigned int present;
7963
7964         present = snd_hda_codec_read(codec, 0x1b, 0,
7965                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7966         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7967                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7968         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7969                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7970 }
7971
7972 /* toggle RCA according to the front-jack state */
7973 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7974 {
7975         unsigned int present;
7976
7977         present = snd_hda_codec_read(codec, 0x14, 0,
7978                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7979         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7980                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7981 }
7982
7983 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7984                                              unsigned int res)
7985 {
7986         if ((res >> 26) == ALC880_HP_EVENT)
7987                 alc888_lenovo_ms7195_front_automute(codec);
7988         if ((res >> 26) == ALC880_FRONT_EVENT)
7989                 alc888_lenovo_ms7195_rca_automute(codec);
7990 }
7991
7992 static struct hda_verb alc883_medion_md2_verbs[] = {
7993         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7994         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7995
7996         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7997
7998         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7999         { } /* end */
8000 };
8001
8002 /* toggle speaker-output according to the hp-jack state */
8003 static void alc883_medion_md2_automute(struct hda_codec *codec)
8004 {
8005         unsigned int present;
8006
8007         present = snd_hda_codec_read(codec, 0x14, 0,
8008                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8009         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8010                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8011 }
8012
8013 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
8014                                           unsigned int res)
8015 {
8016         if ((res >> 26) == ALC880_HP_EVENT)
8017                 alc883_medion_md2_automute(codec);
8018 }
8019
8020 /* toggle speaker-output according to the hp-jack state */
8021 static void alc883_tagra_automute(struct hda_codec *codec)
8022 {
8023         unsigned int present;
8024         unsigned char bits;
8025
8026         present = snd_hda_codec_read(codec, 0x14, 0,
8027                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8028         bits = present ? HDA_AMP_MUTE : 0;
8029         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
8030                                  HDA_AMP_MUTE, bits);
8031         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8032                                   present ? 1 : 3);
8033 }
8034
8035 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
8036 {
8037         if ((res >> 26) == ALC880_HP_EVENT)
8038                 alc883_tagra_automute(codec);
8039 }
8040
8041 /* toggle speaker-output according to the hp-jack state */
8042 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
8043 {
8044         unsigned int present;
8045         unsigned char bits;
8046
8047         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
8048                 & AC_PINSENSE_PRESENCE;
8049         bits = present ? HDA_AMP_MUTE : 0;
8050         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8051                                  HDA_AMP_MUTE, bits);
8052 }
8053
8054 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8055 {
8056         unsigned int present;
8057
8058         present = snd_hda_codec_read(codec, 0x18, 0,
8059                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8060         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8061                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8062 }
8063
8064 static void alc883_clevo_m720_automute(struct hda_codec *codec)
8065 {
8066         alc883_clevo_m720_hp_automute(codec);
8067         alc883_clevo_m720_mic_automute(codec);
8068 }
8069
8070 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8071                                            unsigned int res)
8072 {
8073         switch (res >> 26) {
8074         case ALC880_HP_EVENT:
8075                 alc883_clevo_m720_hp_automute(codec);
8076                 break;
8077         case ALC880_MIC_EVENT:
8078                 alc883_clevo_m720_mic_automute(codec);
8079                 break;
8080         }
8081 }
8082
8083 /* toggle speaker-output according to the hp-jack state */
8084 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8085 {
8086         unsigned int present;
8087         unsigned char bits;
8088
8089         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8090                 & AC_PINSENSE_PRESENCE;
8091         bits = present ? HDA_AMP_MUTE : 0;
8092         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8093                                  HDA_AMP_MUTE, bits);
8094 }
8095
8096 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8097                                                   unsigned int res)
8098 {
8099         if ((res >> 26) == ALC880_HP_EVENT)
8100                 alc883_2ch_fujitsu_pi2515_automute(codec);
8101 }
8102
8103 static void alc883_haier_w66_automute(struct hda_codec *codec)
8104 {
8105         unsigned int present;
8106         unsigned char bits;
8107
8108         present = snd_hda_codec_read(codec, 0x1b, 0,
8109                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8110         bits = present ? 0x80 : 0;
8111         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8112                                  0x80, bits);
8113 }
8114
8115 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8116                                          unsigned int res)
8117 {
8118         if ((res >> 26) == ALC880_HP_EVENT)
8119                 alc883_haier_w66_automute(codec);
8120 }
8121
8122 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8123 {
8124         unsigned int present;
8125         unsigned char bits;
8126
8127         present = snd_hda_codec_read(codec, 0x14, 0,
8128                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8129         bits = present ? HDA_AMP_MUTE : 0;
8130         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8131                                  HDA_AMP_MUTE, bits);
8132 }
8133
8134 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8135 {
8136         unsigned int present;
8137         unsigned char bits;
8138
8139         present = snd_hda_codec_read(codec, 0x1b, 0,
8140                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8141         bits = present ? HDA_AMP_MUTE : 0;
8142         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8143                                  HDA_AMP_MUTE, bits);
8144         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8145                                  HDA_AMP_MUTE, bits);
8146 }
8147
8148 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8149                                            unsigned int res)
8150 {
8151         if ((res >> 26) == ALC880_HP_EVENT)
8152                 alc883_lenovo_101e_all_automute(codec);
8153         if ((res >> 26) == ALC880_FRONT_EVENT)
8154                 alc883_lenovo_101e_ispeaker_automute(codec);
8155 }
8156
8157 /* toggle speaker-output according to the hp-jack state */
8158 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8159 {
8160         unsigned int present;
8161
8162         present = snd_hda_codec_read(codec, 0x14, 0,
8163                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8164         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8165                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8166         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8167                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8168 }
8169
8170 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8171                                            unsigned int res)
8172 {
8173         if ((res >> 26) == ALC880_HP_EVENT)
8174                 alc883_acer_aspire_automute(codec);
8175 }
8176
8177 static struct hda_verb alc883_acer_eapd_verbs[] = {
8178         /* HP Pin: output 0 (0x0c) */
8179         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8180         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8181         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8182         /* Front Pin: output 0 (0x0c) */
8183         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8184         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8185         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8186         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8187         /* eanable EAPD on medion laptop */
8188         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8189         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8190         /* enable unsolicited event */
8191         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8192         { }
8193 };
8194
8195 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8196 {
8197         unsigned int present;
8198
8199         present = snd_hda_codec_read(codec, 0x1b, 0,
8200                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8201         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8202                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8203         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8204                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8205         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8206                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8207         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8208                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8209 }
8210
8211 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8212                                              unsigned int res)
8213 {
8214         switch (res >> 26) {
8215         case ALC880_HP_EVENT:
8216                 /* printk(KERN_DEBUG "hp_event\n"); */
8217                 alc888_6st_dell_front_automute(codec);
8218                 break;
8219         }
8220 }
8221
8222 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8223 {
8224         unsigned int mute;
8225         unsigned int present;
8226
8227         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8228         present = snd_hda_codec_read(codec, 0x1b, 0,
8229                                      AC_VERB_GET_PIN_SENSE, 0);
8230         present = (present & 0x80000000) != 0;
8231         if (present) {
8232                 /* mute internal speaker */
8233                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8234                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8235                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8236                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8237                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8238                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8239                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8240                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8241                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8242                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
8243         } else {
8244                 /* unmute internal speaker if necessary */
8245                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8246                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8247                                          HDA_AMP_MUTE, mute);
8248                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8249                                          HDA_AMP_MUTE, mute);
8250                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8251                                          HDA_AMP_MUTE, mute);
8252                 snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8253                                          HDA_AMP_MUTE, mute);
8254                 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8255                                          HDA_AMP_MUTE, mute);
8256         }
8257 }
8258
8259 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8260                                              unsigned int res)
8261 {
8262         if ((res >> 26) == ALC880_HP_EVENT)
8263                 alc888_lenovo_sky_front_automute(codec);
8264 }
8265
8266 /*
8267  * generic initialization of ADC, input mixers and output mixers
8268  */
8269 static struct hda_verb alc883_auto_init_verbs[] = {
8270         /*
8271          * Unmute ADC0-2 and set the default input to mic-in
8272          */
8273         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8274         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8275         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8276         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8277
8278         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8279          * mixer widget
8280          * Note: PASD motherboards uses the Line In 2 as the input for
8281          * front panel mic (mic 2)
8282          */
8283         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8284         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8285         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8286         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8287         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8288         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8289
8290         /*
8291          * Set up output mixers (0x0c - 0x0f)
8292          */
8293         /* set vol=0 to output mixers */
8294         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8295         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8296         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8297         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8298         /* set up input amps for analog loopback */
8299         /* Amp Indices: DAC = 0, mixer = 1 */
8300         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8301         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8302         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8303         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8304         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8305         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8306         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8307         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8308         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8309         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8310
8311         /* FIXME: use matrix-type input source selection */
8312         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8313         /* Input mixer1 */
8314         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8315         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8316         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8317         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8318         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8319         /* Input mixer2 */
8320         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8321         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8322         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8323         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8324         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8325
8326         { }
8327 };
8328
8329 static struct hda_verb alc888_asus_m90v_verbs[] = {
8330         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8331         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8332         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8333         /* enable unsolicited event */
8334         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8335         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8336         { } /* end */
8337 };
8338
8339 static void alc883_nb_mic_automute(struct hda_codec *codec)
8340 {
8341         unsigned int present;
8342
8343         present = snd_hda_codec_read(codec, 0x18, 0,
8344                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8345         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8346                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8347         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8348                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8349 }
8350
8351 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8352 {
8353         unsigned int present;
8354         unsigned char bits;
8355
8356         present = snd_hda_codec_read(codec, 0x1b, 0,
8357                                      AC_VERB_GET_PIN_SENSE, 0)
8358                 & AC_PINSENSE_PRESENCE;
8359         bits = present ? 0 : PIN_OUT;
8360         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8361                             bits);
8362         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8363                             bits);
8364         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8365                             bits);
8366 }
8367
8368 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8369                                            unsigned int res)
8370 {
8371         switch (res >> 26) {
8372         case ALC880_HP_EVENT:
8373                 alc883_M90V_speaker_automute(codec);
8374                 break;
8375         case ALC880_MIC_EVENT:
8376                 alc883_nb_mic_automute(codec);
8377                 break;
8378         }
8379 }
8380
8381 static void alc883_mode2_inithook(struct hda_codec *codec)
8382 {
8383         alc883_M90V_speaker_automute(codec);
8384         alc883_nb_mic_automute(codec);
8385 }
8386
8387 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8388         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8389         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8390         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8391         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8392         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8393         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8394         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8395         /* enable unsolicited event */
8396         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8397         { } /* end */
8398 };
8399
8400 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8401 {
8402         unsigned int present;
8403         unsigned char bits;
8404
8405         present = snd_hda_codec_read(codec, 0x14, 0,
8406                                      AC_VERB_GET_PIN_SENSE, 0)
8407                 & AC_PINSENSE_PRESENCE;
8408         bits = present ? 0 : PIN_OUT;
8409         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8410                             bits);
8411 }
8412
8413 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8414                                            unsigned int res)
8415 {
8416         switch (res >> 26) {
8417         case ALC880_HP_EVENT:
8418                 alc883_eee1601_speaker_automute(codec);
8419                 break;
8420         }
8421 }
8422
8423 static void alc883_eee1601_inithook(struct hda_codec *codec)
8424 {
8425         alc883_eee1601_speaker_automute(codec);
8426 }
8427
8428 #ifdef CONFIG_SND_HDA_POWER_SAVE
8429 #define alc883_loopbacks        alc880_loopbacks
8430 #endif
8431
8432 /* pcm configuration: identiacal with ALC880 */
8433 #define alc883_pcm_analog_playback      alc880_pcm_analog_playback
8434 #define alc883_pcm_analog_capture       alc880_pcm_analog_capture
8435 #define alc883_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
8436 #define alc883_pcm_digital_playback     alc880_pcm_digital_playback
8437 #define alc883_pcm_digital_capture      alc880_pcm_digital_capture
8438
8439 /*
8440  * configuration and preset
8441  */
8442 static const char *alc883_models[ALC883_MODEL_LAST] = {
8443         [ALC883_3ST_2ch_DIG]    = "3stack-dig",
8444         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8445         [ALC883_3ST_6ch]        = "3stack-6ch",
8446         [ALC883_6ST_DIG]        = "6stack-dig",
8447         [ALC883_TARGA_DIG]      = "targa-dig",
8448         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8449         [ALC883_ACER]           = "acer",
8450         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8451         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8452         [ALC883_MEDION]         = "medion",
8453         [ALC883_MEDION_MD2]     = "medion-md2",
8454         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8455         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8456         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8457         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8458         [ALC888_LENOVO_SKY] = "lenovo-sky",
8459         [ALC883_HAIER_W66]      = "haier-w66",
8460         [ALC888_3ST_HP]         = "3stack-hp",
8461         [ALC888_6ST_DELL]       = "6stack-dell",
8462         [ALC883_MITAC]          = "mitac",
8463         [ALC883_CLEVO_M720]     = "clevo-m720",
8464         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8465         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8466         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8467         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8468         [ALC883_AUTO]           = "auto",
8469 };
8470
8471 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8472         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8473         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8474         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8475         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8476         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8477         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8478         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8479                 ALC888_ACER_ASPIRE_4930G),
8480         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8481                 ALC888_ACER_ASPIRE_4930G),
8482         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8483         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8484         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8485                 ALC888_ACER_ASPIRE_4930G),
8486         /* default Acer */
8487         SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
8488         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8489         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8490         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8491         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8492         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8493         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8494         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8495         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8496         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8497         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8498         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8499         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8500         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8501         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8502         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8503         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8504         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8505         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8506         SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8507         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8508         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8509         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8510         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8511         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8512         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8513         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8514         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8515         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8516         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8517         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8518         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8519         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8520         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8521         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8522         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8523         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8524         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8525         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8526         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8527         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8528         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8529         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8530         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8531         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8532         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8533         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8534         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8535         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8536         SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550",
8537                       ALC883_FUJITSU_PI2515),
8538         SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8539         SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
8540                 ALC888_FUJITSU_XA3530),
8541         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8542         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8543         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8544         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8545         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8546         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8547         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8548         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8549         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8550         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8551         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8552         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8553         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8554         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8555         {}
8556 };
8557
8558 static hda_nid_t alc1200_slave_dig_outs[] = {
8559         ALC883_DIGOUT_NID, 0,
8560 };
8561
8562 static struct alc_config_preset alc883_presets[] = {
8563         [ALC883_3ST_2ch_DIG] = {
8564                 .mixers = { alc883_3ST_2ch_mixer },
8565                 .init_verbs = { alc883_init_verbs },
8566                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8567                 .dac_nids = alc883_dac_nids,
8568                 .dig_out_nid = ALC883_DIGOUT_NID,
8569                 .dig_in_nid = ALC883_DIGIN_NID,
8570                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8571                 .channel_mode = alc883_3ST_2ch_modes,
8572                 .input_mux = &alc883_capture_source,
8573         },
8574         [ALC883_3ST_6ch_DIG] = {
8575                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8576                 .init_verbs = { alc883_init_verbs },
8577                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8578                 .dac_nids = alc883_dac_nids,
8579                 .dig_out_nid = ALC883_DIGOUT_NID,
8580                 .dig_in_nid = ALC883_DIGIN_NID,
8581                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8582                 .channel_mode = alc883_3ST_6ch_modes,
8583                 .need_dac_fix = 1,
8584                 .input_mux = &alc883_capture_source,
8585         },
8586         [ALC883_3ST_6ch] = {
8587                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8588                 .init_verbs = { alc883_init_verbs },
8589                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8590                 .dac_nids = alc883_dac_nids,
8591                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8592                 .channel_mode = alc883_3ST_6ch_modes,
8593                 .need_dac_fix = 1,
8594                 .input_mux = &alc883_capture_source,
8595         },
8596         [ALC883_3ST_6ch_INTEL] = {
8597                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8598                 .init_verbs = { alc883_init_verbs },
8599                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8600                 .dac_nids = alc883_dac_nids,
8601                 .dig_out_nid = ALC883_DIGOUT_NID,
8602                 .dig_in_nid = ALC883_DIGIN_NID,
8603                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8604                 .channel_mode = alc883_3ST_6ch_intel_modes,
8605                 .need_dac_fix = 1,
8606                 .input_mux = &alc883_3stack_6ch_intel,
8607         },
8608         [ALC883_6ST_DIG] = {
8609                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8610                 .init_verbs = { alc883_init_verbs },
8611                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8612                 .dac_nids = alc883_dac_nids,
8613                 .dig_out_nid = ALC883_DIGOUT_NID,
8614                 .dig_in_nid = ALC883_DIGIN_NID,
8615                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8616                 .channel_mode = alc883_sixstack_modes,
8617                 .input_mux = &alc883_capture_source,
8618         },
8619         [ALC883_TARGA_DIG] = {
8620                 .mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8621                 .init_verbs = { alc883_init_verbs, alc883_tagra_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_6ch_modes),
8626                 .channel_mode = alc883_3ST_6ch_modes,
8627                 .need_dac_fix = 1,
8628                 .input_mux = &alc883_capture_source,
8629                 .unsol_event = alc883_tagra_unsol_event,
8630                 .init_hook = alc883_tagra_automute,
8631         },
8632         [ALC883_TARGA_2ch_DIG] = {
8633                 .mixers = { alc883_tagra_2ch_mixer},
8634                 .init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8635                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8636                 .dac_nids = alc883_dac_nids,
8637                 .adc_nids = alc883_adc_nids_alt,
8638                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8639                 .dig_out_nid = ALC883_DIGOUT_NID,
8640                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8641                 .channel_mode = alc883_3ST_2ch_modes,
8642                 .input_mux = &alc883_capture_source,
8643                 .unsol_event = alc883_tagra_unsol_event,
8644                 .init_hook = alc883_tagra_automute,
8645         },
8646         [ALC883_ACER] = {
8647                 .mixers = { alc883_base_mixer },
8648                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8649                  * and the headphone jack.  Turn this on and rely on the
8650                  * standard mute methods whenever the user wants to turn
8651                  * these outputs off.
8652                  */
8653                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8654                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8655                 .dac_nids = alc883_dac_nids,
8656                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8657                 .channel_mode = alc883_3ST_2ch_modes,
8658                 .input_mux = &alc883_capture_source,
8659         },
8660         [ALC883_ACER_ASPIRE] = {
8661                 .mixers = { alc883_acer_aspire_mixer },
8662                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8663                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8664                 .dac_nids = alc883_dac_nids,
8665                 .dig_out_nid = ALC883_DIGOUT_NID,
8666                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8667                 .channel_mode = alc883_3ST_2ch_modes,
8668                 .input_mux = &alc883_capture_source,
8669                 .unsol_event = alc883_acer_aspire_unsol_event,
8670                 .init_hook = alc883_acer_aspire_automute,
8671         },
8672         [ALC888_ACER_ASPIRE_4930G] = {
8673                 .mixers = { alc888_base_mixer,
8674                                 alc883_chmode_mixer },
8675                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8676                                 alc888_acer_aspire_4930g_verbs },
8677                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8678                 .dac_nids = alc883_dac_nids,
8679                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8680                 .adc_nids = alc883_adc_nids_rev,
8681                 .capsrc_nids = alc883_capsrc_nids_rev,
8682                 .dig_out_nid = ALC883_DIGOUT_NID,
8683                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8684                 .channel_mode = alc883_3ST_6ch_modes,
8685                 .need_dac_fix = 1,
8686                 .num_mux_defs =
8687                         ARRAY_SIZE(alc888_2_capture_sources),
8688                 .input_mux = alc888_2_capture_sources,
8689                 .unsol_event = alc888_acer_aspire_4930g_unsol_event,
8690                 .init_hook = alc888_acer_aspire_4930g_automute,
8691         },
8692         [ALC883_MEDION] = {
8693                 .mixers = { alc883_fivestack_mixer,
8694                             alc883_chmode_mixer },
8695                 .init_verbs = { alc883_init_verbs,
8696                                 alc883_medion_eapd_verbs },
8697                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8698                 .dac_nids = alc883_dac_nids,
8699                 .adc_nids = alc883_adc_nids_alt,
8700                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8701                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8702                 .channel_mode = alc883_sixstack_modes,
8703                 .input_mux = &alc883_capture_source,
8704         },
8705         [ALC883_MEDION_MD2] = {
8706                 .mixers = { alc883_medion_md2_mixer},
8707                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8708                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8709                 .dac_nids = alc883_dac_nids,
8710                 .dig_out_nid = ALC883_DIGOUT_NID,
8711                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8712                 .channel_mode = alc883_3ST_2ch_modes,
8713                 .input_mux = &alc883_capture_source,
8714                 .unsol_event = alc883_medion_md2_unsol_event,
8715                 .init_hook = alc883_medion_md2_automute,
8716         },
8717         [ALC883_LAPTOP_EAPD] = {
8718                 .mixers = { alc883_base_mixer },
8719                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8720                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8721                 .dac_nids = alc883_dac_nids,
8722                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8723                 .channel_mode = alc883_3ST_2ch_modes,
8724                 .input_mux = &alc883_capture_source,
8725         },
8726         [ALC883_CLEVO_M720] = {
8727                 .mixers = { alc883_clevo_m720_mixer },
8728                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8729                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8730                 .dac_nids = alc883_dac_nids,
8731                 .dig_out_nid = ALC883_DIGOUT_NID,
8732                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8733                 .channel_mode = alc883_3ST_2ch_modes,
8734                 .input_mux = &alc883_capture_source,
8735                 .unsol_event = alc883_clevo_m720_unsol_event,
8736                 .init_hook = alc883_clevo_m720_automute,
8737         },
8738         [ALC883_LENOVO_101E_2ch] = {
8739                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8740                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8741                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8742                 .dac_nids = alc883_dac_nids,
8743                 .adc_nids = alc883_adc_nids_alt,
8744                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8745                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8746                 .channel_mode = alc883_3ST_2ch_modes,
8747                 .input_mux = &alc883_lenovo_101e_capture_source,
8748                 .unsol_event = alc883_lenovo_101e_unsol_event,
8749                 .init_hook = alc883_lenovo_101e_all_automute,
8750         },
8751         [ALC883_LENOVO_NB0763] = {
8752                 .mixers = { alc883_lenovo_nb0763_mixer },
8753                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8754                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8755                 .dac_nids = alc883_dac_nids,
8756                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8757                 .channel_mode = alc883_3ST_2ch_modes,
8758                 .need_dac_fix = 1,
8759                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8760                 .unsol_event = alc883_medion_md2_unsol_event,
8761                 .init_hook = alc883_medion_md2_automute,
8762         },
8763         [ALC888_LENOVO_MS7195_DIG] = {
8764                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8765                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8766                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8767                 .dac_nids = alc883_dac_nids,
8768                 .dig_out_nid = ALC883_DIGOUT_NID,
8769                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8770                 .channel_mode = alc883_3ST_6ch_modes,
8771                 .need_dac_fix = 1,
8772                 .input_mux = &alc883_capture_source,
8773                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8774                 .init_hook = alc888_lenovo_ms7195_front_automute,
8775         },
8776         [ALC883_HAIER_W66] = {
8777                 .mixers = { alc883_tagra_2ch_mixer},
8778                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8779                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8780                 .dac_nids = alc883_dac_nids,
8781                 .dig_out_nid = ALC883_DIGOUT_NID,
8782                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8783                 .channel_mode = alc883_3ST_2ch_modes,
8784                 .input_mux = &alc883_capture_source,
8785                 .unsol_event = alc883_haier_w66_unsol_event,
8786                 .init_hook = alc883_haier_w66_automute,
8787         },
8788         [ALC888_3ST_HP] = {
8789                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8790                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8791                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8792                 .dac_nids = alc883_dac_nids,
8793                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8794                 .channel_mode = alc888_3st_hp_modes,
8795                 .need_dac_fix = 1,
8796                 .input_mux = &alc883_capture_source,
8797         },
8798         [ALC888_6ST_DELL] = {
8799                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8800                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8801                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8802                 .dac_nids = alc883_dac_nids,
8803                 .dig_out_nid = ALC883_DIGOUT_NID,
8804                 .dig_in_nid = ALC883_DIGIN_NID,
8805                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8806                 .channel_mode = alc883_sixstack_modes,
8807                 .input_mux = &alc883_capture_source,
8808                 .unsol_event = alc888_6st_dell_unsol_event,
8809                 .init_hook = alc888_6st_dell_front_automute,
8810         },
8811         [ALC883_MITAC] = {
8812                 .mixers = { alc883_mitac_mixer },
8813                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8814                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8815                 .dac_nids = alc883_dac_nids,
8816                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8817                 .channel_mode = alc883_3ST_2ch_modes,
8818                 .input_mux = &alc883_capture_source,
8819                 .unsol_event = alc883_mitac_unsol_event,
8820                 .init_hook = alc883_mitac_automute,
8821         },
8822         [ALC883_FUJITSU_PI2515] = {
8823                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8824                 .init_verbs = { alc883_init_verbs,
8825                                 alc883_2ch_fujitsu_pi2515_verbs},
8826                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8827                 .dac_nids = alc883_dac_nids,
8828                 .dig_out_nid = ALC883_DIGOUT_NID,
8829                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8830                 .channel_mode = alc883_3ST_2ch_modes,
8831                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8832                 .unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
8833                 .init_hook = alc883_2ch_fujitsu_pi2515_automute,
8834         },
8835         [ALC888_FUJITSU_XA3530] = {
8836                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
8837                 .init_verbs = { alc883_init_verbs,
8838                         alc888_fujitsu_xa3530_verbs },
8839                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8840                 .dac_nids = alc883_dac_nids,
8841                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8842                 .adc_nids = alc883_adc_nids_rev,
8843                 .capsrc_nids = alc883_capsrc_nids_rev,
8844                 .dig_out_nid = ALC883_DIGOUT_NID,
8845                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
8846                 .channel_mode = alc888_4ST_8ch_intel_modes,
8847                 .num_mux_defs =
8848                         ARRAY_SIZE(alc888_2_capture_sources),
8849                 .input_mux = alc888_2_capture_sources,
8850                 .unsol_event = alc888_fujitsu_xa3530_unsol_event,
8851                 .init_hook = alc888_fujitsu_xa3530_automute,
8852         },
8853         [ALC888_LENOVO_SKY] = {
8854                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8855                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8856                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8857                 .dac_nids = alc883_dac_nids,
8858                 .dig_out_nid = ALC883_DIGOUT_NID,
8859                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8860                 .channel_mode = alc883_sixstack_modes,
8861                 .need_dac_fix = 1,
8862                 .input_mux = &alc883_lenovo_sky_capture_source,
8863                 .unsol_event = alc883_lenovo_sky_unsol_event,
8864                 .init_hook = alc888_lenovo_sky_front_automute,
8865         },
8866         [ALC888_ASUS_M90V] = {
8867                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8868                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
8869                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8870                 .dac_nids = alc883_dac_nids,
8871                 .dig_out_nid = ALC883_DIGOUT_NID,
8872                 .dig_in_nid = ALC883_DIGIN_NID,
8873                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8874                 .channel_mode = alc883_3ST_6ch_modes,
8875                 .need_dac_fix = 1,
8876                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8877                 .unsol_event = alc883_mode2_unsol_event,
8878                 .init_hook = alc883_mode2_inithook,
8879         },
8880         [ALC888_ASUS_EEE1601] = {
8881                 .mixers = { alc883_asus_eee1601_mixer },
8882                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
8883                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
8884                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8885                 .dac_nids = alc883_dac_nids,
8886                 .dig_out_nid = ALC883_DIGOUT_NID,
8887                 .dig_in_nid = ALC883_DIGIN_NID,
8888                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8889                 .channel_mode = alc883_3ST_2ch_modes,
8890                 .need_dac_fix = 1,
8891                 .input_mux = &alc883_asus_eee1601_capture_source,
8892                 .unsol_event = alc883_eee1601_unsol_event,
8893                 .init_hook = alc883_eee1601_inithook,
8894         },
8895         [ALC1200_ASUS_P5Q] = {
8896                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8897                 .init_verbs = { alc883_init_verbs },
8898                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8899                 .dac_nids = alc883_dac_nids,
8900                 .dig_out_nid = ALC1200_DIGOUT_NID,
8901                 .dig_in_nid = ALC883_DIGIN_NID,
8902                 .slave_dig_outs = alc1200_slave_dig_outs,
8903                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8904                 .channel_mode = alc883_sixstack_modes,
8905                 .input_mux = &alc883_capture_source,
8906         },
8907 };
8908
8909
8910 /*
8911  * BIOS auto configuration
8912  */
8913 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
8914                                               hda_nid_t nid, int pin_type,
8915                                               int dac_idx)
8916 {
8917         /* set as output */
8918         struct alc_spec *spec = codec->spec;
8919         int idx;
8920
8921         alc_set_pin_output(codec, nid, pin_type);
8922         if (spec->multiout.dac_nids[dac_idx] == 0x25)
8923                 idx = 4;
8924         else
8925                 idx = spec->multiout.dac_nids[dac_idx] - 2;
8926         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
8927
8928 }
8929
8930 static void alc883_auto_init_multi_out(struct hda_codec *codec)
8931 {
8932         struct alc_spec *spec = codec->spec;
8933         int i;
8934
8935         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
8936         for (i = 0; i <= HDA_SIDE; i++) {
8937                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
8938                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
8939                 if (nid)
8940                         alc883_auto_set_output_and_unmute(codec, nid, pin_type,
8941                                                           i);
8942         }
8943 }
8944
8945 static void alc883_auto_init_hp_out(struct hda_codec *codec)
8946 {
8947         struct alc_spec *spec = codec->spec;
8948         hda_nid_t pin;
8949
8950         pin = spec->autocfg.hp_pins[0];
8951         if (pin) /* connect to front */
8952                 /* use dac 0 */
8953                 alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
8954         pin = spec->autocfg.speaker_pins[0];
8955         if (pin)
8956                 alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
8957 }
8958
8959 #define alc883_is_input_pin(nid)        alc880_is_input_pin(nid)
8960 #define ALC883_PIN_CD_NID               ALC880_PIN_CD_NID
8961
8962 static void alc883_auto_init_analog_input(struct hda_codec *codec)
8963 {
8964         struct alc_spec *spec = codec->spec;
8965         int i;
8966
8967         for (i = 0; i < AUTO_PIN_LAST; i++) {
8968                 hda_nid_t nid = spec->autocfg.input_pins[i];
8969                 if (alc883_is_input_pin(nid)) {
8970                         snd_hda_codec_write(codec, nid, 0,
8971                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
8972                                             (i <= AUTO_PIN_FRONT_MIC ?
8973                                              PIN_VREF80 : PIN_IN));
8974                         if (nid != ALC883_PIN_CD_NID)
8975                                 snd_hda_codec_write(codec, nid, 0,
8976                                                     AC_VERB_SET_AMP_GAIN_MUTE,
8977                                                     AMP_OUT_MUTE);
8978                 }
8979         }
8980 }
8981
8982 #define alc883_auto_init_input_src      alc882_auto_init_input_src
8983
8984 /* almost identical with ALC880 parser... */
8985 static int alc883_parse_auto_config(struct hda_codec *codec)
8986 {
8987         struct alc_spec *spec = codec->spec;
8988         int err = alc880_parse_auto_config(codec);
8989         struct auto_pin_cfg *cfg = &spec->autocfg;
8990         int i;
8991
8992         if (err < 0)
8993                 return err;
8994         else if (!err)
8995                 return 0; /* no config found */
8996
8997         err = alc_auto_add_mic_boost(codec);
8998         if (err < 0)
8999                 return err;
9000
9001         /* hack - override the init verbs */
9002         spec->init_verbs[0] = alc883_auto_init_verbs;
9003
9004         /* setup input_mux for ALC889 */
9005         if (codec->vendor_id == 0x10ec0889) {
9006                 /* digital-mic input pin is excluded in alc880_auto_create..()
9007                  * because it's under 0x18
9008                  */
9009                 if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9010                     cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9011                         struct hda_input_mux *imux = &spec->private_imux[0];
9012                         for (i = 1; i < 3; i++)
9013                                 memcpy(&spec->private_imux[i],
9014                                        &spec->private_imux[0],
9015                                        sizeof(spec->private_imux[0]));
9016                         imux->items[imux->num_items].label = "Int DMic";
9017                         imux->items[imux->num_items].index = 0x0b;
9018                         imux->num_items++;
9019                         spec->num_mux_defs = 3;
9020                         spec->input_mux = spec->private_imux;
9021                 }
9022         }
9023
9024         return 1; /* config found */
9025 }
9026
9027 /* additional initialization for auto-configuration model */
9028 static void alc883_auto_init(struct hda_codec *codec)
9029 {
9030         struct alc_spec *spec = codec->spec;
9031         alc883_auto_init_multi_out(codec);
9032         alc883_auto_init_hp_out(codec);
9033         alc883_auto_init_analog_input(codec);
9034         alc883_auto_init_input_src(codec);
9035         if (spec->unsol_event)
9036                 alc_inithook(codec);
9037 }
9038
9039 static int patch_alc883(struct hda_codec *codec)
9040 {
9041         struct alc_spec *spec;
9042         int err, board_config;
9043
9044         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9045         if (spec == NULL)
9046                 return -ENOMEM;
9047
9048         codec->spec = spec;
9049
9050         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9051
9052         board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9053                                                   alc883_models,
9054                                                   alc883_cfg_tbl);
9055         if (board_config < 0) {
9056                 printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9057                        "trying auto-probe from BIOS...\n");
9058                 board_config = ALC883_AUTO;
9059         }
9060
9061         if (board_config == ALC883_AUTO) {
9062                 /* automatic parse from the BIOS config */
9063                 err = alc883_parse_auto_config(codec);
9064                 if (err < 0) {
9065                         alc_free(codec);
9066                         return err;
9067                 } else if (!err) {
9068                         printk(KERN_INFO
9069                                "hda_codec: Cannot set up configuration "
9070                                "from BIOS.  Using base mode...\n");
9071                         board_config = ALC883_3ST_2ch_DIG;
9072                 }
9073         }
9074
9075         err = snd_hda_attach_beep_device(codec, 0x1);
9076         if (err < 0) {
9077                 alc_free(codec);
9078                 return err;
9079         }
9080
9081         if (board_config != ALC883_AUTO)
9082                 setup_preset(spec, &alc883_presets[board_config]);
9083
9084         switch (codec->vendor_id) {
9085         case 0x10ec0888:
9086                 if (codec->revision_id == 0x100101) {
9087                         spec->stream_name_analog = "ALC1200 Analog";
9088                         spec->stream_name_digital = "ALC1200 Digital";
9089                 } else {
9090                         spec->stream_name_analog = "ALC888 Analog";
9091                         spec->stream_name_digital = "ALC888 Digital";
9092                 }
9093                 if (!spec->num_adc_nids) {
9094                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9095                         spec->adc_nids = alc883_adc_nids;
9096                 }
9097                 if (!spec->capsrc_nids)
9098                         spec->capsrc_nids = alc883_capsrc_nids;
9099                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9100                 break;
9101         case 0x10ec0889:
9102                 spec->stream_name_analog = "ALC889 Analog";
9103                 spec->stream_name_digital = "ALC889 Digital";
9104                 if (!spec->num_adc_nids) {
9105                         spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9106                         spec->adc_nids = alc889_adc_nids;
9107                 }
9108                 if (!spec->capsrc_nids)
9109                         spec->capsrc_nids = alc889_capsrc_nids;
9110                 spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9111                                                         capture */
9112                 break;
9113         default:
9114                 spec->stream_name_analog = "ALC883 Analog";
9115                 spec->stream_name_digital = "ALC883 Digital";
9116                 if (!spec->num_adc_nids) {
9117                         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9118                         spec->adc_nids = alc883_adc_nids;
9119                 }
9120                 if (!spec->capsrc_nids)
9121                         spec->capsrc_nids = alc883_capsrc_nids;
9122                 spec->capture_style = CAPT_MIX; /* matrix-style capture */
9123                 break;
9124         }
9125
9126         spec->stream_analog_playback = &alc883_pcm_analog_playback;
9127         spec->stream_analog_capture = &alc883_pcm_analog_capture;
9128         spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9129
9130         spec->stream_digital_playback = &alc883_pcm_digital_playback;
9131         spec->stream_digital_capture = &alc883_pcm_digital_capture;
9132
9133         if (!spec->cap_mixer)
9134                 set_capture_mixer(spec);
9135         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9136
9137         spec->vmaster_nid = 0x0c;
9138
9139         codec->patch_ops = alc_patch_ops;
9140         if (board_config == ALC883_AUTO)
9141                 spec->init_hook = alc883_auto_init;
9142
9143 #ifdef CONFIG_SND_HDA_POWER_SAVE
9144         if (!spec->loopback.amplist)
9145                 spec->loopback.amplist = alc883_loopbacks;
9146 #endif
9147         codec->proc_widget_hook = print_realtek_coef;
9148
9149         return 0;
9150 }
9151
9152 /*
9153  * ALC262 support
9154  */
9155
9156 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9157 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9158
9159 #define alc262_dac_nids         alc260_dac_nids
9160 #define alc262_adc_nids         alc882_adc_nids
9161 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9162 #define alc262_capsrc_nids      alc882_capsrc_nids
9163 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9164
9165 #define alc262_modes            alc260_modes
9166 #define alc262_capture_source   alc882_capture_source
9167
9168 static hda_nid_t alc262_dmic_adc_nids[1] = {
9169         /* ADC0 */
9170         0x09
9171 };
9172
9173 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9174
9175 static struct snd_kcontrol_new alc262_base_mixer[] = {
9176         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9177         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9178         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9179         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9180         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9181         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9182         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9183         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9184         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9185         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9186         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9187         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9188         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9189         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9190         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9191         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9192         { } /* end */
9193 };
9194
9195 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9196         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9197         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9198         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9199         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9200         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9201         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9202         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9203         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9204         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9205         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9206         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9207         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9208         /*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9209         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9210         { } /* end */
9211 };
9212
9213 /* update HP, line and mono-out pins according to the master switch */
9214 static void alc262_hp_master_update(struct hda_codec *codec)
9215 {
9216         struct alc_spec *spec = codec->spec;
9217         int val = spec->master_sw;
9218
9219         /* HP & line-out */
9220         snd_hda_codec_write_cache(codec, 0x1b, 0,
9221                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9222                                   val ? PIN_HP : 0);
9223         snd_hda_codec_write_cache(codec, 0x15, 0,
9224                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9225                                   val ? PIN_HP : 0);
9226         /* mono (speaker) depending on the HP jack sense */
9227         val = val && !spec->jack_present;
9228         snd_hda_codec_write_cache(codec, 0x16, 0,
9229                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9230                                   val ? PIN_OUT : 0);
9231 }
9232
9233 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9234 {
9235         struct alc_spec *spec = codec->spec;
9236         unsigned int presence;
9237         presence = snd_hda_codec_read(codec, 0x1b, 0,
9238                                       AC_VERB_GET_PIN_SENSE, 0);
9239         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9240         alc262_hp_master_update(codec);
9241 }
9242
9243 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9244 {
9245         if ((res >> 26) != ALC880_HP_EVENT)
9246                 return;
9247         alc262_hp_bpc_automute(codec);
9248 }
9249
9250 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9251 {
9252         struct alc_spec *spec = codec->spec;
9253         unsigned int presence;
9254         presence = snd_hda_codec_read(codec, 0x15, 0,
9255                                       AC_VERB_GET_PIN_SENSE, 0);
9256         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9257         alc262_hp_master_update(codec);
9258 }
9259
9260 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9261                                            unsigned int res)
9262 {
9263         if ((res >> 26) != ALC880_HP_EVENT)
9264                 return;
9265         alc262_hp_wildwest_automute(codec);
9266 }
9267
9268 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9269                                    struct snd_ctl_elem_value *ucontrol)
9270 {
9271         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9272         struct alc_spec *spec = codec->spec;
9273         *ucontrol->value.integer.value = spec->master_sw;
9274         return 0;
9275 }
9276
9277 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9278                                    struct snd_ctl_elem_value *ucontrol)
9279 {
9280         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9281         struct alc_spec *spec = codec->spec;
9282         int val = !!*ucontrol->value.integer.value;
9283
9284         if (val == spec->master_sw)
9285                 return 0;
9286         spec->master_sw = val;
9287         alc262_hp_master_update(codec);
9288         return 1;
9289 }
9290
9291 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9292         {
9293                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9294                 .name = "Master Playback Switch",
9295                 .info = snd_ctl_boolean_mono_info,
9296                 .get = alc262_hp_master_sw_get,
9297                 .put = alc262_hp_master_sw_put,
9298         },
9299         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9300         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9301         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9302         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9303                               HDA_OUTPUT),
9304         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9305                             HDA_OUTPUT),
9306         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9307         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9308         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9309         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9310         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9311         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9312         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9313         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9314         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9315         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9316         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9317         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9318         { } /* end */
9319 };
9320
9321 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9322         {
9323                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9324                 .name = "Master Playback Switch",
9325                 .info = snd_ctl_boolean_mono_info,
9326                 .get = alc262_hp_master_sw_get,
9327                 .put = alc262_hp_master_sw_put,
9328         },
9329         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9330         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9331         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9332         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9333         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9334                               HDA_OUTPUT),
9335         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9336                             HDA_OUTPUT),
9337         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9338         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9339         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9340         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9341         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9342         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9343         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9344         { } /* end */
9345 };
9346
9347 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9348         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9349         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9350         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9351         { } /* end */
9352 };
9353
9354 /* mute/unmute internal speaker according to the hp jack and mute state */
9355 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9356 {
9357         struct alc_spec *spec = codec->spec;
9358
9359         if (force || !spec->sense_updated) {
9360                 unsigned int present;
9361                 present = snd_hda_codec_read(codec, 0x15, 0,
9362                                              AC_VERB_GET_PIN_SENSE, 0);
9363                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9364                 spec->sense_updated = 1;
9365         }
9366         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9367                                  spec->jack_present ? HDA_AMP_MUTE : 0);
9368 }
9369
9370 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9371                                         unsigned int res)
9372 {
9373         if ((res >> 26) != ALC880_HP_EVENT)
9374                 return;
9375         alc262_hp_t5735_automute(codec, 1);
9376 }
9377
9378 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9379 {
9380         alc262_hp_t5735_automute(codec, 1);
9381 }
9382
9383 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9384         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9385         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9386         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9387         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9388         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9389         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9390         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9391         { } /* end */
9392 };
9393
9394 static struct hda_verb alc262_hp_t5735_verbs[] = {
9395         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9396         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9397
9398         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9399         { }
9400 };
9401
9402 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9403         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9404         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9405         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9406         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9407         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9408         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9409         { } /* end */
9410 };
9411
9412 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9413         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9414         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9415         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9416         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9417         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9418         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9419         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9420         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9421         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9422         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9423         {}
9424 };
9425
9426 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9427         .num_items = 1,
9428         .items = {
9429                 { "Line", 0x1 },
9430         },
9431 };
9432
9433 /* bind hp and internal speaker mute (with plug check) */
9434 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9435                                      struct snd_ctl_elem_value *ucontrol)
9436 {
9437         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9438         long *valp = ucontrol->value.integer.value;
9439         int change;
9440
9441         /* change hp mute */
9442         change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9443                                           HDA_AMP_MUTE,
9444                                           valp[0] ? 0 : HDA_AMP_MUTE);
9445         change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9446                                            HDA_AMP_MUTE,
9447                                            valp[1] ? 0 : HDA_AMP_MUTE);
9448         if (change) {
9449                 /* change speaker according to HP jack state */
9450                 struct alc_spec *spec = codec->spec;
9451                 unsigned int mute;
9452                 if (spec->jack_present)
9453                         mute = HDA_AMP_MUTE;
9454                 else
9455                         mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9456                                                       HDA_OUTPUT, 0);
9457                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9458                                          HDA_AMP_MUTE, mute);
9459         }
9460         return change;
9461 }
9462
9463 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9464         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9465         {
9466                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9467                 .name = "Master Playback Switch",
9468                 .info = snd_hda_mixer_amp_switch_info,
9469                 .get = snd_hda_mixer_amp_switch_get,
9470                 .put = alc262_sony_master_sw_put,
9471                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9472         },
9473         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9474         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9475         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9476         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9477         { } /* end */
9478 };
9479
9480 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9481         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9482         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9483         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9484         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9485         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9486         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9487         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9488         { } /* end */
9489 };
9490
9491 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9492         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9493         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9494         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9495         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9496         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9497         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9498         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9499         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9500         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9501         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9502         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9503         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9504         { } /* end */
9505 };
9506
9507 static struct hda_verb alc262_tyan_verbs[] = {
9508         /* Headphone automute */
9509         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9510         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9511         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9512
9513         /* P11 AUX_IN, white 4-pin connector */
9514         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9515         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9516         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9517         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9518
9519         {}
9520 };
9521
9522 /* unsolicited event for HP jack sensing */
9523 static void alc262_tyan_automute(struct hda_codec *codec)
9524 {
9525         unsigned int mute;
9526         unsigned int present;
9527
9528         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9529         present = snd_hda_codec_read(codec, 0x1b, 0,
9530                                      AC_VERB_GET_PIN_SENSE, 0);
9531         present = (present & 0x80000000) != 0;
9532         if (present) {
9533                 /* mute line output on ATX panel */
9534                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9535                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9536         } else {
9537                 /* unmute line output if necessary */
9538                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9539                 snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9540                                          HDA_AMP_MUTE, mute);
9541         }
9542 }
9543
9544 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9545                                        unsigned int res)
9546 {
9547         if ((res >> 26) != ALC880_HP_EVENT)
9548                 return;
9549         alc262_tyan_automute(codec);
9550 }
9551
9552 #define alc262_capture_mixer            alc882_capture_mixer
9553 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9554
9555 /*
9556  * generic initialization of ADC, input mixers and output mixers
9557  */
9558 static struct hda_verb alc262_init_verbs[] = {
9559         /*
9560          * Unmute ADC0-2 and set the default input to mic-in
9561          */
9562         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9563         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9564         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9565         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9566         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9567         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9568
9569         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9570          * mixer widget
9571          * Note: PASD motherboards uses the Line In 2 as the input for
9572          * front panel mic (mic 2)
9573          */
9574         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9575         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9576         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9577         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9578         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9579         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9580
9581         /*
9582          * Set up output mixers (0x0c - 0x0e)
9583          */
9584         /* set vol=0 to output mixers */
9585         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9587         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9588         /* set up input amps for analog loopback */
9589         /* Amp Indices: DAC = 0, mixer = 1 */
9590         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9591         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9592         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9593         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9594         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9595         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9596
9597         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9598         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9599         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9600         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9601         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9602         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9603
9604         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9605         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9606         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9607         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9608         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9609
9610         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9611         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9612
9613         /* FIXME: use matrix-type input source selection */
9614         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9615         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9616         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9617         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9618         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9619         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9620         /* Input mixer2 */
9621         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9622         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9623         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9624         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9625         /* Input mixer3 */
9626         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9627         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9628         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9629         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9630
9631         { }
9632 };
9633
9634 static struct hda_verb alc262_eapd_verbs[] = {
9635         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9636         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9637         { }
9638 };
9639
9640 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9641         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9642         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9643         {}
9644 };
9645
9646 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9647         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9648         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9649         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9650
9651         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9652         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9653         {}
9654 };
9655
9656 static struct hda_verb alc262_sony_unsol_verbs[] = {
9657         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9658         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9659         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9660
9661         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9662         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9663         {}
9664 };
9665
9666 static struct hda_input_mux alc262_dmic_capture_source = {
9667         .num_items = 2,
9668         .items = {
9669                 { "Int DMic", 0x9 },
9670                 { "Mic", 0x0 },
9671         },
9672 };
9673
9674 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9675         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9676         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9677         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9678         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9679         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9680         { } /* end */
9681 };
9682
9683 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9684         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9685         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9686         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9687         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9688         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9689         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9690         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9691         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9692         {}
9693 };
9694
9695 static void alc262_dmic_automute(struct hda_codec *codec)
9696 {
9697         unsigned int present;
9698
9699         present = snd_hda_codec_read(codec, 0x18, 0,
9700                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9701         snd_hda_codec_write(codec, 0x22, 0,
9702                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9703 }
9704
9705 /* toggle speaker-output according to the hp-jack state */
9706 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9707 {
9708         unsigned int present;
9709         unsigned char bits;
9710
9711         present = snd_hda_codec_read(codec, 0x15, 0,
9712                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9713         bits = present ? 0 : PIN_OUT;
9714         snd_hda_codec_write(codec, 0x14, 0,
9715                                         AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9716 }
9717
9718
9719
9720 /* unsolicited event for HP jack sensing */
9721 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9722                                        unsigned int res)
9723 {
9724         if ((res >> 26) == ALC880_HP_EVENT)
9725                 alc262_toshiba_s06_speaker_automute(codec);
9726         if ((res >> 26) == ALC880_MIC_EVENT)
9727                 alc262_dmic_automute(codec);
9728
9729 }
9730
9731 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9732 {
9733         alc262_toshiba_s06_speaker_automute(codec);
9734         alc262_dmic_automute(codec);
9735 }
9736
9737 /* mute/unmute internal speaker according to the hp jack and mute state */
9738 static void alc262_hippo_automute(struct hda_codec *codec)
9739 {
9740         struct alc_spec *spec = codec->spec;
9741         unsigned int mute;
9742         unsigned int present;
9743
9744         /* need to execute and sync at first */
9745         snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9746         present = snd_hda_codec_read(codec, 0x15, 0,
9747                                      AC_VERB_GET_PIN_SENSE, 0);
9748         spec->jack_present = (present & 0x80000000) != 0;
9749         if (spec->jack_present) {
9750                 /* mute internal speaker */
9751                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9752                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9753         } else {
9754                 /* unmute internal speaker if necessary */
9755                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9756                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9757                                          HDA_AMP_MUTE, mute);
9758         }
9759 }
9760
9761 /* unsolicited event for HP jack sensing */
9762 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9763                                        unsigned int res)
9764 {
9765         if ((res >> 26) != ALC880_HP_EVENT)
9766                 return;
9767         alc262_hippo_automute(codec);
9768 }
9769
9770 static void alc262_hippo1_automute(struct hda_codec *codec)
9771 {
9772         unsigned int mute;
9773         unsigned int present;
9774
9775         snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9776         present = snd_hda_codec_read(codec, 0x1b, 0,
9777                                      AC_VERB_GET_PIN_SENSE, 0);
9778         present = (present & 0x80000000) != 0;
9779         if (present) {
9780                 /* mute internal speaker */
9781                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9782                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9783         } else {
9784                 /* unmute internal speaker if necessary */
9785                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9786                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9787                                          HDA_AMP_MUTE, mute);
9788         }
9789 }
9790
9791 /* unsolicited event for HP jack sensing */
9792 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
9793                                        unsigned int res)
9794 {
9795         if ((res >> 26) != ALC880_HP_EVENT)
9796                 return;
9797         alc262_hippo1_automute(codec);
9798 }
9799
9800 /*
9801  * nec model
9802  *  0x15 = headphone
9803  *  0x16 = internal speaker
9804  *  0x18 = external mic
9805  */
9806
9807 static struct snd_kcontrol_new alc262_nec_mixer[] = {
9808         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9809         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
9810
9811         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9813         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9814
9815         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9816         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9817         { } /* end */
9818 };
9819
9820 static struct hda_verb alc262_nec_verbs[] = {
9821         /* Unmute Speaker */
9822         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9823
9824         /* Headphone */
9825         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9826         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9827
9828         /* External mic to headphone */
9829         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9830         /* External mic to speaker */
9831         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9832         {}
9833 };
9834
9835 /*
9836  * fujitsu model
9837  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
9838  *  0x1b = port replicator headphone out
9839  */
9840
9841 #define ALC_HP_EVENT    0x37
9842
9843 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
9844         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9845         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9846         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9847         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9848         {}
9849 };
9850
9851 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
9852         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
9853         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9854         {}
9855 };
9856
9857 static struct hda_input_mux alc262_fujitsu_capture_source = {
9858         .num_items = 3,
9859         .items = {
9860                 { "Mic", 0x0 },
9861                 { "Int Mic", 0x1 },
9862                 { "CD", 0x4 },
9863         },
9864 };
9865
9866 static struct hda_input_mux alc262_HP_capture_source = {
9867         .num_items = 5,
9868         .items = {
9869                 { "Mic", 0x0 },
9870                 { "Front Mic", 0x1 },
9871                 { "Line", 0x2 },
9872                 { "CD", 0x4 },
9873                 { "AUX IN", 0x6 },
9874         },
9875 };
9876
9877 static struct hda_input_mux alc262_HP_D7000_capture_source = {
9878         .num_items = 4,
9879         .items = {
9880                 { "Mic", 0x0 },
9881                 { "Front Mic", 0x2 },
9882                 { "Line", 0x1 },
9883                 { "CD", 0x4 },
9884         },
9885 };
9886
9887 /* mute/unmute internal speaker according to the hp jacks and mute state */
9888 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
9889 {
9890         struct alc_spec *spec = codec->spec;
9891         unsigned int mute;
9892
9893         if (force || !spec->sense_updated) {
9894                 unsigned int present;
9895                 /* need to execute and sync at first */
9896                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
9897                 /* check laptop HP jack */
9898                 present = snd_hda_codec_read(codec, 0x14, 0,
9899                                              AC_VERB_GET_PIN_SENSE, 0);
9900                 /* need to execute and sync at first */
9901                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9902                 /* check docking HP jack */
9903                 present |= snd_hda_codec_read(codec, 0x1b, 0,
9904                                               AC_VERB_GET_PIN_SENSE, 0);
9905                 if (present & AC_PINSENSE_PRESENCE)
9906                         spec->jack_present = 1;
9907                 else
9908                         spec->jack_present = 0;
9909                 spec->sense_updated = 1;
9910         }
9911         /* unmute internal speaker only if both HPs are unplugged and
9912          * master switch is on
9913          */
9914         if (spec->jack_present)
9915                 mute = HDA_AMP_MUTE;
9916         else
9917                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
9918         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9919                                  HDA_AMP_MUTE, mute);
9920 }
9921
9922 /* unsolicited event for HP jack sensing */
9923 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
9924                                        unsigned int res)
9925 {
9926         if ((res >> 26) != ALC_HP_EVENT)
9927                 return;
9928         alc262_fujitsu_automute(codec, 1);
9929 }
9930
9931 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
9932 {
9933         alc262_fujitsu_automute(codec, 1);
9934 }
9935
9936 /* bind volumes of both NID 0x0c and 0x0d */
9937 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
9938         .ops = &snd_hda_bind_vol,
9939         .values = {
9940                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
9941                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
9942                 0
9943         },
9944 };
9945
9946 /* mute/unmute internal speaker according to the hp jack and mute state */
9947 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
9948 {
9949         struct alc_spec *spec = codec->spec;
9950         unsigned int mute;
9951
9952         if (force || !spec->sense_updated) {
9953                 unsigned int present_int_hp;
9954                 /* need to execute and sync at first */
9955                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9956                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
9957                                         AC_VERB_GET_PIN_SENSE, 0);
9958                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
9959                 spec->sense_updated = 1;
9960         }
9961         if (spec->jack_present) {
9962                 /* mute internal speaker */
9963                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9964                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9965                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9966                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
9967         } else {
9968                 /* unmute internal speaker if necessary */
9969                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9970                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9971                                          HDA_AMP_MUTE, mute);
9972                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9973                                          HDA_AMP_MUTE, mute);
9974         }
9975 }
9976
9977 /* unsolicited event for HP jack sensing */
9978 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
9979                                        unsigned int res)
9980 {
9981         if ((res >> 26) != ALC_HP_EVENT)
9982                 return;
9983         alc262_lenovo_3000_automute(codec, 1);
9984 }
9985
9986 /* bind hp and internal speaker mute (with plug check) */
9987 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
9988                                          struct snd_ctl_elem_value *ucontrol)
9989 {
9990         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9991         long *valp = ucontrol->value.integer.value;
9992         int change;
9993
9994         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9995                                                  HDA_AMP_MUTE,
9996                                                  valp ? 0 : HDA_AMP_MUTE);
9997         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
9998                                                  HDA_AMP_MUTE,
9999                                                  valp ? 0 : HDA_AMP_MUTE);
10000
10001         if (change)
10002                 alc262_fujitsu_automute(codec, 0);
10003         return change;
10004 }
10005
10006 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10007         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10008         {
10009                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10010                 .name = "Master Playback Switch",
10011                 .info = snd_hda_mixer_amp_switch_info,
10012                 .get = snd_hda_mixer_amp_switch_get,
10013                 .put = alc262_fujitsu_master_sw_put,
10014                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10015         },
10016         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10017         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10018         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10019         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10020         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10021         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10022         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10023         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10024         { } /* end */
10025 };
10026
10027 /* bind hp and internal speaker mute (with plug check) */
10028 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10029                                          struct snd_ctl_elem_value *ucontrol)
10030 {
10031         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10032         long *valp = ucontrol->value.integer.value;
10033         int change;
10034
10035         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10036                                                  HDA_AMP_MUTE,
10037                                                  valp ? 0 : HDA_AMP_MUTE);
10038
10039         if (change)
10040                 alc262_lenovo_3000_automute(codec, 0);
10041         return change;
10042 }
10043
10044 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10045         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10046         {
10047                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10048                 .name = "Master Playback Switch",
10049                 .info = snd_hda_mixer_amp_switch_info,
10050                 .get = snd_hda_mixer_amp_switch_get,
10051                 .put = alc262_lenovo_3000_master_sw_put,
10052                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10053         },
10054         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10055         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10056         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10057         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10058         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10059         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10060         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10061         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10062         { } /* end */
10063 };
10064
10065 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10066         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10067         {
10068                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10069                 .name = "Master Playback Switch",
10070                 .info = snd_hda_mixer_amp_switch_info,
10071                 .get = snd_hda_mixer_amp_switch_get,
10072                 .put = alc262_sony_master_sw_put,
10073                 .private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10074         },
10075         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10076         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10077         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10078         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10079         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10080         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10081         { } /* end */
10082 };
10083
10084 /* additional init verbs for Benq laptops */
10085 static struct hda_verb alc262_EAPD_verbs[] = {
10086         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10087         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10088         {}
10089 };
10090
10091 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10092         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10093         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10094
10095         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10096         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10097         {}
10098 };
10099
10100 /* Samsung Q1 Ultra Vista model setup */
10101 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10102         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10103         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10104         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10105         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10106         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10107         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10108         { } /* end */
10109 };
10110
10111 static struct hda_verb alc262_ultra_verbs[] = {
10112         /* output mixer */
10113         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10114         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10115         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10116         /* speaker */
10117         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10118         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10119         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10120         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10121         /* HP */
10122         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10123         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10124         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10125         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10126         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10127         /* internal mic */
10128         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10129         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10130         /* ADC, choose mic */
10131         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10132         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10133         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10134         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10135         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10136         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10137         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10138         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10139         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10140         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10141         {}
10142 };
10143
10144 /* mute/unmute internal speaker according to the hp jack and mute state */
10145 static void alc262_ultra_automute(struct hda_codec *codec)
10146 {
10147         struct alc_spec *spec = codec->spec;
10148         unsigned int mute;
10149
10150         mute = 0;
10151         /* auto-mute only when HP is used as HP */
10152         if (!spec->cur_mux[0]) {
10153                 unsigned int present;
10154                 /* need to execute and sync at first */
10155                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10156                 present = snd_hda_codec_read(codec, 0x15, 0,
10157                                              AC_VERB_GET_PIN_SENSE, 0);
10158                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10159                 if (spec->jack_present)
10160                         mute = HDA_AMP_MUTE;
10161         }
10162         /* mute/unmute internal speaker */
10163         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10164                                  HDA_AMP_MUTE, mute);
10165         /* mute/unmute HP */
10166         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10167                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10168 }
10169
10170 /* unsolicited event for HP jack sensing */
10171 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10172                                        unsigned int res)
10173 {
10174         if ((res >> 26) != ALC880_HP_EVENT)
10175                 return;
10176         alc262_ultra_automute(codec);
10177 }
10178
10179 static struct hda_input_mux alc262_ultra_capture_source = {
10180         .num_items = 2,
10181         .items = {
10182                 { "Mic", 0x1 },
10183                 { "Headphone", 0x7 },
10184         },
10185 };
10186
10187 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10188                                      struct snd_ctl_elem_value *ucontrol)
10189 {
10190         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10191         struct alc_spec *spec = codec->spec;
10192         int ret;
10193
10194         ret = alc_mux_enum_put(kcontrol, ucontrol);
10195         if (!ret)
10196                 return 0;
10197         /* reprogram the HP pin as mic or HP according to the input source */
10198         snd_hda_codec_write_cache(codec, 0x15, 0,
10199                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10200                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10201         alc262_ultra_automute(codec); /* mute/unmute HP */
10202         return ret;
10203 }
10204
10205 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10206         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10207         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10208         {
10209                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10210                 .name = "Capture Source",
10211                 .info = alc_mux_enum_info,
10212                 .get = alc_mux_enum_get,
10213                 .put = alc262_ultra_mux_enum_put,
10214         },
10215         { } /* end */
10216 };
10217
10218 /* add playback controls from the parsed DAC table */
10219 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10220                                              const struct auto_pin_cfg *cfg)
10221 {
10222         hda_nid_t nid;
10223         int err;
10224
10225         spec->multiout.num_dacs = 1;    /* only use one dac */
10226         spec->multiout.dac_nids = spec->private_dac_nids;
10227         spec->multiout.dac_nids[0] = 2;
10228
10229         nid = cfg->line_out_pins[0];
10230         if (nid) {
10231                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10232                                   "Front Playback Volume",
10233                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10234                 if (err < 0)
10235                         return err;
10236                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10237                                   "Front Playback Switch",
10238                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10239                 if (err < 0)
10240                         return err;
10241         }
10242
10243         nid = cfg->speaker_pins[0];
10244         if (nid) {
10245                 if (nid == 0x16) {
10246                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10247                                           "Speaker Playback Volume",
10248                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10249                                                               HDA_OUTPUT));
10250                         if (err < 0)
10251                                 return err;
10252                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10253                                           "Speaker Playback Switch",
10254                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10255                                                               HDA_OUTPUT));
10256                         if (err < 0)
10257                                 return err;
10258                 } else {
10259                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10260                                           "Speaker Playback Switch",
10261                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10262                                                               HDA_OUTPUT));
10263                         if (err < 0)
10264                                 return err;
10265                 }
10266         }
10267         nid = cfg->hp_pins[0];
10268         if (nid) {
10269                 /* spec->multiout.hp_nid = 2; */
10270                 if (nid == 0x16) {
10271                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10272                                           "Headphone Playback Volume",
10273                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10274                                                               HDA_OUTPUT));
10275                         if (err < 0)
10276                                 return err;
10277                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10278                                           "Headphone Playback Switch",
10279                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10280                                                               HDA_OUTPUT));
10281                         if (err < 0)
10282                                 return err;
10283                 } else {
10284                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10285                                           "Headphone Playback Switch",
10286                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10287                                                               HDA_OUTPUT));
10288                         if (err < 0)
10289                                 return err;
10290                 }
10291         }
10292         return 0;
10293 }
10294
10295 /* identical with ALC880 */
10296 #define alc262_auto_create_analog_input_ctls \
10297         alc880_auto_create_analog_input_ctls
10298
10299 /*
10300  * generic initialization of ADC, input mixers and output mixers
10301  */
10302 static struct hda_verb alc262_volume_init_verbs[] = {
10303         /*
10304          * Unmute ADC0-2 and set the default input to mic-in
10305          */
10306         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10307         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10308         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10309         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10310         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10311         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10312
10313         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10314          * mixer widget
10315          * Note: PASD motherboards uses the Line In 2 as the input for
10316          * front panel mic (mic 2)
10317          */
10318         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10319         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10320         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10321         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10322         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10323         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10324
10325         /*
10326          * Set up output mixers (0x0c - 0x0f)
10327          */
10328         /* set vol=0 to output mixers */
10329         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10330         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10331         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10332
10333         /* set up input amps for analog loopback */
10334         /* Amp Indices: DAC = 0, mixer = 1 */
10335         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10336         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10337         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10338         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10339         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10340         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10341
10342         /* FIXME: use matrix-type input source selection */
10343         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10344         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10345         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10346         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10347         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10348         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10349         /* Input mixer2 */
10350         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10351         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10352         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10353         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10354         /* Input mixer3 */
10355         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10356         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10357         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10358         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10359
10360         { }
10361 };
10362
10363 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10364         /*
10365          * Unmute ADC0-2 and set the default input to mic-in
10366          */
10367         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10368         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10369         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10370         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10371         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10372         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10373
10374         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10375          * mixer widget
10376          * Note: PASD motherboards uses the Line In 2 as the input for
10377          * front panel mic (mic 2)
10378          */
10379         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10380         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10381         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10382         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10383         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10384         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10385         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10386         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10387
10388         /*
10389          * Set up output mixers (0x0c - 0x0e)
10390          */
10391         /* set vol=0 to output mixers */
10392         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10393         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10394         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10395
10396         /* set up input amps for analog loopback */
10397         /* Amp Indices: DAC = 0, mixer = 1 */
10398         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10399         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10400         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10401         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10402         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10403         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10404
10405         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10406         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10407         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10408
10409         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10410         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10411
10412         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10413         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10414
10415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10416         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10417         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10418         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10419         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10420
10421         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10422         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10423         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10424         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10425         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10426         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10427
10428
10429         /* FIXME: use matrix-type input source selection */
10430         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10431         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10432         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10433         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10434         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10435         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10436         /* Input mixer2 */
10437         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10438         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10439         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10440         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10441         /* Input mixer3 */
10442         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10443         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10444         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10445         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10446
10447         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10448
10449         { }
10450 };
10451
10452 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10453         /*
10454          * Unmute ADC0-2 and set the default input to mic-in
10455          */
10456         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10457         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10458         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10459         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10460         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10461         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10462
10463         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10464          * mixer widget
10465          * Note: PASD motherboards uses the Line In 2 as the input for front
10466          * panel mic (mic 2)
10467          */
10468         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10469         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10470         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10471         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10472         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10473         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10474         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10475         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10476         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10477         /*
10478          * Set up output mixers (0x0c - 0x0e)
10479          */
10480         /* set vol=0 to output mixers */
10481         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10482         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10483         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10484
10485         /* set up input amps for analog loopback */
10486         /* Amp Indices: DAC = 0, mixer = 1 */
10487         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10488         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10489         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10490         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10491         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10492         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10493
10494
10495         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10496         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10497         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10498         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10499         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10500         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10501         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10502
10503         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10504         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10505
10506         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10507         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10508
10509         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10510         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10511         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10512         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10513         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10514         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10515
10516         /* FIXME: use matrix-type input source selection */
10517         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10518         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10519         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10520         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10521         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10522         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10523         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10524         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10525         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10526         /* Input mixer2 */
10527         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10528         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10529         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10530         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10531         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10532         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10533         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10534         /* Input mixer3 */
10535         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10536         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10537         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10538         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10539         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10540         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10541         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10542
10543         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10544
10545         { }
10546 };
10547
10548 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10549
10550         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10551         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10552         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10553
10554         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10555         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10556         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10557         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10558
10559         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10560         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10561         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10562         {}
10563 };
10564
10565
10566 #ifdef CONFIG_SND_HDA_POWER_SAVE
10567 #define alc262_loopbacks        alc880_loopbacks
10568 #endif
10569
10570 /* pcm configuration: identiacal with ALC880 */
10571 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10572 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10573 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10574 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10575
10576 /*
10577  * BIOS auto configuration
10578  */
10579 static int alc262_parse_auto_config(struct hda_codec *codec)
10580 {
10581         struct alc_spec *spec = codec->spec;
10582         int err;
10583         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10584
10585         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10586                                            alc262_ignore);
10587         if (err < 0)
10588                 return err;
10589         if (!spec->autocfg.line_outs) {
10590                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10591                         spec->multiout.max_channels = 2;
10592                         spec->no_analog = 1;
10593                         goto dig_only;
10594                 }
10595                 return 0; /* can't find valid BIOS pin config */
10596         }
10597         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10598         if (err < 0)
10599                 return err;
10600         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10601         if (err < 0)
10602                 return err;
10603
10604         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10605
10606  dig_only:
10607         if (spec->autocfg.dig_outs) {
10608                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10609                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10610         }
10611         if (spec->autocfg.dig_in_pin)
10612                 spec->dig_in_nid = ALC262_DIGIN_NID;
10613
10614         if (spec->kctls.list)
10615                 add_mixer(spec, spec->kctls.list);
10616
10617         add_verb(spec, alc262_volume_init_verbs);
10618         spec->num_mux_defs = 1;
10619         spec->input_mux = &spec->private_imux[0];
10620
10621         err = alc_auto_add_mic_boost(codec);
10622         if (err < 0)
10623                 return err;
10624
10625         return 1;
10626 }
10627
10628 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10629 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10630 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10631 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10632
10633
10634 /* init callback for auto-configuration model -- overriding the default init */
10635 static void alc262_auto_init(struct hda_codec *codec)
10636 {
10637         struct alc_spec *spec = codec->spec;
10638         alc262_auto_init_multi_out(codec);
10639         alc262_auto_init_hp_out(codec);
10640         alc262_auto_init_analog_input(codec);
10641         alc262_auto_init_input_src(codec);
10642         if (spec->unsol_event)
10643                 alc_inithook(codec);
10644 }
10645
10646 /*
10647  * configuration and preset
10648  */
10649 static const char *alc262_models[ALC262_MODEL_LAST] = {
10650         [ALC262_BASIC]          = "basic",
10651         [ALC262_HIPPO]          = "hippo",
10652         [ALC262_HIPPO_1]        = "hippo_1",
10653         [ALC262_FUJITSU]        = "fujitsu",
10654         [ALC262_HP_BPC]         = "hp-bpc",
10655         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10656         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10657         [ALC262_HP_RP5700]      = "hp-rp5700",
10658         [ALC262_BENQ_ED8]       = "benq",
10659         [ALC262_BENQ_T31]       = "benq-t31",
10660         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10661         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10662         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10663         [ALC262_ULTRA]          = "ultra",
10664         [ALC262_LENOVO_3000]    = "lenovo-3000",
10665         [ALC262_NEC]            = "nec",
10666         [ALC262_TYAN]           = "tyan",
10667         [ALC262_AUTO]           = "auto",
10668 };
10669
10670 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10671         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10672         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10673         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10674                            ALC262_HP_BPC),
10675         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10676                            ALC262_HP_BPC),
10677         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10678         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10679         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10680         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10681         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10682         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10683         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10684         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10685         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10686         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10687         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10688         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10689                       ALC262_HP_TC_T5735),
10690         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10691         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10692         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10693         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10694         SND_PCI_QUIRK(0x104d, 0x900e, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10695         SND_PCI_QUIRK(0x104d, 0x9015, "Sony 0x9015", ALC262_SONY_ASSAMD),
10696         SND_PCI_QUIRK(0x104d, 0x9033, "Sony VAIO VGN-SR19XN",
10697                       ALC262_SONY_ASSAMD),
10698         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10699                       ALC262_TOSHIBA_RX1),
10700         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10701         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10702         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10703         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10704         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10705                            ALC262_ULTRA),
10706         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10707         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10708         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10709         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10710         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10711         {}
10712 };
10713
10714 static struct alc_config_preset alc262_presets[] = {
10715         [ALC262_BASIC] = {
10716                 .mixers = { alc262_base_mixer },
10717                 .init_verbs = { alc262_init_verbs },
10718                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10719                 .dac_nids = alc262_dac_nids,
10720                 .hp_nid = 0x03,
10721                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10722                 .channel_mode = alc262_modes,
10723                 .input_mux = &alc262_capture_source,
10724         },
10725         [ALC262_HIPPO] = {
10726                 .mixers = { alc262_base_mixer },
10727                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10728                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10729                 .dac_nids = alc262_dac_nids,
10730                 .hp_nid = 0x03,
10731                 .dig_out_nid = ALC262_DIGOUT_NID,
10732                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10733                 .channel_mode = alc262_modes,
10734                 .input_mux = &alc262_capture_source,
10735                 .unsol_event = alc262_hippo_unsol_event,
10736                 .init_hook = alc262_hippo_automute,
10737         },
10738         [ALC262_HIPPO_1] = {
10739                 .mixers = { alc262_hippo1_mixer },
10740                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10741                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10742                 .dac_nids = alc262_dac_nids,
10743                 .hp_nid = 0x02,
10744                 .dig_out_nid = ALC262_DIGOUT_NID,
10745                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10746                 .channel_mode = alc262_modes,
10747                 .input_mux = &alc262_capture_source,
10748                 .unsol_event = alc262_hippo1_unsol_event,
10749                 .init_hook = alc262_hippo1_automute,
10750         },
10751         [ALC262_FUJITSU] = {
10752                 .mixers = { alc262_fujitsu_mixer },
10753                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10754                                 alc262_fujitsu_unsol_verbs },
10755                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10756                 .dac_nids = alc262_dac_nids,
10757                 .hp_nid = 0x03,
10758                 .dig_out_nid = ALC262_DIGOUT_NID,
10759                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10760                 .channel_mode = alc262_modes,
10761                 .input_mux = &alc262_fujitsu_capture_source,
10762                 .unsol_event = alc262_fujitsu_unsol_event,
10763                 .init_hook = alc262_fujitsu_init_hook,
10764         },
10765         [ALC262_HP_BPC] = {
10766                 .mixers = { alc262_HP_BPC_mixer },
10767                 .init_verbs = { alc262_HP_BPC_init_verbs },
10768                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10769                 .dac_nids = alc262_dac_nids,
10770                 .hp_nid = 0x03,
10771                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10772                 .channel_mode = alc262_modes,
10773                 .input_mux = &alc262_HP_capture_source,
10774                 .unsol_event = alc262_hp_bpc_unsol_event,
10775                 .init_hook = alc262_hp_bpc_automute,
10776         },
10777         [ALC262_HP_BPC_D7000_WF] = {
10778                 .mixers = { alc262_HP_BPC_WildWest_mixer },
10779                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10780                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10781                 .dac_nids = alc262_dac_nids,
10782                 .hp_nid = 0x03,
10783                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10784                 .channel_mode = alc262_modes,
10785                 .input_mux = &alc262_HP_D7000_capture_source,
10786                 .unsol_event = alc262_hp_wildwest_unsol_event,
10787                 .init_hook = alc262_hp_wildwest_automute,
10788         },
10789         [ALC262_HP_BPC_D7000_WL] = {
10790                 .mixers = { alc262_HP_BPC_WildWest_mixer,
10791                             alc262_HP_BPC_WildWest_option_mixer },
10792                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10793                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10794                 .dac_nids = alc262_dac_nids,
10795                 .hp_nid = 0x03,
10796                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10797                 .channel_mode = alc262_modes,
10798                 .input_mux = &alc262_HP_D7000_capture_source,
10799                 .unsol_event = alc262_hp_wildwest_unsol_event,
10800                 .init_hook = alc262_hp_wildwest_automute,
10801         },
10802         [ALC262_HP_TC_T5735] = {
10803                 .mixers = { alc262_hp_t5735_mixer },
10804                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
10805                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10806                 .dac_nids = alc262_dac_nids,
10807                 .hp_nid = 0x03,
10808                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10809                 .channel_mode = alc262_modes,
10810                 .input_mux = &alc262_capture_source,
10811                 .unsol_event = alc262_hp_t5735_unsol_event,
10812                 .init_hook = alc262_hp_t5735_init_hook,
10813         },
10814         [ALC262_HP_RP5700] = {
10815                 .mixers = { alc262_hp_rp5700_mixer },
10816                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
10817                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10818                 .dac_nids = alc262_dac_nids,
10819                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10820                 .channel_mode = alc262_modes,
10821                 .input_mux = &alc262_hp_rp5700_capture_source,
10822         },
10823         [ALC262_BENQ_ED8] = {
10824                 .mixers = { alc262_base_mixer },
10825                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
10826                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10827                 .dac_nids = alc262_dac_nids,
10828                 .hp_nid = 0x03,
10829                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10830                 .channel_mode = alc262_modes,
10831                 .input_mux = &alc262_capture_source,
10832         },
10833         [ALC262_SONY_ASSAMD] = {
10834                 .mixers = { alc262_sony_mixer },
10835                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
10836                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10837                 .dac_nids = alc262_dac_nids,
10838                 .hp_nid = 0x02,
10839                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10840                 .channel_mode = alc262_modes,
10841                 .input_mux = &alc262_capture_source,
10842                 .unsol_event = alc262_hippo_unsol_event,
10843                 .init_hook = alc262_hippo_automute,
10844         },
10845         [ALC262_BENQ_T31] = {
10846                 .mixers = { alc262_benq_t31_mixer },
10847                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
10848                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10849                 .dac_nids = alc262_dac_nids,
10850                 .hp_nid = 0x03,
10851                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10852                 .channel_mode = alc262_modes,
10853                 .input_mux = &alc262_capture_source,
10854                 .unsol_event = alc262_hippo_unsol_event,
10855                 .init_hook = alc262_hippo_automute,
10856         },
10857         [ALC262_ULTRA] = {
10858                 .mixers = { alc262_ultra_mixer },
10859                 .cap_mixer = alc262_ultra_capture_mixer,
10860                 .init_verbs = { alc262_ultra_verbs },
10861                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10862                 .dac_nids = alc262_dac_nids,
10863                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10864                 .channel_mode = alc262_modes,
10865                 .input_mux = &alc262_ultra_capture_source,
10866                 .adc_nids = alc262_adc_nids, /* ADC0 */
10867                 .capsrc_nids = alc262_capsrc_nids,
10868                 .num_adc_nids = 1, /* single ADC */
10869                 .unsol_event = alc262_ultra_unsol_event,
10870                 .init_hook = alc262_ultra_automute,
10871         },
10872         [ALC262_LENOVO_3000] = {
10873                 .mixers = { alc262_lenovo_3000_mixer },
10874                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10875                                 alc262_lenovo_3000_unsol_verbs },
10876                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10877                 .dac_nids = alc262_dac_nids,
10878                 .hp_nid = 0x03,
10879                 .dig_out_nid = ALC262_DIGOUT_NID,
10880                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10881                 .channel_mode = alc262_modes,
10882                 .input_mux = &alc262_fujitsu_capture_source,
10883                 .unsol_event = alc262_lenovo_3000_unsol_event,
10884         },
10885         [ALC262_NEC] = {
10886                 .mixers = { alc262_nec_mixer },
10887                 .init_verbs = { alc262_nec_verbs },
10888                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10889                 .dac_nids = alc262_dac_nids,
10890                 .hp_nid = 0x03,
10891                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10892                 .channel_mode = alc262_modes,
10893                 .input_mux = &alc262_capture_source,
10894         },
10895         [ALC262_TOSHIBA_S06] = {
10896                 .mixers = { alc262_toshiba_s06_mixer },
10897                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
10898                                                         alc262_eapd_verbs },
10899                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10900                 .capsrc_nids = alc262_dmic_capsrc_nids,
10901                 .dac_nids = alc262_dac_nids,
10902                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
10903                 .dig_out_nid = ALC262_DIGOUT_NID,
10904                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10905                 .channel_mode = alc262_modes,
10906                 .input_mux = &alc262_dmic_capture_source,
10907                 .unsol_event = alc262_toshiba_s06_unsol_event,
10908                 .init_hook = alc262_toshiba_s06_init_hook,
10909         },
10910         [ALC262_TOSHIBA_RX1] = {
10911                 .mixers = { alc262_toshiba_rx1_mixer },
10912                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
10913                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10914                 .dac_nids = alc262_dac_nids,
10915                 .hp_nid = 0x03,
10916                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10917                 .channel_mode = alc262_modes,
10918                 .input_mux = &alc262_capture_source,
10919                 .unsol_event = alc262_hippo_unsol_event,
10920                 .init_hook = alc262_hippo_automute,
10921         },
10922         [ALC262_TYAN] = {
10923                 .mixers = { alc262_tyan_mixer },
10924                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
10925                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10926                 .dac_nids = alc262_dac_nids,
10927                 .hp_nid = 0x02,
10928                 .dig_out_nid = ALC262_DIGOUT_NID,
10929                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10930                 .channel_mode = alc262_modes,
10931                 .input_mux = &alc262_capture_source,
10932                 .unsol_event = alc262_tyan_unsol_event,
10933                 .init_hook = alc262_tyan_automute,
10934         },
10935 };
10936
10937 static int patch_alc262(struct hda_codec *codec)
10938 {
10939         struct alc_spec *spec;
10940         int board_config;
10941         int err;
10942
10943         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10944         if (spec == NULL)
10945                 return -ENOMEM;
10946
10947         codec->spec = spec;
10948 #if 0
10949         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
10950          * under-run
10951          */
10952         {
10953         int tmp;
10954         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10955         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
10956         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
10957         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
10958         }
10959 #endif
10960
10961         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10962
10963         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
10964                                                   alc262_models,
10965                                                   alc262_cfg_tbl);
10966
10967         if (board_config < 0) {
10968                 printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
10969                        "trying auto-probe from BIOS...\n");
10970                 board_config = ALC262_AUTO;
10971         }
10972
10973         if (board_config == ALC262_AUTO) {
10974                 /* automatic parse from the BIOS config */
10975                 err = alc262_parse_auto_config(codec);
10976                 if (err < 0) {
10977                         alc_free(codec);
10978                         return err;
10979                 } else if (!err) {
10980                         printk(KERN_INFO
10981                                "hda_codec: Cannot set up configuration "
10982                                "from BIOS.  Using base mode...\n");
10983                         board_config = ALC262_BASIC;
10984                 }
10985         }
10986
10987         if (!spec->no_analog) {
10988                 err = snd_hda_attach_beep_device(codec, 0x1);
10989                 if (err < 0) {
10990                         alc_free(codec);
10991                         return err;
10992                 }
10993         }
10994
10995         if (board_config != ALC262_AUTO)
10996                 setup_preset(spec, &alc262_presets[board_config]);
10997
10998         spec->stream_name_analog = "ALC262 Analog";
10999         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11000         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11001
11002         spec->stream_name_digital = "ALC262 Digital";
11003         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11004         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11005
11006         spec->capture_style = CAPT_MIX;
11007         if (!spec->adc_nids && spec->input_mux) {
11008                 /* check whether NID 0x07 is valid */
11009                 unsigned int wcap = get_wcaps(codec, 0x07);
11010
11011                 /* get type */
11012                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11013                 if (wcap != AC_WID_AUD_IN) {
11014                         spec->adc_nids = alc262_adc_nids_alt;
11015                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11016                         spec->capsrc_nids = alc262_capsrc_nids_alt;
11017                 } else {
11018                         spec->adc_nids = alc262_adc_nids;
11019                         spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11020                         spec->capsrc_nids = alc262_capsrc_nids;
11021                 }
11022         }
11023         if (!spec->cap_mixer && !spec->no_analog)
11024                 set_capture_mixer(spec);
11025         if (!spec->no_analog)
11026                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11027
11028         spec->vmaster_nid = 0x0c;
11029
11030         codec->patch_ops = alc_patch_ops;
11031         if (board_config == ALC262_AUTO)
11032                 spec->init_hook = alc262_auto_init;
11033 #ifdef CONFIG_SND_HDA_POWER_SAVE
11034         if (!spec->loopback.amplist)
11035                 spec->loopback.amplist = alc262_loopbacks;
11036 #endif
11037         codec->proc_widget_hook = print_realtek_coef;
11038
11039         return 0;
11040 }
11041
11042 /*
11043  *  ALC268 channel source setting (2 channel)
11044  */
11045 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11046 #define alc268_modes            alc260_modes
11047
11048 static hda_nid_t alc268_dac_nids[2] = {
11049         /* front, hp */
11050         0x02, 0x03
11051 };
11052
11053 static hda_nid_t alc268_adc_nids[2] = {
11054         /* ADC0-1 */
11055         0x08, 0x07
11056 };
11057
11058 static hda_nid_t alc268_adc_nids_alt[1] = {
11059         /* ADC0 */
11060         0x08
11061 };
11062
11063 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11064
11065 static struct snd_kcontrol_new alc268_base_mixer[] = {
11066         /* output mixer control */
11067         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11068         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11069         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11070         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11071         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11072         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11073         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11074         { }
11075 };
11076
11077 /* bind Beep switches of both NID 0x0f and 0x10 */
11078 static struct hda_bind_ctls alc268_bind_beep_sw = {
11079         .ops = &snd_hda_bind_sw,
11080         .values = {
11081                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11082                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11083                 0
11084         },
11085 };
11086
11087 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11088         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11089         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11090         { }
11091 };
11092
11093 static struct hda_verb alc268_eapd_verbs[] = {
11094         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11095         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11096         { }
11097 };
11098
11099 /* Toshiba specific */
11100 #define alc268_toshiba_automute alc262_hippo_automute
11101
11102 static struct hda_verb alc268_toshiba_verbs[] = {
11103         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11104         { } /* end */
11105 };
11106
11107 static struct hda_input_mux alc268_acer_lc_capture_source = {
11108         .num_items = 2,
11109         .items = {
11110                 { "i-Mic", 0x6 },
11111                 { "E-Mic", 0x0 },
11112         },
11113 };
11114
11115 /* Acer specific */
11116 /* bind volumes of both NID 0x02 and 0x03 */
11117 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11118         .ops = &snd_hda_bind_vol,
11119         .values = {
11120                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11121                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11122                 0
11123         },
11124 };
11125
11126 /* mute/unmute internal speaker according to the hp jack and mute state */
11127 static void alc268_acer_automute(struct hda_codec *codec, int force)
11128 {
11129         struct alc_spec *spec = codec->spec;
11130         unsigned int mute;
11131
11132         if (force || !spec->sense_updated) {
11133                 unsigned int present;
11134                 present = snd_hda_codec_read(codec, 0x14, 0,
11135                                          AC_VERB_GET_PIN_SENSE, 0);
11136                 spec->jack_present = (present & 0x80000000) != 0;
11137                 spec->sense_updated = 1;
11138         }
11139         if (spec->jack_present)
11140                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11141         else /* unmute internal speaker if necessary */
11142                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11143         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11144                                  HDA_AMP_MUTE, mute);
11145 }
11146
11147
11148 /* bind hp and internal speaker mute (with plug check) */
11149 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11150                                      struct snd_ctl_elem_value *ucontrol)
11151 {
11152         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11153         long *valp = ucontrol->value.integer.value;
11154         int change;
11155
11156         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11157                                           HDA_AMP_MUTE,
11158                                           valp[0] ? 0 : HDA_AMP_MUTE);
11159         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11160                                            HDA_AMP_MUTE,
11161                                            valp[1] ? 0 : HDA_AMP_MUTE);
11162         if (change)
11163                 alc268_acer_automute(codec, 0);
11164         return change;
11165 }
11166
11167 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11168         /* output mixer control */
11169         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11170         {
11171                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11172                 .name = "Master Playback Switch",
11173                 .info = snd_hda_mixer_amp_switch_info,
11174                 .get = snd_hda_mixer_amp_switch_get,
11175                 .put = alc268_acer_master_sw_put,
11176                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11177         },
11178         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11179         { }
11180 };
11181
11182 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11183         /* output mixer control */
11184         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11185         {
11186                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11187                 .name = "Master Playback Switch",
11188                 .info = snd_hda_mixer_amp_switch_info,
11189                 .get = snd_hda_mixer_amp_switch_get,
11190                 .put = alc268_acer_master_sw_put,
11191                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11192         },
11193         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11194         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11195         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11196         { }
11197 };
11198
11199 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11200         /* output mixer control */
11201         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11202         {
11203                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11204                 .name = "Master Playback Switch",
11205                 .info = snd_hda_mixer_amp_switch_info,
11206                 .get = snd_hda_mixer_amp_switch_get,
11207                 .put = alc268_acer_master_sw_put,
11208                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11209         },
11210         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11211         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11212         { }
11213 };
11214
11215 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11216         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11217         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11218         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11219         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11220         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11221         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11222         { }
11223 };
11224
11225 static struct hda_verb alc268_acer_verbs[] = {
11226         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11227         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11228         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11229         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11230         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11231         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11232         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11233         { }
11234 };
11235
11236 /* unsolicited event for HP jack sensing */
11237 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11238                                        unsigned int res)
11239 {
11240         if ((res >> 26) != ALC880_HP_EVENT)
11241                 return;
11242         alc268_toshiba_automute(codec);
11243 }
11244
11245 static void alc268_acer_unsol_event(struct hda_codec *codec,
11246                                        unsigned int res)
11247 {
11248         if ((res >> 26) != ALC880_HP_EVENT)
11249                 return;
11250         alc268_acer_automute(codec, 1);
11251 }
11252
11253 static void alc268_acer_init_hook(struct hda_codec *codec)
11254 {
11255         alc268_acer_automute(codec, 1);
11256 }
11257
11258 /* toggle speaker-output according to the hp-jack state */
11259 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11260 {
11261         unsigned int present;
11262         unsigned char bits;
11263
11264         present = snd_hda_codec_read(codec, 0x15, 0,
11265                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11266         bits = present ? AMP_IN_MUTE(0) : 0;
11267         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11268                                 AMP_IN_MUTE(0), bits);
11269         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11270                                 AMP_IN_MUTE(0), bits);
11271 }
11272
11273
11274 static void alc268_acer_mic_automute(struct hda_codec *codec)
11275 {
11276         unsigned int present;
11277
11278         present = snd_hda_codec_read(codec, 0x18, 0,
11279                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11280         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11281                             present ? 0x0 : 0x6);
11282 }
11283
11284 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11285                                     unsigned int res)
11286 {
11287         if ((res >> 26) == ALC880_HP_EVENT)
11288                 alc268_aspire_one_speaker_automute(codec);
11289         if ((res >> 26) == ALC880_MIC_EVENT)
11290                 alc268_acer_mic_automute(codec);
11291 }
11292
11293 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11294 {
11295         alc268_aspire_one_speaker_automute(codec);
11296         alc268_acer_mic_automute(codec);
11297 }
11298
11299 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11300         /* output mixer control */
11301         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11302         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11303         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11304         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11305         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11306         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11307         { }
11308 };
11309
11310 static struct hda_verb alc268_dell_verbs[] = {
11311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11313         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11314         { }
11315 };
11316
11317 /* mute/unmute internal speaker according to the hp jack and mute state */
11318 static void alc268_dell_automute(struct hda_codec *codec)
11319 {
11320         unsigned int present;
11321         unsigned int mute;
11322
11323         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11324         if (present & 0x80000000)
11325                 mute = HDA_AMP_MUTE;
11326         else
11327                 mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11328         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11329                                  HDA_AMP_MUTE, mute);
11330 }
11331
11332 static void alc268_dell_unsol_event(struct hda_codec *codec,
11333                                     unsigned int res)
11334 {
11335         if ((res >> 26) != ALC880_HP_EVENT)
11336                 return;
11337         alc268_dell_automute(codec);
11338 }
11339
11340 #define alc268_dell_init_hook   alc268_dell_automute
11341
11342 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11343         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11344         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11345         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11346         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11347         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11348         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11349         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11350         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11351         { }
11352 };
11353
11354 static struct hda_verb alc267_quanta_il1_verbs[] = {
11355         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11356         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11357         { }
11358 };
11359
11360 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11361 {
11362         unsigned int present;
11363
11364         present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11365                 & AC_PINSENSE_PRESENCE;
11366         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11367                             present ? 0 : PIN_OUT);
11368 }
11369
11370 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11371 {
11372         unsigned int present;
11373
11374         present = snd_hda_codec_read(codec, 0x18, 0,
11375                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11376         snd_hda_codec_write(codec, 0x23, 0,
11377                             AC_VERB_SET_CONNECT_SEL,
11378                             present ? 0x00 : 0x01);
11379 }
11380
11381 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11382 {
11383         alc267_quanta_il1_hp_automute(codec);
11384         alc267_quanta_il1_mic_automute(codec);
11385 }
11386
11387 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11388                                            unsigned int res)
11389 {
11390         switch (res >> 26) {
11391         case ALC880_HP_EVENT:
11392                 alc267_quanta_il1_hp_automute(codec);
11393                 break;
11394         case ALC880_MIC_EVENT:
11395                 alc267_quanta_il1_mic_automute(codec);
11396                 break;
11397         }
11398 }
11399
11400 /*
11401  * generic initialization of ADC, input mixers and output mixers
11402  */
11403 static struct hda_verb alc268_base_init_verbs[] = {
11404         /* Unmute DAC0-1 and set vol = 0 */
11405         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11406         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11407
11408         /*
11409          * Set up output mixers (0x0c - 0x0e)
11410          */
11411         /* set vol=0 to output mixers */
11412         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11413         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11414
11415         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11416         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11417
11418         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11419         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11420         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11421         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11422         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11423         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11424         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11425         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11426
11427         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11428         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11429         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11430         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11431         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11432
11433         /* set PCBEEP vol = 0, mute connections */
11434         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11435         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11436         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11437
11438         /* Unmute Selector 23h,24h and set the default input to mic-in */
11439
11440         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11441         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11442         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11443         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11444
11445         { }
11446 };
11447
11448 /*
11449  * generic initialization of ADC, input mixers and output mixers
11450  */
11451 static struct hda_verb alc268_volume_init_verbs[] = {
11452         /* set output DAC */
11453         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11454         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11455
11456         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11457         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11458         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11459         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11460         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11461
11462         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11463         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11464         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11465
11466         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11467         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11468
11469         /* set PCBEEP vol = 0, mute connections */
11470         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11471         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11472         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11473
11474         { }
11475 };
11476
11477 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11478         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11479         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11480         {
11481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11482                 /* The multiple "Capture Source" controls confuse alsamixer
11483                  * So call somewhat different..
11484                  */
11485                 /* .name = "Capture Source", */
11486                 .name = "Input Source",
11487                 .count = 1,
11488                 .info = alc_mux_enum_info,
11489                 .get = alc_mux_enum_get,
11490                 .put = alc_mux_enum_put,
11491         },
11492         { } /* end */
11493 };
11494
11495 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11496         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11497         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11498         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11499         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11500         {
11501                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11502                 /* The multiple "Capture Source" controls confuse alsamixer
11503                  * So call somewhat different..
11504                  */
11505                 /* .name = "Capture Source", */
11506                 .name = "Input Source",
11507                 .count = 2,
11508                 .info = alc_mux_enum_info,
11509                 .get = alc_mux_enum_get,
11510                 .put = alc_mux_enum_put,
11511         },
11512         { } /* end */
11513 };
11514
11515 static struct hda_input_mux alc268_capture_source = {
11516         .num_items = 4,
11517         .items = {
11518                 { "Mic", 0x0 },
11519                 { "Front Mic", 0x1 },
11520                 { "Line", 0x2 },
11521                 { "CD", 0x3 },
11522         },
11523 };
11524
11525 static struct hda_input_mux alc268_acer_capture_source = {
11526         .num_items = 3,
11527         .items = {
11528                 { "Mic", 0x0 },
11529                 { "Internal Mic", 0x1 },
11530                 { "Line", 0x2 },
11531         },
11532 };
11533
11534 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11535         .num_items = 3,
11536         .items = {
11537                 { "Mic", 0x0 },
11538                 { "Internal Mic", 0x6 },
11539                 { "Line", 0x2 },
11540         },
11541 };
11542
11543 #ifdef CONFIG_SND_DEBUG
11544 static struct snd_kcontrol_new alc268_test_mixer[] = {
11545         /* Volume widgets */
11546         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11547         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11548         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11549         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11550         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11551         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11552         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11553         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11554         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11555         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11556         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11557         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11558         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11559         /* The below appears problematic on some hardwares */
11560         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11561         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11562         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11563         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11564         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11565
11566         /* Modes for retasking pin widgets */
11567         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11568         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11569         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11570         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11571
11572         /* Controls for GPIO pins, assuming they are configured as outputs */
11573         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11574         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11575         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11576         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11577
11578         /* Switches to allow the digital SPDIF output pin to be enabled.
11579          * The ALC268 does not have an SPDIF input.
11580          */
11581         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11582
11583         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11584          * this output to turn on an external amplifier.
11585          */
11586         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11587         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11588
11589         { } /* end */
11590 };
11591 #endif
11592
11593 /* create input playback/capture controls for the given pin */
11594 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11595                                     const char *ctlname, int idx)
11596 {
11597         char name[32];
11598         int err;
11599
11600         sprintf(name, "%s Playback Volume", ctlname);
11601         if (nid == 0x14) {
11602                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11603                                   HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11604                                                       HDA_OUTPUT));
11605                 if (err < 0)
11606                         return err;
11607         } else if (nid == 0x15) {
11608                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11609                                   HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11610                                                       HDA_OUTPUT));
11611                 if (err < 0)
11612                         return err;
11613         } else
11614                 return -1;
11615         sprintf(name, "%s Playback Switch", ctlname);
11616         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11617                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11618         if (err < 0)
11619                 return err;
11620         return 0;
11621 }
11622
11623 /* add playback controls from the parsed DAC table */
11624 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11625                                              const struct auto_pin_cfg *cfg)
11626 {
11627         hda_nid_t nid;
11628         int err;
11629
11630         spec->multiout.num_dacs = 2;    /* only use one dac */
11631         spec->multiout.dac_nids = spec->private_dac_nids;
11632         spec->multiout.dac_nids[0] = 2;
11633         spec->multiout.dac_nids[1] = 3;
11634
11635         nid = cfg->line_out_pins[0];
11636         if (nid)
11637                 alc268_new_analog_output(spec, nid, "Front", 0);
11638
11639         nid = cfg->speaker_pins[0];
11640         if (nid == 0x1d) {
11641                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11642                                   "Speaker Playback Volume",
11643                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11644                 if (err < 0)
11645                         return err;
11646         }
11647         nid = cfg->hp_pins[0];
11648         if (nid)
11649                 alc268_new_analog_output(spec, nid, "Headphone", 0);
11650
11651         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11652         if (nid == 0x16) {
11653                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11654                                   "Mono Playback Switch",
11655                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11656                 if (err < 0)
11657                         return err;
11658         }
11659         return 0;
11660 }
11661
11662 /* create playback/capture controls for input pins */
11663 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11664                                                 const struct auto_pin_cfg *cfg)
11665 {
11666         struct hda_input_mux *imux = &spec->private_imux[0];
11667         int i, idx1;
11668
11669         for (i = 0; i < AUTO_PIN_LAST; i++) {
11670                 switch(cfg->input_pins[i]) {
11671                 case 0x18:
11672                         idx1 = 0;       /* Mic 1 */
11673                         break;
11674                 case 0x19:
11675                         idx1 = 1;       /* Mic 2 */
11676                         break;
11677                 case 0x1a:
11678                         idx1 = 2;       /* Line In */
11679                         break;
11680                 case 0x1c:
11681                         idx1 = 3;       /* CD */
11682                         break;
11683                 case 0x12:
11684                 case 0x13:
11685                         idx1 = 6;       /* digital mics */
11686                         break;
11687                 default:
11688                         continue;
11689                 }
11690                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11691                 imux->items[imux->num_items].index = idx1;
11692                 imux->num_items++;
11693         }
11694         return 0;
11695 }
11696
11697 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11698 {
11699         struct alc_spec *spec = codec->spec;
11700         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11701         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11702         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11703         unsigned int    dac_vol1, dac_vol2;
11704
11705         if (speaker_nid) {
11706                 snd_hda_codec_write(codec, speaker_nid, 0,
11707                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11708                 snd_hda_codec_write(codec, 0x0f, 0,
11709                                     AC_VERB_SET_AMP_GAIN_MUTE,
11710                                     AMP_IN_UNMUTE(1));
11711                 snd_hda_codec_write(codec, 0x10, 0,
11712                                     AC_VERB_SET_AMP_GAIN_MUTE,
11713                                     AMP_IN_UNMUTE(1));
11714         } else {
11715                 snd_hda_codec_write(codec, 0x0f, 0,
11716                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11717                 snd_hda_codec_write(codec, 0x10, 0,
11718                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11719         }
11720
11721         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11722         if (line_nid == 0x14)
11723                 dac_vol2 = AMP_OUT_ZERO;
11724         else if (line_nid == 0x15)
11725                 dac_vol1 = AMP_OUT_ZERO;
11726         if (hp_nid == 0x14)
11727                 dac_vol2 = AMP_OUT_ZERO;
11728         else if (hp_nid == 0x15)
11729                 dac_vol1 = AMP_OUT_ZERO;
11730         if (line_nid != 0x16 || hp_nid != 0x16 ||
11731             spec->autocfg.line_out_pins[1] != 0x16 ||
11732             spec->autocfg.line_out_pins[2] != 0x16)
11733                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11734
11735         snd_hda_codec_write(codec, 0x02, 0,
11736                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11737         snd_hda_codec_write(codec, 0x03, 0,
11738                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11739 }
11740
11741 /* pcm configuration: identiacal with ALC880 */
11742 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11743 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11744 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11745 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11746
11747 /*
11748  * BIOS auto configuration
11749  */
11750 static int alc268_parse_auto_config(struct hda_codec *codec)
11751 {
11752         struct alc_spec *spec = codec->spec;
11753         int err;
11754         static hda_nid_t alc268_ignore[] = { 0 };
11755
11756         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11757                                            alc268_ignore);
11758         if (err < 0)
11759                 return err;
11760         if (!spec->autocfg.line_outs) {
11761                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11762                         spec->multiout.max_channels = 2;
11763                         spec->no_analog = 1;
11764                         goto dig_only;
11765                 }
11766                 return 0; /* can't find valid BIOS pin config */
11767         }
11768         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11769         if (err < 0)
11770                 return err;
11771         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11772         if (err < 0)
11773                 return err;
11774
11775         spec->multiout.max_channels = 2;
11776
11777  dig_only:
11778         /* digital only support output */
11779         if (spec->autocfg.dig_outs) {
11780                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11781                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11782         }
11783         if (spec->kctls.list)
11784                 add_mixer(spec, spec->kctls.list);
11785
11786         if (spec->autocfg.speaker_pins[0] != 0x1d)
11787                 add_mixer(spec, alc268_beep_mixer);
11788
11789         add_verb(spec, alc268_volume_init_verbs);
11790         spec->num_mux_defs = 1;
11791         spec->input_mux = &spec->private_imux[0];
11792
11793         err = alc_auto_add_mic_boost(codec);
11794         if (err < 0)
11795                 return err;
11796
11797         return 1;
11798 }
11799
11800 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
11801 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
11802 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
11803
11804 /* init callback for auto-configuration model -- overriding the default init */
11805 static void alc268_auto_init(struct hda_codec *codec)
11806 {
11807         struct alc_spec *spec = codec->spec;
11808         alc268_auto_init_multi_out(codec);
11809         alc268_auto_init_hp_out(codec);
11810         alc268_auto_init_mono_speaker_out(codec);
11811         alc268_auto_init_analog_input(codec);
11812         if (spec->unsol_event)
11813                 alc_inithook(codec);
11814 }
11815
11816 /*
11817  * configuration and preset
11818  */
11819 static const char *alc268_models[ALC268_MODEL_LAST] = {
11820         [ALC267_QUANTA_IL1]     = "quanta-il1",
11821         [ALC268_3ST]            = "3stack",
11822         [ALC268_TOSHIBA]        = "toshiba",
11823         [ALC268_ACER]           = "acer",
11824         [ALC268_ACER_DMIC]      = "acer-dmic",
11825         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
11826         [ALC268_DELL]           = "dell",
11827         [ALC268_ZEPTO]          = "zepto",
11828 #ifdef CONFIG_SND_DEBUG
11829         [ALC268_TEST]           = "test",
11830 #endif
11831         [ALC268_AUTO]           = "auto",
11832 };
11833
11834 static struct snd_pci_quirk alc268_cfg_tbl[] = {
11835         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
11836         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
11837         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
11838         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
11839         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
11840         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
11841                                                 ALC268_ACER_ASPIRE_ONE),
11842         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
11843         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
11844         SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
11845         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
11846         SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
11847         SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
11848         SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
11849         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
11850         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
11851         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
11852         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
11853         {}
11854 };
11855
11856 static struct alc_config_preset alc268_presets[] = {
11857         [ALC267_QUANTA_IL1] = {
11858                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
11859                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11860                                 alc267_quanta_il1_verbs },
11861                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11862                 .dac_nids = alc268_dac_nids,
11863                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11864                 .adc_nids = alc268_adc_nids_alt,
11865                 .hp_nid = 0x03,
11866                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11867                 .channel_mode = alc268_modes,
11868                 .input_mux = &alc268_capture_source,
11869                 .unsol_event = alc267_quanta_il1_unsol_event,
11870                 .init_hook = alc267_quanta_il1_automute,
11871         },
11872         [ALC268_3ST] = {
11873                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11874                             alc268_beep_mixer },
11875                 .init_verbs = { alc268_base_init_verbs },
11876                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11877                 .dac_nids = alc268_dac_nids,
11878                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11879                 .adc_nids = alc268_adc_nids_alt,
11880                 .capsrc_nids = alc268_capsrc_nids,
11881                 .hp_nid = 0x03,
11882                 .dig_out_nid = ALC268_DIGOUT_NID,
11883                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11884                 .channel_mode = alc268_modes,
11885                 .input_mux = &alc268_capture_source,
11886         },
11887         [ALC268_TOSHIBA] = {
11888                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11889                             alc268_beep_mixer },
11890                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11891                                 alc268_toshiba_verbs },
11892                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11893                 .dac_nids = alc268_dac_nids,
11894                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11895                 .adc_nids = alc268_adc_nids_alt,
11896                 .capsrc_nids = alc268_capsrc_nids,
11897                 .hp_nid = 0x03,
11898                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11899                 .channel_mode = alc268_modes,
11900                 .input_mux = &alc268_capture_source,
11901                 .unsol_event = alc268_toshiba_unsol_event,
11902                 .init_hook = alc268_toshiba_automute,
11903         },
11904         [ALC268_ACER] = {
11905                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
11906                             alc268_beep_mixer },
11907                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11908                                 alc268_acer_verbs },
11909                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11910                 .dac_nids = alc268_dac_nids,
11911                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11912                 .adc_nids = alc268_adc_nids_alt,
11913                 .capsrc_nids = alc268_capsrc_nids,
11914                 .hp_nid = 0x02,
11915                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11916                 .channel_mode = alc268_modes,
11917                 .input_mux = &alc268_acer_capture_source,
11918                 .unsol_event = alc268_acer_unsol_event,
11919                 .init_hook = alc268_acer_init_hook,
11920         },
11921         [ALC268_ACER_DMIC] = {
11922                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
11923                             alc268_beep_mixer },
11924                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11925                                 alc268_acer_verbs },
11926                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11927                 .dac_nids = alc268_dac_nids,
11928                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11929                 .adc_nids = alc268_adc_nids_alt,
11930                 .capsrc_nids = alc268_capsrc_nids,
11931                 .hp_nid = 0x02,
11932                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11933                 .channel_mode = alc268_modes,
11934                 .input_mux = &alc268_acer_dmic_capture_source,
11935                 .unsol_event = alc268_acer_unsol_event,
11936                 .init_hook = alc268_acer_init_hook,
11937         },
11938         [ALC268_ACER_ASPIRE_ONE] = {
11939                 .mixers = { alc268_acer_aspire_one_mixer,
11940                             alc268_beep_mixer,
11941                             alc268_capture_alt_mixer },
11942                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11943                                 alc268_acer_aspire_one_verbs },
11944                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11945                 .dac_nids = alc268_dac_nids,
11946                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11947                 .adc_nids = alc268_adc_nids_alt,
11948                 .capsrc_nids = alc268_capsrc_nids,
11949                 .hp_nid = 0x03,
11950                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11951                 .channel_mode = alc268_modes,
11952                 .input_mux = &alc268_acer_lc_capture_source,
11953                 .unsol_event = alc268_acer_lc_unsol_event,
11954                 .init_hook = alc268_acer_lc_init_hook,
11955         },
11956         [ALC268_DELL] = {
11957                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
11958                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11959                                 alc268_dell_verbs },
11960                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11961                 .dac_nids = alc268_dac_nids,
11962                 .hp_nid = 0x02,
11963                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11964                 .channel_mode = alc268_modes,
11965                 .unsol_event = alc268_dell_unsol_event,
11966                 .init_hook = alc268_dell_init_hook,
11967                 .input_mux = &alc268_capture_source,
11968         },
11969         [ALC268_ZEPTO] = {
11970                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
11971                             alc268_beep_mixer },
11972                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11973                                 alc268_toshiba_verbs },
11974                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11975                 .dac_nids = alc268_dac_nids,
11976                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11977                 .adc_nids = alc268_adc_nids_alt,
11978                 .capsrc_nids = alc268_capsrc_nids,
11979                 .hp_nid = 0x03,
11980                 .dig_out_nid = ALC268_DIGOUT_NID,
11981                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
11982                 .channel_mode = alc268_modes,
11983                 .input_mux = &alc268_capture_source,
11984                 .unsol_event = alc268_toshiba_unsol_event,
11985                 .init_hook = alc268_toshiba_automute
11986         },
11987 #ifdef CONFIG_SND_DEBUG
11988         [ALC268_TEST] = {
11989                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
11990                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
11991                                 alc268_volume_init_verbs },
11992                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
11993                 .dac_nids = alc268_dac_nids,
11994                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
11995                 .adc_nids = alc268_adc_nids_alt,
11996                 .capsrc_nids = alc268_capsrc_nids,
11997                 .hp_nid = 0x03,
11998                 .dig_out_nid = ALC268_DIGOUT_NID,
11999                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12000                 .channel_mode = alc268_modes,
12001                 .input_mux = &alc268_capture_source,
12002         },
12003 #endif
12004 };
12005
12006 static int patch_alc268(struct hda_codec *codec)
12007 {
12008         struct alc_spec *spec;
12009         int board_config;
12010         int i, has_beep, err;
12011
12012         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12013         if (spec == NULL)
12014                 return -ENOMEM;
12015
12016         codec->spec = spec;
12017
12018         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12019                                                   alc268_models,
12020                                                   alc268_cfg_tbl);
12021
12022         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12023                 printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12024                        "trying auto-probe from BIOS...\n");
12025                 board_config = ALC268_AUTO;
12026         }
12027
12028         if (board_config == ALC268_AUTO) {
12029                 /* automatic parse from the BIOS config */
12030                 err = alc268_parse_auto_config(codec);
12031                 if (err < 0) {
12032                         alc_free(codec);
12033                         return err;
12034                 } else if (!err) {
12035                         printk(KERN_INFO
12036                                "hda_codec: Cannot set up configuration "
12037                                "from BIOS.  Using base mode...\n");
12038                         board_config = ALC268_3ST;
12039                 }
12040         }
12041
12042         if (board_config != ALC268_AUTO)
12043                 setup_preset(spec, &alc268_presets[board_config]);
12044
12045         if (codec->vendor_id == 0x10ec0267) {
12046                 spec->stream_name_analog = "ALC267 Analog";
12047                 spec->stream_name_digital = "ALC267 Digital";
12048         } else {
12049                 spec->stream_name_analog = "ALC268 Analog";
12050                 spec->stream_name_digital = "ALC268 Digital";
12051         }
12052
12053         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12054         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12055         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12056
12057         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12058
12059         has_beep = 0;
12060         for (i = 0; i < spec->num_mixers; i++) {
12061                 if (spec->mixers[i] == alc268_beep_mixer) {
12062                         has_beep = 1;
12063                         break;
12064                 }
12065         }
12066
12067         if (has_beep) {
12068                 err = snd_hda_attach_beep_device(codec, 0x1);
12069                 if (err < 0) {
12070                         alc_free(codec);
12071                         return err;
12072                 }
12073                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12074                         /* override the amp caps for beep generator */
12075                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12076                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12077                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12078                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12079                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12080         }
12081
12082         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12083                 /* check whether NID 0x07 is valid */
12084                 unsigned int wcap = get_wcaps(codec, 0x07);
12085                 int i;
12086
12087                 /* get type */
12088                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12089                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12090                         spec->adc_nids = alc268_adc_nids_alt;
12091                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12092                         add_mixer(spec, alc268_capture_alt_mixer);
12093                 } else {
12094                         spec->adc_nids = alc268_adc_nids;
12095                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12096                         add_mixer(spec, alc268_capture_mixer);
12097                 }
12098                 spec->capsrc_nids = alc268_capsrc_nids;
12099                 /* set default input source */
12100                 for (i = 0; i < spec->num_adc_nids; i++)
12101                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12102                                 0, AC_VERB_SET_CONNECT_SEL,
12103                                 spec->input_mux->items[0].index);
12104         }
12105
12106         spec->vmaster_nid = 0x02;
12107
12108         codec->patch_ops = alc_patch_ops;
12109         if (board_config == ALC268_AUTO)
12110                 spec->init_hook = alc268_auto_init;
12111
12112         codec->proc_widget_hook = print_realtek_coef;
12113
12114         return 0;
12115 }
12116
12117 /*
12118  *  ALC269 channel source setting (2 channel)
12119  */
12120 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12121
12122 #define alc269_dac_nids         alc260_dac_nids
12123
12124 static hda_nid_t alc269_adc_nids[1] = {
12125         /* ADC1 */
12126         0x08,
12127 };
12128
12129 static hda_nid_t alc269_capsrc_nids[1] = {
12130         0x23,
12131 };
12132
12133 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12134  *       not a mux!
12135  */
12136
12137 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12138         .num_items = 2,
12139         .items = {
12140                 { "i-Mic", 0x5 },
12141                 { "e-Mic", 0x0 },
12142         },
12143 };
12144
12145 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12146         .num_items = 2,
12147         .items = {
12148                 { "i-Mic", 0x1 },
12149                 { "e-Mic", 0x0 },
12150         },
12151 };
12152
12153 #define alc269_modes            alc260_modes
12154 #define alc269_capture_source   alc880_lg_lw_capture_source
12155
12156 static struct snd_kcontrol_new alc269_base_mixer[] = {
12157         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12158         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12159         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12160         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12161         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12162         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12163         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12164         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12165         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12166         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12167         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12168         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12169         { } /* end */
12170 };
12171
12172 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12173         /* output mixer control */
12174         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12175         {
12176                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12177                 .name = "Master Playback Switch",
12178                 .info = snd_hda_mixer_amp_switch_info,
12179                 .get = snd_hda_mixer_amp_switch_get,
12180                 .put = alc268_acer_master_sw_put,
12181                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12182         },
12183         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12185         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12186         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12187         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12188         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12189         { }
12190 };
12191
12192 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12193         /* output mixer control */
12194         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12195         {
12196                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12197                 .name = "Master Playback Switch",
12198                 .info = snd_hda_mixer_amp_switch_info,
12199                 .get = snd_hda_mixer_amp_switch_get,
12200                 .put = alc268_acer_master_sw_put,
12201                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12202         },
12203         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12204         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12205         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12206         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12207         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12208         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12209         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12210         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12211         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12212         { }
12213 };
12214
12215 /* bind volumes of both NID 0x0c and 0x0d */
12216 static struct hda_bind_ctls alc269_epc_bind_vol = {
12217         .ops = &snd_hda_bind_vol,
12218         .values = {
12219                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12220                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12221                 0
12222         },
12223 };
12224
12225 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12226         HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12227         HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12228         HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12229         { } /* end */
12230 };
12231
12232 /* capture mixer elements */
12233 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12234         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12235         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12236         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12237         { } /* end */
12238 };
12239
12240 /* FSC amilo */
12241 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12242         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12243         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12244         HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12245         { } /* end */
12246 };
12247
12248 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12249         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12250         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12251         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12252         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12253         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12254         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12255         { }
12256 };
12257
12258 static struct hda_verb alc269_lifebook_verbs[] = {
12259         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12260         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12261         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12262         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12263         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12264         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12265         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12266         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12267         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12268         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12269         { }
12270 };
12271
12272 /* toggle speaker-output according to the hp-jack state */
12273 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12274 {
12275         unsigned int present;
12276         unsigned char bits;
12277
12278         present = snd_hda_codec_read(codec, 0x15, 0,
12279                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12280         bits = present ? AMP_IN_MUTE(0) : 0;
12281         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12282                         AMP_IN_MUTE(0), bits);
12283         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12284                         AMP_IN_MUTE(0), bits);
12285
12286         snd_hda_codec_write(codec, 0x20, 0,
12287                         AC_VERB_SET_COEF_INDEX, 0x0c);
12288         snd_hda_codec_write(codec, 0x20, 0,
12289                         AC_VERB_SET_PROC_COEF, 0x680);
12290
12291         snd_hda_codec_write(codec, 0x20, 0,
12292                         AC_VERB_SET_COEF_INDEX, 0x0c);
12293         snd_hda_codec_write(codec, 0x20, 0,
12294                         AC_VERB_SET_PROC_COEF, 0x480);
12295 }
12296
12297 /* toggle speaker-output according to the hp-jacks state */
12298 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12299 {
12300         unsigned int present;
12301         unsigned char bits;
12302
12303         /* Check laptop headphone socket */
12304         present = snd_hda_codec_read(codec, 0x15, 0,
12305                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12306
12307         /* Check port replicator headphone socket */
12308         present |= snd_hda_codec_read(codec, 0x1a, 0,
12309                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12310
12311         bits = present ? AMP_IN_MUTE(0) : 0;
12312         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12313                         AMP_IN_MUTE(0), bits);
12314         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12315                         AMP_IN_MUTE(0), bits);
12316
12317         snd_hda_codec_write(codec, 0x20, 0,
12318                         AC_VERB_SET_COEF_INDEX, 0x0c);
12319         snd_hda_codec_write(codec, 0x20, 0,
12320                         AC_VERB_SET_PROC_COEF, 0x680);
12321
12322         snd_hda_codec_write(codec, 0x20, 0,
12323                         AC_VERB_SET_COEF_INDEX, 0x0c);
12324         snd_hda_codec_write(codec, 0x20, 0,
12325                         AC_VERB_SET_PROC_COEF, 0x480);
12326 }
12327
12328 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12329 {
12330         unsigned int present;
12331
12332         present = snd_hda_codec_read(codec, 0x18, 0,
12333                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12334         snd_hda_codec_write(codec, 0x23, 0,
12335                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12336 }
12337
12338 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12339 {
12340         unsigned int present_laptop;
12341         unsigned int present_dock;
12342
12343         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12344                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12345
12346         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12347                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12348
12349         /* Laptop mic port overrides dock mic port, design decision */
12350         if (present_dock)
12351                 snd_hda_codec_write(codec, 0x23, 0,
12352                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12353         if (present_laptop)
12354                 snd_hda_codec_write(codec, 0x23, 0,
12355                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12356         if (!present_dock && !present_laptop)
12357                 snd_hda_codec_write(codec, 0x23, 0,
12358                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12359 }
12360
12361 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12362                                     unsigned int res)
12363 {
12364         if ((res >> 26) == ALC880_HP_EVENT)
12365                 alc269_quanta_fl1_speaker_automute(codec);
12366         if ((res >> 26) == ALC880_MIC_EVENT)
12367                 alc269_quanta_fl1_mic_automute(codec);
12368 }
12369
12370 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12371                                         unsigned int res)
12372 {
12373         if ((res >> 26) == ALC880_HP_EVENT)
12374                 alc269_lifebook_speaker_automute(codec);
12375         if ((res >> 26) == ALC880_MIC_EVENT)
12376                 alc269_lifebook_mic_autoswitch(codec);
12377 }
12378
12379 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12380 {
12381         alc269_quanta_fl1_speaker_automute(codec);
12382         alc269_quanta_fl1_mic_automute(codec);
12383 }
12384
12385 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12386 {
12387         alc269_lifebook_speaker_automute(codec);
12388         alc269_lifebook_mic_autoswitch(codec);
12389 }
12390
12391 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12392         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12393         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12394         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12395         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12396         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12397         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12398         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12399         {}
12400 };
12401
12402 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12403         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12404         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12405         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12406         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12407         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12408         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12409         {}
12410 };
12411
12412 /* toggle speaker-output according to the hp-jack state */
12413 static void alc269_speaker_automute(struct hda_codec *codec)
12414 {
12415         unsigned int present;
12416         unsigned char bits;
12417
12418         present = snd_hda_codec_read(codec, 0x15, 0,
12419                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12420         bits = present ? AMP_IN_MUTE(0) : 0;
12421         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12422                                 AMP_IN_MUTE(0), bits);
12423         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12424                                 AMP_IN_MUTE(0), bits);
12425 }
12426
12427 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12428 {
12429         unsigned int present;
12430
12431         present = snd_hda_codec_read(codec, 0x18, 0,
12432                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12433         snd_hda_codec_write(codec, 0x23, 0,
12434                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12435 }
12436
12437 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12438 {
12439         unsigned int present;
12440
12441         present = snd_hda_codec_read(codec, 0x18, 0,
12442                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12443         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12444                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12445         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12446                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12447 }
12448
12449 /* unsolicited event for HP jack sensing */
12450 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12451                                      unsigned int res)
12452 {
12453         if ((res >> 26) == ALC880_HP_EVENT)
12454                 alc269_speaker_automute(codec);
12455
12456         if ((res >> 26) == ALC880_MIC_EVENT)
12457                 alc269_eeepc_dmic_automute(codec);
12458 }
12459
12460 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12461 {
12462         alc269_speaker_automute(codec);
12463         alc269_eeepc_dmic_automute(codec);
12464 }
12465
12466 /* unsolicited event for HP jack sensing */
12467 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12468                                      unsigned int res)
12469 {
12470         if ((res >> 26) == ALC880_HP_EVENT)
12471                 alc269_speaker_automute(codec);
12472
12473         if ((res >> 26) == ALC880_MIC_EVENT)
12474                 alc269_eeepc_amic_automute(codec);
12475 }
12476
12477 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12478 {
12479         alc269_speaker_automute(codec);
12480         alc269_eeepc_amic_automute(codec);
12481 }
12482
12483 /*
12484  * generic initialization of ADC, input mixers and output mixers
12485  */
12486 static struct hda_verb alc269_init_verbs[] = {
12487         /*
12488          * Unmute ADC0 and set the default input to mic-in
12489          */
12490         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12491
12492         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12493          * analog-loopback mixer widget
12494          * Note: PASD motherboards uses the Line In 2 as the input for
12495          * front panel mic (mic 2)
12496          */
12497         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12498         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12499         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12500         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12501         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12502         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12503
12504         /*
12505          * Set up output mixers (0x0c - 0x0e)
12506          */
12507         /* set vol=0 to output mixers */
12508         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12509         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12510
12511         /* set up input amps for analog loopback */
12512         /* Amp Indices: DAC = 0, mixer = 1 */
12513         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12514         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12515         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12516         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12517         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12518         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12519
12520         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12521         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12522         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12523         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12524         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12525         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12526         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12527
12528         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12529         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12530         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12531         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12532         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12533         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12534         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12535
12536         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12537         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12538
12539         /* FIXME: use matrix-type input source selection */
12540         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12541         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12542         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12543         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12544         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12545         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12546
12547         /* set EAPD */
12548         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12549         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12550         { }
12551 };
12552
12553 /* add playback controls from the parsed DAC table */
12554 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12555                                              const struct auto_pin_cfg *cfg)
12556 {
12557         hda_nid_t nid;
12558         int err;
12559
12560         spec->multiout.num_dacs = 1;    /* only use one dac */
12561         spec->multiout.dac_nids = spec->private_dac_nids;
12562         spec->multiout.dac_nids[0] = 2;
12563
12564         nid = cfg->line_out_pins[0];
12565         if (nid) {
12566                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12567                                   "Front Playback Volume",
12568                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12569                 if (err < 0)
12570                         return err;
12571                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12572                                   "Front Playback Switch",
12573                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12574                 if (err < 0)
12575                         return err;
12576         }
12577
12578         nid = cfg->speaker_pins[0];
12579         if (nid) {
12580                 if (!cfg->line_out_pins[0]) {
12581                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12582                                           "Speaker Playback Volume",
12583                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12584                                                               HDA_OUTPUT));
12585                         if (err < 0)
12586                                 return err;
12587                 }
12588                 if (nid == 0x16) {
12589                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12590                                           "Speaker Playback Switch",
12591                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12592                                                               HDA_OUTPUT));
12593                         if (err < 0)
12594                                 return err;
12595                 } else {
12596                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12597                                           "Speaker Playback Switch",
12598                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12599                                                               HDA_OUTPUT));
12600                         if (err < 0)
12601                                 return err;
12602                 }
12603         }
12604         nid = cfg->hp_pins[0];
12605         if (nid) {
12606                 /* spec->multiout.hp_nid = 2; */
12607                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12608                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12609                                           "Headphone Playback Volume",
12610                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12611                                                               HDA_OUTPUT));
12612                         if (err < 0)
12613                                 return err;
12614                 }
12615                 if (nid == 0x16) {
12616                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12617                                           "Headphone Playback Switch",
12618                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12619                                                               HDA_OUTPUT));
12620                         if (err < 0)
12621                                 return err;
12622                 } else {
12623                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12624                                           "Headphone Playback Switch",
12625                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12626                                                               HDA_OUTPUT));
12627                         if (err < 0)
12628                                 return err;
12629                 }
12630         }
12631         return 0;
12632 }
12633
12634 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12635                                                 const struct auto_pin_cfg *cfg)
12636 {
12637         int err;
12638
12639         err = alc880_auto_create_analog_input_ctls(spec, cfg);
12640         if (err < 0)
12641                 return err;
12642         /* digital-mic input pin is excluded in alc880_auto_create..()
12643          * because it's under 0x18
12644          */
12645         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12646             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12647                 struct hda_input_mux *imux = &spec->private_imux[0];
12648                 imux->items[imux->num_items].label = "Int Mic";
12649                 imux->items[imux->num_items].index = 0x05;
12650                 imux->num_items++;
12651         }
12652         return 0;
12653 }
12654
12655 #ifdef CONFIG_SND_HDA_POWER_SAVE
12656 #define alc269_loopbacks        alc880_loopbacks
12657 #endif
12658
12659 /* pcm configuration: identiacal with ALC880 */
12660 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12661 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12662 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12663 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12664
12665 /*
12666  * BIOS auto configuration
12667  */
12668 static int alc269_parse_auto_config(struct hda_codec *codec)
12669 {
12670         struct alc_spec *spec = codec->spec;
12671         int err;
12672         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12673
12674         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12675                                            alc269_ignore);
12676         if (err < 0)
12677                 return err;
12678
12679         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12680         if (err < 0)
12681                 return err;
12682         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12683         if (err < 0)
12684                 return err;
12685
12686         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12687
12688         if (spec->autocfg.dig_outs)
12689                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12690
12691         if (spec->kctls.list)
12692                 add_mixer(spec, spec->kctls.list);
12693
12694         add_verb(spec, alc269_init_verbs);
12695         spec->num_mux_defs = 1;
12696         spec->input_mux = &spec->private_imux[0];
12697         /* set default input source */
12698         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12699                                   0, AC_VERB_SET_CONNECT_SEL,
12700                                   spec->input_mux->items[0].index);
12701
12702         err = alc_auto_add_mic_boost(codec);
12703         if (err < 0)
12704                 return err;
12705
12706         if (!spec->cap_mixer && !spec->no_analog)
12707                 set_capture_mixer(spec);
12708
12709         return 1;
12710 }
12711
12712 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12713 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12714 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12715
12716
12717 /* init callback for auto-configuration model -- overriding the default init */
12718 static void alc269_auto_init(struct hda_codec *codec)
12719 {
12720         struct alc_spec *spec = codec->spec;
12721         alc269_auto_init_multi_out(codec);
12722         alc269_auto_init_hp_out(codec);
12723         alc269_auto_init_analog_input(codec);
12724         if (spec->unsol_event)
12725                 alc_inithook(codec);
12726 }
12727
12728 /*
12729  * configuration and preset
12730  */
12731 static const char *alc269_models[ALC269_MODEL_LAST] = {
12732         [ALC269_BASIC]                  = "basic",
12733         [ALC269_QUANTA_FL1]             = "quanta",
12734         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12735         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12736         [ALC269_FUJITSU]                = "fujitsu",
12737         [ALC269_LIFEBOOK]               = "lifebook"
12738 };
12739
12740 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12741         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12742         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12743                       ALC269_ASUS_EEEPC_P703),
12744         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12745                       ALC269_ASUS_EEEPC_P901),
12746         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12747                       ALC269_ASUS_EEEPC_P901),
12748         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12749         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12750         {}
12751 };
12752
12753 static struct alc_config_preset alc269_presets[] = {
12754         [ALC269_BASIC] = {
12755                 .mixers = { alc269_base_mixer },
12756                 .init_verbs = { alc269_init_verbs },
12757                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12758                 .dac_nids = alc269_dac_nids,
12759                 .hp_nid = 0x03,
12760                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12761                 .channel_mode = alc269_modes,
12762                 .input_mux = &alc269_capture_source,
12763         },
12764         [ALC269_QUANTA_FL1] = {
12765                 .mixers = { alc269_quanta_fl1_mixer },
12766                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12767                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12768                 .dac_nids = alc269_dac_nids,
12769                 .hp_nid = 0x03,
12770                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12771                 .channel_mode = alc269_modes,
12772                 .input_mux = &alc269_capture_source,
12773                 .unsol_event = alc269_quanta_fl1_unsol_event,
12774                 .init_hook = alc269_quanta_fl1_init_hook,
12775         },
12776         [ALC269_ASUS_EEEPC_P703] = {
12777                 .mixers = { alc269_eeepc_mixer },
12778                 .cap_mixer = alc269_epc_capture_mixer,
12779                 .init_verbs = { alc269_init_verbs,
12780                                 alc269_eeepc_amic_init_verbs },
12781                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12782                 .dac_nids = alc269_dac_nids,
12783                 .hp_nid = 0x03,
12784                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12785                 .channel_mode = alc269_modes,
12786                 .input_mux = &alc269_eeepc_amic_capture_source,
12787                 .unsol_event = alc269_eeepc_amic_unsol_event,
12788                 .init_hook = alc269_eeepc_amic_inithook,
12789         },
12790         [ALC269_ASUS_EEEPC_P901] = {
12791                 .mixers = { alc269_eeepc_mixer },
12792                 .cap_mixer = alc269_epc_capture_mixer,
12793                 .init_verbs = { alc269_init_verbs,
12794                                 alc269_eeepc_dmic_init_verbs },
12795                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12796                 .dac_nids = alc269_dac_nids,
12797                 .hp_nid = 0x03,
12798                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12799                 .channel_mode = alc269_modes,
12800                 .input_mux = &alc269_eeepc_dmic_capture_source,
12801                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12802                 .init_hook = alc269_eeepc_dmic_inithook,
12803         },
12804         [ALC269_FUJITSU] = {
12805                 .mixers = { alc269_fujitsu_mixer },
12806                 .cap_mixer = alc269_epc_capture_mixer,
12807                 .init_verbs = { alc269_init_verbs,
12808                                 alc269_eeepc_dmic_init_verbs },
12809                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12810                 .dac_nids = alc269_dac_nids,
12811                 .hp_nid = 0x03,
12812                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12813                 .channel_mode = alc269_modes,
12814                 .input_mux = &alc269_eeepc_dmic_capture_source,
12815                 .unsol_event = alc269_eeepc_dmic_unsol_event,
12816                 .init_hook = alc269_eeepc_dmic_inithook,
12817         },
12818         [ALC269_LIFEBOOK] = {
12819                 .mixers = { alc269_lifebook_mixer },
12820                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
12821                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12822                 .dac_nids = alc269_dac_nids,
12823                 .hp_nid = 0x03,
12824                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12825                 .channel_mode = alc269_modes,
12826                 .input_mux = &alc269_capture_source,
12827                 .unsol_event = alc269_lifebook_unsol_event,
12828                 .init_hook = alc269_lifebook_init_hook,
12829         },
12830 };
12831
12832 static int patch_alc269(struct hda_codec *codec)
12833 {
12834         struct alc_spec *spec;
12835         int board_config;
12836         int err;
12837
12838         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12839         if (spec == NULL)
12840                 return -ENOMEM;
12841
12842         codec->spec = spec;
12843
12844         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12845
12846         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
12847                                                   alc269_models,
12848                                                   alc269_cfg_tbl);
12849
12850         if (board_config < 0) {
12851                 printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
12852                        "trying auto-probe from BIOS...\n");
12853                 board_config = ALC269_AUTO;
12854         }
12855
12856         if (board_config == ALC269_AUTO) {
12857                 /* automatic parse from the BIOS config */
12858                 err = alc269_parse_auto_config(codec);
12859                 if (err < 0) {
12860                         alc_free(codec);
12861                         return err;
12862                 } else if (!err) {
12863                         printk(KERN_INFO
12864                                "hda_codec: Cannot set up configuration "
12865                                "from BIOS.  Using base mode...\n");
12866                         board_config = ALC269_BASIC;
12867                 }
12868         }
12869
12870         err = snd_hda_attach_beep_device(codec, 0x1);
12871         if (err < 0) {
12872                 alc_free(codec);
12873                 return err;
12874         }
12875
12876         if (board_config != ALC269_AUTO)
12877                 setup_preset(spec, &alc269_presets[board_config]);
12878
12879         spec->stream_name_analog = "ALC269 Analog";
12880         spec->stream_analog_playback = &alc269_pcm_analog_playback;
12881         spec->stream_analog_capture = &alc269_pcm_analog_capture;
12882
12883         spec->stream_name_digital = "ALC269 Digital";
12884         spec->stream_digital_playback = &alc269_pcm_digital_playback;
12885         spec->stream_digital_capture = &alc269_pcm_digital_capture;
12886
12887         spec->adc_nids = alc269_adc_nids;
12888         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
12889         spec->capsrc_nids = alc269_capsrc_nids;
12890         if (!spec->cap_mixer)
12891                 set_capture_mixer(spec);
12892         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12893
12894         codec->patch_ops = alc_patch_ops;
12895         if (board_config == ALC269_AUTO)
12896                 spec->init_hook = alc269_auto_init;
12897 #ifdef CONFIG_SND_HDA_POWER_SAVE
12898         if (!spec->loopback.amplist)
12899                 spec->loopback.amplist = alc269_loopbacks;
12900 #endif
12901         codec->proc_widget_hook = print_realtek_coef;
12902
12903         return 0;
12904 }
12905
12906 /*
12907  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
12908  */
12909
12910 /*
12911  * set the path ways for 2 channel output
12912  * need to set the codec line out and mic 1 pin widgets to inputs
12913  */
12914 static struct hda_verb alc861_threestack_ch2_init[] = {
12915         /* set pin widget 1Ah (line in) for input */
12916         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12917         /* set pin widget 18h (mic1/2) for input, for mic also enable
12918          * the vref
12919          */
12920         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12921
12922         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12923 #if 0
12924         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12925         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12926 #endif
12927         { } /* end */
12928 };
12929 /*
12930  * 6ch mode
12931  * need to set the codec line out and mic 1 pin widgets to outputs
12932  */
12933 static struct hda_verb alc861_threestack_ch6_init[] = {
12934         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12935         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12936         /* set pin widget 18h (mic1) for output (CLFE)*/
12937         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12938
12939         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12940         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12941
12942         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
12943 #if 0
12944         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12945         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
12946 #endif
12947         { } /* end */
12948 };
12949
12950 static struct hda_channel_mode alc861_threestack_modes[2] = {
12951         { 2, alc861_threestack_ch2_init },
12952         { 6, alc861_threestack_ch6_init },
12953 };
12954 /* Set mic1 as input and unmute the mixer */
12955 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
12956         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12957         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
12958         { } /* end */
12959 };
12960 /* Set mic1 as output and mute mixer */
12961 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
12962         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12963         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12964         { } /* end */
12965 };
12966
12967 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
12968         { 2, alc861_uniwill_m31_ch2_init },
12969         { 4, alc861_uniwill_m31_ch4_init },
12970 };
12971
12972 /* Set mic1 and line-in as input and unmute the mixer */
12973 static struct hda_verb alc861_asus_ch2_init[] = {
12974         /* set pin widget 1Ah (line in) for input */
12975         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
12976         /* set pin widget 18h (mic1/2) for input, for mic also enable
12977          * the vref
12978          */
12979         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
12980
12981         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
12982 #if 0
12983         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
12984         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
12985 #endif
12986         { } /* end */
12987 };
12988 /* Set mic1 nad line-in as output and mute mixer */
12989 static struct hda_verb alc861_asus_ch6_init[] = {
12990         /* set pin widget 1Ah (line in) for output (Back Surround)*/
12991         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12992         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12993         /* set pin widget 18h (mic1) for output (CLFE)*/
12994         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
12995         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
12996         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
12997         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
12998
12999         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13000 #if 0
13001         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13002         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13003 #endif
13004         { } /* end */
13005 };
13006
13007 static struct hda_channel_mode alc861_asus_modes[2] = {
13008         { 2, alc861_asus_ch2_init },
13009         { 6, alc861_asus_ch6_init },
13010 };
13011
13012 /* patch-ALC861 */
13013
13014 static struct snd_kcontrol_new alc861_base_mixer[] = {
13015         /* output mixer control */
13016         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13017         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13018         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13019         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13020         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13021
13022         /*Input mixer control */
13023         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13024            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13025         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13026         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13027         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13028         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13029         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13030         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13031         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13032         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13033
13034         { } /* end */
13035 };
13036
13037 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13038         /* output mixer control */
13039         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13040         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13041         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13042         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13043         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13044
13045         /* Input mixer control */
13046         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13047            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13048         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13049         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13050         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13051         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13052         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13053         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13054         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13055         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13056
13057         {
13058                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13059                 .name = "Channel Mode",
13060                 .info = alc_ch_mode_info,
13061                 .get = alc_ch_mode_get,
13062                 .put = alc_ch_mode_put,
13063                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13064         },
13065         { } /* end */
13066 };
13067
13068 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13069         /* output mixer control */
13070         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13071         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13072         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13073
13074         { } /* end */
13075 };
13076
13077 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13078         /* output mixer control */
13079         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13080         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13081         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13082         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13083         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13084
13085         /* Input mixer control */
13086         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13087            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13088         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13089         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13090         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13091         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13092         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13093         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13094         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13095         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13096
13097         {
13098                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13099                 .name = "Channel Mode",
13100                 .info = alc_ch_mode_info,
13101                 .get = alc_ch_mode_get,
13102                 .put = alc_ch_mode_put,
13103                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13104         },
13105         { } /* end */
13106 };
13107
13108 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13109         /* output mixer control */
13110         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13111         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13112         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13113         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13114         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13115
13116         /* Input mixer control */
13117         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13118         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13119         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13120         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13121         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13122         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13123         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13124         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13125         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13126         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13127
13128         {
13129                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13130                 .name = "Channel Mode",
13131                 .info = alc_ch_mode_info,
13132                 .get = alc_ch_mode_get,
13133                 .put = alc_ch_mode_put,
13134                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13135         },
13136         { }
13137 };
13138
13139 /* additional mixer */
13140 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13141         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13142         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13143         { }
13144 };
13145
13146 /*
13147  * generic initialization of ADC, input mixers and output mixers
13148  */
13149 static struct hda_verb alc861_base_init_verbs[] = {
13150         /*
13151          * Unmute ADC0 and set the default input to mic-in
13152          */
13153         /* port-A for surround (rear panel) */
13154         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13155         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13156         /* port-B for mic-in (rear panel) with vref */
13157         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13158         /* port-C for line-in (rear panel) */
13159         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13160         /* port-D for Front */
13161         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13162         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13163         /* port-E for HP out (front panel) */
13164         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13165         /* route front PCM to HP */
13166         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13167         /* port-F for mic-in (front panel) with vref */
13168         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13169         /* port-G for CLFE (rear panel) */
13170         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13171         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13172         /* port-H for side (rear panel) */
13173         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13174         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13175         /* CD-in */
13176         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13177         /* route front mic to ADC1*/
13178         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13179         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13180
13181         /* Unmute DAC0~3 & spdif out*/
13182         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13183         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13184         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13185         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13186         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13187
13188         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13189         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13190         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13191         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13192         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13193
13194         /* Unmute Stereo Mixer 15 */
13195         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13196         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13197         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13198         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13199
13200         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13201         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13202         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13203         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13204         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13205         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13206         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13207         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13208         /* hp used DAC 3 (Front) */
13209         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13210         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13211
13212         { }
13213 };
13214
13215 static struct hda_verb alc861_threestack_init_verbs[] = {
13216         /*
13217          * Unmute ADC0 and set the default input to mic-in
13218          */
13219         /* port-A for surround (rear panel) */
13220         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13221         /* port-B for mic-in (rear panel) with vref */
13222         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13223         /* port-C for line-in (rear panel) */
13224         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13225         /* port-D for Front */
13226         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13227         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13228         /* port-E for HP out (front panel) */
13229         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13230         /* route front PCM to HP */
13231         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13232         /* port-F for mic-in (front panel) with vref */
13233         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13234         /* port-G for CLFE (rear panel) */
13235         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13236         /* port-H for side (rear panel) */
13237         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13238         /* CD-in */
13239         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13240         /* route front mic to ADC1*/
13241         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13242         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13243         /* Unmute DAC0~3 & spdif out*/
13244         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13245         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13246         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13247         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13249
13250         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13251         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13252         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13253         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13254         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13255
13256         /* Unmute Stereo Mixer 15 */
13257         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13258         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13259         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13260         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13261
13262         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13263         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13264         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13265         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13266         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13267         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13268         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13269         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13270         /* hp used DAC 3 (Front) */
13271         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13272         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13273         { }
13274 };
13275
13276 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13277         /*
13278          * Unmute ADC0 and set the default input to mic-in
13279          */
13280         /* port-A for surround (rear panel) */
13281         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13282         /* port-B for mic-in (rear panel) with vref */
13283         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13284         /* port-C for line-in (rear panel) */
13285         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13286         /* port-D for Front */
13287         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13288         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13289         /* port-E for HP out (front panel) */
13290         /* this has to be set to VREF80 */
13291         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13292         /* route front PCM to HP */
13293         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13294         /* port-F for mic-in (front panel) with vref */
13295         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13296         /* port-G for CLFE (rear panel) */
13297         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13298         /* port-H for side (rear panel) */
13299         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13300         /* CD-in */
13301         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13302         /* route front mic to ADC1*/
13303         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13304         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13305         /* Unmute DAC0~3 & spdif out*/
13306         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13307         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13308         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13309         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13310         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13311
13312         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13313         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13314         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13315         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13316         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13317
13318         /* Unmute Stereo Mixer 15 */
13319         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13320         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13321         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13323
13324         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13325         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13326         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13327         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13328         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13329         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13330         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13331         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13332         /* hp used DAC 3 (Front) */
13333         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13334         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13335         { }
13336 };
13337
13338 static struct hda_verb alc861_asus_init_verbs[] = {
13339         /*
13340          * Unmute ADC0 and set the default input to mic-in
13341          */
13342         /* port-A for surround (rear panel)
13343          * according to codec#0 this is the HP jack
13344          */
13345         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13346         /* route front PCM to HP */
13347         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13348         /* port-B for mic-in (rear panel) with vref */
13349         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13350         /* port-C for line-in (rear panel) */
13351         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13352         /* port-D for Front */
13353         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13354         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13355         /* port-E for HP out (front panel) */
13356         /* this has to be set to VREF80 */
13357         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13358         /* route front PCM to HP */
13359         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13360         /* port-F for mic-in (front panel) with vref */
13361         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13362         /* port-G for CLFE (rear panel) */
13363         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13364         /* port-H for side (rear panel) */
13365         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13366         /* CD-in */
13367         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13368         /* route front mic to ADC1*/
13369         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13370         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13371         /* Unmute DAC0~3 & spdif out*/
13372         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13373         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13374         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13375         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13376         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13377         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13378         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13379         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13380         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13381         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13382
13383         /* Unmute Stereo Mixer 15 */
13384         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13385         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13386         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13387         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13388
13389         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13390         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13391         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13392         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13393         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13394         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13395         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13396         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13397         /* hp used DAC 3 (Front) */
13398         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13399         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13400         { }
13401 };
13402
13403 /* additional init verbs for ASUS laptops */
13404 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13405         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13406         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13407         { }
13408 };
13409
13410 /*
13411  * generic initialization of ADC, input mixers and output mixers
13412  */
13413 static struct hda_verb alc861_auto_init_verbs[] = {
13414         /*
13415          * Unmute ADC0 and set the default input to mic-in
13416          */
13417         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13418         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13419
13420         /* Unmute DAC0~3 & spdif out*/
13421         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13422         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13423         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13424         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13425         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13426
13427         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13428         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13429         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13430         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13431         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13432
13433         /* Unmute Stereo Mixer 15 */
13434         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13435         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13436         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13437         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13438
13439         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13440         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13441         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13442         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13443         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13444         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13445         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13446         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13447
13448         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13449         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13450         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13451         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13452         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13453         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13454         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13455         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13456
13457         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13458
13459         { }
13460 };
13461
13462 static struct hda_verb alc861_toshiba_init_verbs[] = {
13463         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13464
13465         { }
13466 };
13467
13468 /* toggle speaker-output according to the hp-jack state */
13469 static void alc861_toshiba_automute(struct hda_codec *codec)
13470 {
13471         unsigned int present;
13472
13473         present = snd_hda_codec_read(codec, 0x0f, 0,
13474                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13475         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13476                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13477         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13478                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13479 }
13480
13481 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13482                                        unsigned int res)
13483 {
13484         if ((res >> 26) == ALC880_HP_EVENT)
13485                 alc861_toshiba_automute(codec);
13486 }
13487
13488 /* pcm configuration: identiacal with ALC880 */
13489 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13490 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13491 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13492 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13493
13494
13495 #define ALC861_DIGOUT_NID       0x07
13496
13497 static struct hda_channel_mode alc861_8ch_modes[1] = {
13498         { 8, NULL }
13499 };
13500
13501 static hda_nid_t alc861_dac_nids[4] = {
13502         /* front, surround, clfe, side */
13503         0x03, 0x06, 0x05, 0x04
13504 };
13505
13506 static hda_nid_t alc660_dac_nids[3] = {
13507         /* front, clfe, surround */
13508         0x03, 0x05, 0x06
13509 };
13510
13511 static hda_nid_t alc861_adc_nids[1] = {
13512         /* ADC0-2 */
13513         0x08,
13514 };
13515
13516 static struct hda_input_mux alc861_capture_source = {
13517         .num_items = 5,
13518         .items = {
13519                 { "Mic", 0x0 },
13520                 { "Front Mic", 0x3 },
13521                 { "Line", 0x1 },
13522                 { "CD", 0x4 },
13523                 { "Mixer", 0x5 },
13524         },
13525 };
13526
13527 /* fill in the dac_nids table from the parsed pin configuration */
13528 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13529                                      const struct auto_pin_cfg *cfg)
13530 {
13531         int i;
13532         hda_nid_t nid;
13533
13534         spec->multiout.dac_nids = spec->private_dac_nids;
13535         for (i = 0; i < cfg->line_outs; i++) {
13536                 nid = cfg->line_out_pins[i];
13537                 if (nid) {
13538                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13539                                 continue;
13540                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13541                 }
13542         }
13543         spec->multiout.num_dacs = cfg->line_outs;
13544         return 0;
13545 }
13546
13547 /* add playback controls from the parsed DAC table */
13548 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13549                                              const struct auto_pin_cfg *cfg)
13550 {
13551         char name[32];
13552         static const char *chname[4] = {
13553                 "Front", "Surround", NULL /*CLFE*/, "Side"
13554         };
13555         hda_nid_t nid;
13556         int i, idx, err;
13557
13558         for (i = 0; i < cfg->line_outs; i++) {
13559                 nid = spec->multiout.dac_nids[i];
13560                 if (!nid)
13561                         continue;
13562                 if (nid == 0x05) {
13563                         /* Center/LFE */
13564                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13565                                           "Center Playback Switch",
13566                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13567                                                               HDA_OUTPUT));
13568                         if (err < 0)
13569                                 return err;
13570                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13571                                           "LFE Playback Switch",
13572                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13573                                                               HDA_OUTPUT));
13574                         if (err < 0)
13575                                 return err;
13576                 } else {
13577                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13578                              idx++)
13579                                 if (nid == alc861_dac_nids[idx])
13580                                         break;
13581                         sprintf(name, "%s Playback Switch", chname[idx]);
13582                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13583                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13584                                                               HDA_OUTPUT));
13585                         if (err < 0)
13586                                 return err;
13587                 }
13588         }
13589         return 0;
13590 }
13591
13592 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13593 {
13594         int err;
13595         hda_nid_t nid;
13596
13597         if (!pin)
13598                 return 0;
13599
13600         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13601                 nid = 0x03;
13602                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13603                                   "Headphone Playback Switch",
13604                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13605                 if (err < 0)
13606                         return err;
13607                 spec->multiout.hp_nid = nid;
13608         }
13609         return 0;
13610 }
13611
13612 /* create playback/capture controls for input pins */
13613 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13614                                                 const struct auto_pin_cfg *cfg)
13615 {
13616         struct hda_input_mux *imux = &spec->private_imux[0];
13617         int i, err, idx, idx1;
13618
13619         for (i = 0; i < AUTO_PIN_LAST; i++) {
13620                 switch (cfg->input_pins[i]) {
13621                 case 0x0c:
13622                         idx1 = 1;
13623                         idx = 2;        /* Line In */
13624                         break;
13625                 case 0x0f:
13626                         idx1 = 2;
13627                         idx = 2;        /* Line In */
13628                         break;
13629                 case 0x0d:
13630                         idx1 = 0;
13631                         idx = 1;        /* Mic In */
13632                         break;
13633                 case 0x10:
13634                         idx1 = 3;
13635                         idx = 1;        /* Mic In */
13636                         break;
13637                 case 0x11:
13638                         idx1 = 4;
13639                         idx = 0;        /* CD */
13640                         break;
13641                 default:
13642                         continue;
13643                 }
13644
13645                 err = new_analog_input(spec, cfg->input_pins[i],
13646                                        auto_pin_cfg_labels[i], idx, 0x15);
13647                 if (err < 0)
13648                         return err;
13649
13650                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13651                 imux->items[imux->num_items].index = idx1;
13652                 imux->num_items++;
13653         }
13654         return 0;
13655 }
13656
13657 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13658                                               hda_nid_t nid,
13659                                               int pin_type, int dac_idx)
13660 {
13661         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13662                             pin_type);
13663         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13664                             AMP_OUT_UNMUTE);
13665 }
13666
13667 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13668 {
13669         struct alc_spec *spec = codec->spec;
13670         int i;
13671
13672         alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13673         for (i = 0; i < spec->autocfg.line_outs; i++) {
13674                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13675                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13676                 if (nid)
13677                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13678                                                           spec->multiout.dac_nids[i]);
13679         }
13680 }
13681
13682 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13683 {
13684         struct alc_spec *spec = codec->spec;
13685         hda_nid_t pin;
13686
13687         pin = spec->autocfg.hp_pins[0];
13688         if (pin) /* connect to front */
13689                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13690                                                   spec->multiout.dac_nids[0]);
13691         pin = spec->autocfg.speaker_pins[0];
13692         if (pin)
13693                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13694 }
13695
13696 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13697 {
13698         struct alc_spec *spec = codec->spec;
13699         int i;
13700
13701         for (i = 0; i < AUTO_PIN_LAST; i++) {
13702                 hda_nid_t nid = spec->autocfg.input_pins[i];
13703                 if (nid >= 0x0c && nid <= 0x11) {
13704                         snd_hda_codec_write(codec, nid, 0,
13705                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
13706                                             i <= AUTO_PIN_FRONT_MIC ?
13707                                             PIN_VREF80 : PIN_IN);
13708                 }
13709         }
13710 }
13711
13712 /* parse the BIOS configuration and set up the alc_spec */
13713 /* return 1 if successful, 0 if the proper config is not found,
13714  * or a negative error code
13715  */
13716 static int alc861_parse_auto_config(struct hda_codec *codec)
13717 {
13718         struct alc_spec *spec = codec->spec;
13719         int err;
13720         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13721
13722         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13723                                            alc861_ignore);
13724         if (err < 0)
13725                 return err;
13726         if (!spec->autocfg.line_outs)
13727                 return 0; /* can't find valid BIOS pin config */
13728
13729         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13730         if (err < 0)
13731                 return err;
13732         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13733         if (err < 0)
13734                 return err;
13735         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13736         if (err < 0)
13737                 return err;
13738         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13739         if (err < 0)
13740                 return err;
13741
13742         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13743
13744         if (spec->autocfg.dig_outs)
13745                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13746
13747         if (spec->kctls.list)
13748                 add_mixer(spec, spec->kctls.list);
13749
13750         add_verb(spec, alc861_auto_init_verbs);
13751
13752         spec->num_mux_defs = 1;
13753         spec->input_mux = &spec->private_imux[0];
13754
13755         spec->adc_nids = alc861_adc_nids;
13756         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13757         set_capture_mixer(spec);
13758
13759         return 1;
13760 }
13761
13762 /* additional initialization for auto-configuration model */
13763 static void alc861_auto_init(struct hda_codec *codec)
13764 {
13765         struct alc_spec *spec = codec->spec;
13766         alc861_auto_init_multi_out(codec);
13767         alc861_auto_init_hp_out(codec);
13768         alc861_auto_init_analog_input(codec);
13769         if (spec->unsol_event)
13770                 alc_inithook(codec);
13771 }
13772
13773 #ifdef CONFIG_SND_HDA_POWER_SAVE
13774 static struct hda_amp_list alc861_loopbacks[] = {
13775         { 0x15, HDA_INPUT, 0 },
13776         { 0x15, HDA_INPUT, 1 },
13777         { 0x15, HDA_INPUT, 2 },
13778         { 0x15, HDA_INPUT, 3 },
13779         { } /* end */
13780 };
13781 #endif
13782
13783
13784 /*
13785  * configuration and preset
13786  */
13787 static const char *alc861_models[ALC861_MODEL_LAST] = {
13788         [ALC861_3ST]            = "3stack",
13789         [ALC660_3ST]            = "3stack-660",
13790         [ALC861_3ST_DIG]        = "3stack-dig",
13791         [ALC861_6ST_DIG]        = "6stack-dig",
13792         [ALC861_UNIWILL_M31]    = "uniwill-m31",
13793         [ALC861_TOSHIBA]        = "toshiba",
13794         [ALC861_ASUS]           = "asus",
13795         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
13796         [ALC861_AUTO]           = "auto",
13797 };
13798
13799 static struct snd_pci_quirk alc861_cfg_tbl[] = {
13800         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
13801         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13802         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
13803         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
13804         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
13805         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
13806         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
13807         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
13808          *        Any other models that need this preset?
13809          */
13810         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
13811         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
13812         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
13813         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
13814         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
13815         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
13816         /* FIXME: the below seems conflict */
13817         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
13818         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
13819         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
13820         {}
13821 };
13822
13823 static struct alc_config_preset alc861_presets[] = {
13824         [ALC861_3ST] = {
13825                 .mixers = { alc861_3ST_mixer },
13826                 .init_verbs = { alc861_threestack_init_verbs },
13827                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13828                 .dac_nids = alc861_dac_nids,
13829                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13830                 .channel_mode = alc861_threestack_modes,
13831                 .need_dac_fix = 1,
13832                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13833                 .adc_nids = alc861_adc_nids,
13834                 .input_mux = &alc861_capture_source,
13835         },
13836         [ALC861_3ST_DIG] = {
13837                 .mixers = { alc861_base_mixer },
13838                 .init_verbs = { alc861_threestack_init_verbs },
13839                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13840                 .dac_nids = alc861_dac_nids,
13841                 .dig_out_nid = ALC861_DIGOUT_NID,
13842                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13843                 .channel_mode = alc861_threestack_modes,
13844                 .need_dac_fix = 1,
13845                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13846                 .adc_nids = alc861_adc_nids,
13847                 .input_mux = &alc861_capture_source,
13848         },
13849         [ALC861_6ST_DIG] = {
13850                 .mixers = { alc861_base_mixer },
13851                 .init_verbs = { alc861_base_init_verbs },
13852                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13853                 .dac_nids = alc861_dac_nids,
13854                 .dig_out_nid = ALC861_DIGOUT_NID,
13855                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
13856                 .channel_mode = alc861_8ch_modes,
13857                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13858                 .adc_nids = alc861_adc_nids,
13859                 .input_mux = &alc861_capture_source,
13860         },
13861         [ALC660_3ST] = {
13862                 .mixers = { alc861_3ST_mixer },
13863                 .init_verbs = { alc861_threestack_init_verbs },
13864                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
13865                 .dac_nids = alc660_dac_nids,
13866                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
13867                 .channel_mode = alc861_threestack_modes,
13868                 .need_dac_fix = 1,
13869                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13870                 .adc_nids = alc861_adc_nids,
13871                 .input_mux = &alc861_capture_source,
13872         },
13873         [ALC861_UNIWILL_M31] = {
13874                 .mixers = { alc861_uniwill_m31_mixer },
13875                 .init_verbs = { alc861_uniwill_m31_init_verbs },
13876                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13877                 .dac_nids = alc861_dac_nids,
13878                 .dig_out_nid = ALC861_DIGOUT_NID,
13879                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
13880                 .channel_mode = alc861_uniwill_m31_modes,
13881                 .need_dac_fix = 1,
13882                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13883                 .adc_nids = alc861_adc_nids,
13884                 .input_mux = &alc861_capture_source,
13885         },
13886         [ALC861_TOSHIBA] = {
13887                 .mixers = { alc861_toshiba_mixer },
13888                 .init_verbs = { alc861_base_init_verbs,
13889                                 alc861_toshiba_init_verbs },
13890                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13891                 .dac_nids = alc861_dac_nids,
13892                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13893                 .channel_mode = alc883_3ST_2ch_modes,
13894                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13895                 .adc_nids = alc861_adc_nids,
13896                 .input_mux = &alc861_capture_source,
13897                 .unsol_event = alc861_toshiba_unsol_event,
13898                 .init_hook = alc861_toshiba_automute,
13899         },
13900         [ALC861_ASUS] = {
13901                 .mixers = { alc861_asus_mixer },
13902                 .init_verbs = { alc861_asus_init_verbs },
13903                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13904                 .dac_nids = alc861_dac_nids,
13905                 .dig_out_nid = ALC861_DIGOUT_NID,
13906                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
13907                 .channel_mode = alc861_asus_modes,
13908                 .need_dac_fix = 1,
13909                 .hp_nid = 0x06,
13910                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13911                 .adc_nids = alc861_adc_nids,
13912                 .input_mux = &alc861_capture_source,
13913         },
13914         [ALC861_ASUS_LAPTOP] = {
13915                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
13916                 .init_verbs = { alc861_asus_init_verbs,
13917                                 alc861_asus_laptop_init_verbs },
13918                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
13919                 .dac_nids = alc861_dac_nids,
13920                 .dig_out_nid = ALC861_DIGOUT_NID,
13921                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
13922                 .channel_mode = alc883_3ST_2ch_modes,
13923                 .need_dac_fix = 1,
13924                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
13925                 .adc_nids = alc861_adc_nids,
13926                 .input_mux = &alc861_capture_source,
13927         },
13928 };
13929
13930
13931 static int patch_alc861(struct hda_codec *codec)
13932 {
13933         struct alc_spec *spec;
13934         int board_config;
13935         int err;
13936
13937         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13938         if (spec == NULL)
13939                 return -ENOMEM;
13940
13941         codec->spec = spec;
13942
13943         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
13944                                                   alc861_models,
13945                                                   alc861_cfg_tbl);
13946
13947         if (board_config < 0) {
13948                 printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
13949                        "trying auto-probe from BIOS...\n");
13950                 board_config = ALC861_AUTO;
13951         }
13952
13953         if (board_config == ALC861_AUTO) {
13954                 /* automatic parse from the BIOS config */
13955                 err = alc861_parse_auto_config(codec);
13956                 if (err < 0) {
13957                         alc_free(codec);
13958                         return err;
13959                 } else if (!err) {
13960                         printk(KERN_INFO
13961                                "hda_codec: Cannot set up configuration "
13962                                "from BIOS.  Using base mode...\n");
13963                    board_config = ALC861_3ST_DIG;
13964                 }
13965         }
13966
13967         err = snd_hda_attach_beep_device(codec, 0x23);
13968         if (err < 0) {
13969                 alc_free(codec);
13970                 return err;
13971         }
13972
13973         if (board_config != ALC861_AUTO)
13974                 setup_preset(spec, &alc861_presets[board_config]);
13975
13976         spec->stream_name_analog = "ALC861 Analog";
13977         spec->stream_analog_playback = &alc861_pcm_analog_playback;
13978         spec->stream_analog_capture = &alc861_pcm_analog_capture;
13979
13980         spec->stream_name_digital = "ALC861 Digital";
13981         spec->stream_digital_playback = &alc861_pcm_digital_playback;
13982         spec->stream_digital_capture = &alc861_pcm_digital_capture;
13983
13984         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
13985
13986         spec->vmaster_nid = 0x03;
13987
13988         codec->patch_ops = alc_patch_ops;
13989         if (board_config == ALC861_AUTO)
13990                 spec->init_hook = alc861_auto_init;
13991 #ifdef CONFIG_SND_HDA_POWER_SAVE
13992         if (!spec->loopback.amplist)
13993                 spec->loopback.amplist = alc861_loopbacks;
13994 #endif
13995         codec->proc_widget_hook = print_realtek_coef;
13996
13997         return 0;
13998 }
13999
14000 /*
14001  * ALC861-VD support
14002  *
14003  * Based on ALC882
14004  *
14005  * In addition, an independent DAC
14006  */
14007 #define ALC861VD_DIGOUT_NID     0x06
14008
14009 static hda_nid_t alc861vd_dac_nids[4] = {
14010         /* front, surr, clfe, side surr */
14011         0x02, 0x03, 0x04, 0x05
14012 };
14013
14014 /* dac_nids for ALC660vd are in a different order - according to
14015  * Realtek's driver.
14016  * This should probably tesult in a different mixer for 6stack models
14017  * of ALC660vd codecs, but for now there is only 3stack mixer
14018  * - and it is the same as in 861vd.
14019  * adc_nids in ALC660vd are (is) the same as in 861vd
14020  */
14021 static hda_nid_t alc660vd_dac_nids[3] = {
14022         /* front, rear, clfe, rear_surr */
14023         0x02, 0x04, 0x03
14024 };
14025
14026 static hda_nid_t alc861vd_adc_nids[1] = {
14027         /* ADC0 */
14028         0x09,
14029 };
14030
14031 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14032
14033 /* input MUX */
14034 /* FIXME: should be a matrix-type input source selection */
14035 static struct hda_input_mux alc861vd_capture_source = {
14036         .num_items = 4,
14037         .items = {
14038                 { "Mic", 0x0 },
14039                 { "Front Mic", 0x1 },
14040                 { "Line", 0x2 },
14041                 { "CD", 0x4 },
14042         },
14043 };
14044
14045 static struct hda_input_mux alc861vd_dallas_capture_source = {
14046         .num_items = 2,
14047         .items = {
14048                 { "Ext Mic", 0x0 },
14049                 { "Int Mic", 0x1 },
14050         },
14051 };
14052
14053 static struct hda_input_mux alc861vd_hp_capture_source = {
14054         .num_items = 2,
14055         .items = {
14056                 { "Front Mic", 0x0 },
14057                 { "ATAPI Mic", 0x1 },
14058         },
14059 };
14060
14061 /*
14062  * 2ch mode
14063  */
14064 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14065         { 2, NULL }
14066 };
14067
14068 /*
14069  * 6ch mode
14070  */
14071 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14072         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14073         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14074         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14075         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14076         { } /* end */
14077 };
14078
14079 /*
14080  * 8ch mode
14081  */
14082 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14083         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14084         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14085         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14086         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14087         { } /* end */
14088 };
14089
14090 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14091         { 6, alc861vd_6stack_ch6_init },
14092         { 8, alc861vd_6stack_ch8_init },
14093 };
14094
14095 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14096         {
14097                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14098                 .name = "Channel Mode",
14099                 .info = alc_ch_mode_info,
14100                 .get = alc_ch_mode_get,
14101                 .put = alc_ch_mode_put,
14102         },
14103         { } /* end */
14104 };
14105
14106 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14107  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14108  */
14109 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14110         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14111         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14112
14113         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14114         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14115
14116         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14117                                 HDA_OUTPUT),
14118         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14119                                 HDA_OUTPUT),
14120         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14121         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14122
14123         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14124         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14125
14126         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14127
14128         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14130         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14131
14132         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14133         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14134         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14135
14136         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14137         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14138
14139         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14140         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14141
14142         { } /* end */
14143 };
14144
14145 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14146         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14147         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14148
14149         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14150
14151         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14152         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14153         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14154
14155         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14156         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14157         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14158
14159         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14160         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14161
14162         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14163         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14164
14165         { } /* end */
14166 };
14167
14168 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14169         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14170         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14171         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14172
14173         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14174
14175         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14176         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14177         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14178
14179         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14180         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14181         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14182
14183         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14184         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14185
14186         { } /* end */
14187 };
14188
14189 /* Pin assignment: Speaker=0x14, HP = 0x15,
14190  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14191  */
14192 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14193         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14194         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14195         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14196         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14197         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14198         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14199         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14200         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14201         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14202         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14203         { } /* end */
14204 };
14205
14206 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14207  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14208  */
14209 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14210         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14211         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14212         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14213         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14214         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14215         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14216         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14217         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14218
14219         { } /* end */
14220 };
14221
14222 /*
14223  * generic initialization of ADC, input mixers and output mixers
14224  */
14225 static struct hda_verb alc861vd_volume_init_verbs[] = {
14226         /*
14227          * Unmute ADC0 and set the default input to mic-in
14228          */
14229         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14230         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14231
14232         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14233          * the analog-loopback mixer widget
14234          */
14235         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14236         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14237         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14238         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14239         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14240         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14241
14242         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14243         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14244         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14245         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14246         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14247
14248         /*
14249          * Set up output mixers (0x02 - 0x05)
14250          */
14251         /* set vol=0 to output mixers */
14252         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14253         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14254         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14255         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14256
14257         /* set up input amps for analog loopback */
14258         /* Amp Indices: DAC = 0, mixer = 1 */
14259         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14260         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14261         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14262         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14263         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14264         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14265         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14266         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14267
14268         { }
14269 };
14270
14271 /*
14272  * 3-stack pin configuration:
14273  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14274  */
14275 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14276         /*
14277          * Set pin mode and muting
14278          */
14279         /* set front pin widgets 0x14 for output */
14280         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14281         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14282         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14283
14284         /* Mic (rear) pin: input vref at 80% */
14285         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14286         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14287         /* Front Mic pin: input vref at 80% */
14288         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14289         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14290         /* Line In pin: input */
14291         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14292         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14293         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14294         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14295         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14296         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14297         /* CD pin widget for input */
14298         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14299
14300         { }
14301 };
14302
14303 /*
14304  * 6-stack pin configuration:
14305  */
14306 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14307         /*
14308          * Set pin mode and muting
14309          */
14310         /* set front pin widgets 0x14 for output */
14311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14312         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14313         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14314
14315         /* Rear Pin: output 1 (0x0d) */
14316         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14317         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14318         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14319         /* CLFE Pin: output 2 (0x0e) */
14320         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14321         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14322         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14323         /* Side Pin: output 3 (0x0f) */
14324         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14325         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14326         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14327
14328         /* Mic (rear) pin: input vref at 80% */
14329         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14330         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14331         /* Front Mic pin: input vref at 80% */
14332         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14333         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14334         /* Line In pin: input */
14335         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14336         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14337         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14338         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14339         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14340         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14341         /* CD pin widget for input */
14342         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14343
14344         { }
14345 };
14346
14347 static struct hda_verb alc861vd_eapd_verbs[] = {
14348         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14349         { }
14350 };
14351
14352 static struct hda_verb alc660vd_eapd_verbs[] = {
14353         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14354         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14355         { }
14356 };
14357
14358 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14359         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14360         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14361         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14362         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14363         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14364         {}
14365 };
14366
14367 /* toggle speaker-output according to the hp-jack state */
14368 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14369 {
14370         unsigned int present;
14371         unsigned char bits;
14372
14373         present = snd_hda_codec_read(codec, 0x1b, 0,
14374                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14375         bits = present ? HDA_AMP_MUTE : 0;
14376         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14377                                  HDA_AMP_MUTE, bits);
14378 }
14379
14380 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14381 {
14382         unsigned int present;
14383         unsigned char bits;
14384
14385         present = snd_hda_codec_read(codec, 0x18, 0,
14386                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14387         bits = present ? HDA_AMP_MUTE : 0;
14388         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14389                                  HDA_AMP_MUTE, bits);
14390 }
14391
14392 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14393 {
14394         alc861vd_lenovo_hp_automute(codec);
14395         alc861vd_lenovo_mic_automute(codec);
14396 }
14397
14398 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14399                                         unsigned int res)
14400 {
14401         switch (res >> 26) {
14402         case ALC880_HP_EVENT:
14403                 alc861vd_lenovo_hp_automute(codec);
14404                 break;
14405         case ALC880_MIC_EVENT:
14406                 alc861vd_lenovo_mic_automute(codec);
14407                 break;
14408         }
14409 }
14410
14411 static struct hda_verb alc861vd_dallas_verbs[] = {
14412         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14413         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14414         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14415         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14416
14417         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14418         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14419         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14420         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14421         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14422         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14423         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14424         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14425
14426         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14427         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14428         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14429         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14430         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14431         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14432         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14433         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14434
14435         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14436         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14437         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14438         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14439         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14440         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14441         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14442         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14443
14444         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14445         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14446         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14448
14449         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14450         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14451         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14452
14453         { } /* end */
14454 };
14455
14456 /* toggle speaker-output according to the hp-jack state */
14457 static void alc861vd_dallas_automute(struct hda_codec *codec)
14458 {
14459         unsigned int present;
14460
14461         present = snd_hda_codec_read(codec, 0x15, 0,
14462                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14463         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14464                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14465 }
14466
14467 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14468 {
14469         if ((res >> 26) == ALC880_HP_EVENT)
14470                 alc861vd_dallas_automute(codec);
14471 }
14472
14473 #ifdef CONFIG_SND_HDA_POWER_SAVE
14474 #define alc861vd_loopbacks      alc880_loopbacks
14475 #endif
14476
14477 /* pcm configuration: identiacal with ALC880 */
14478 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14479 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14480 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14481 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14482
14483 /*
14484  * configuration and preset
14485  */
14486 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14487         [ALC660VD_3ST]          = "3stack-660",
14488         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14489         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14490         [ALC861VD_3ST]          = "3stack",
14491         [ALC861VD_3ST_DIG]      = "3stack-digout",
14492         [ALC861VD_6ST_DIG]      = "6stack-digout",
14493         [ALC861VD_LENOVO]       = "lenovo",
14494         [ALC861VD_DALLAS]       = "dallas",
14495         [ALC861VD_HP]           = "hp",
14496         [ALC861VD_AUTO]         = "auto",
14497 };
14498
14499 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14500         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14501         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14502         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14503         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14504         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14505         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14506         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14507         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14508         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14509         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14510         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14511         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14512         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14513         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14514         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14515         {}
14516 };
14517
14518 static struct alc_config_preset alc861vd_presets[] = {
14519         [ALC660VD_3ST] = {
14520                 .mixers = { alc861vd_3st_mixer },
14521                 .init_verbs = { alc861vd_volume_init_verbs,
14522                                  alc861vd_3stack_init_verbs },
14523                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14524                 .dac_nids = alc660vd_dac_nids,
14525                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14526                 .channel_mode = alc861vd_3stack_2ch_modes,
14527                 .input_mux = &alc861vd_capture_source,
14528         },
14529         [ALC660VD_3ST_DIG] = {
14530                 .mixers = { alc861vd_3st_mixer },
14531                 .init_verbs = { alc861vd_volume_init_verbs,
14532                                  alc861vd_3stack_init_verbs },
14533                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14534                 .dac_nids = alc660vd_dac_nids,
14535                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14536                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14537                 .channel_mode = alc861vd_3stack_2ch_modes,
14538                 .input_mux = &alc861vd_capture_source,
14539         },
14540         [ALC861VD_3ST] = {
14541                 .mixers = { alc861vd_3st_mixer },
14542                 .init_verbs = { alc861vd_volume_init_verbs,
14543                                  alc861vd_3stack_init_verbs },
14544                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14545                 .dac_nids = alc861vd_dac_nids,
14546                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14547                 .channel_mode = alc861vd_3stack_2ch_modes,
14548                 .input_mux = &alc861vd_capture_source,
14549         },
14550         [ALC861VD_3ST_DIG] = {
14551                 .mixers = { alc861vd_3st_mixer },
14552                 .init_verbs = { alc861vd_volume_init_verbs,
14553                                  alc861vd_3stack_init_verbs },
14554                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14555                 .dac_nids = alc861vd_dac_nids,
14556                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14557                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14558                 .channel_mode = alc861vd_3stack_2ch_modes,
14559                 .input_mux = &alc861vd_capture_source,
14560         },
14561         [ALC861VD_6ST_DIG] = {
14562                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14563                 .init_verbs = { alc861vd_volume_init_verbs,
14564                                 alc861vd_6stack_init_verbs },
14565                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14566                 .dac_nids = alc861vd_dac_nids,
14567                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14568                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14569                 .channel_mode = alc861vd_6stack_modes,
14570                 .input_mux = &alc861vd_capture_source,
14571         },
14572         [ALC861VD_LENOVO] = {
14573                 .mixers = { alc861vd_lenovo_mixer },
14574                 .init_verbs = { alc861vd_volume_init_verbs,
14575                                 alc861vd_3stack_init_verbs,
14576                                 alc861vd_eapd_verbs,
14577                                 alc861vd_lenovo_unsol_verbs },
14578                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14579                 .dac_nids = alc660vd_dac_nids,
14580                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14581                 .channel_mode = alc861vd_3stack_2ch_modes,
14582                 .input_mux = &alc861vd_capture_source,
14583                 .unsol_event = alc861vd_lenovo_unsol_event,
14584                 .init_hook = alc861vd_lenovo_automute,
14585         },
14586         [ALC861VD_DALLAS] = {
14587                 .mixers = { alc861vd_dallas_mixer },
14588                 .init_verbs = { alc861vd_dallas_verbs },
14589                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14590                 .dac_nids = alc861vd_dac_nids,
14591                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14592                 .channel_mode = alc861vd_3stack_2ch_modes,
14593                 .input_mux = &alc861vd_dallas_capture_source,
14594                 .unsol_event = alc861vd_dallas_unsol_event,
14595                 .init_hook = alc861vd_dallas_automute,
14596         },
14597         [ALC861VD_HP] = {
14598                 .mixers = { alc861vd_hp_mixer },
14599                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14600                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14601                 .dac_nids = alc861vd_dac_nids,
14602                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14603                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14604                 .channel_mode = alc861vd_3stack_2ch_modes,
14605                 .input_mux = &alc861vd_hp_capture_source,
14606                 .unsol_event = alc861vd_dallas_unsol_event,
14607                 .init_hook = alc861vd_dallas_automute,
14608         },
14609         [ALC660VD_ASUS_V1S] = {
14610                 .mixers = { alc861vd_lenovo_mixer },
14611                 .init_verbs = { alc861vd_volume_init_verbs,
14612                                 alc861vd_3stack_init_verbs,
14613                                 alc861vd_eapd_verbs,
14614                                 alc861vd_lenovo_unsol_verbs },
14615                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14616                 .dac_nids = alc660vd_dac_nids,
14617                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14618                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14619                 .channel_mode = alc861vd_3stack_2ch_modes,
14620                 .input_mux = &alc861vd_capture_source,
14621                 .unsol_event = alc861vd_lenovo_unsol_event,
14622                 .init_hook = alc861vd_lenovo_automute,
14623         },
14624 };
14625
14626 /*
14627  * BIOS auto configuration
14628  */
14629 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14630                                 hda_nid_t nid, int pin_type, int dac_idx)
14631 {
14632         alc_set_pin_output(codec, nid, pin_type);
14633 }
14634
14635 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14636 {
14637         struct alc_spec *spec = codec->spec;
14638         int i;
14639
14640         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14641         for (i = 0; i <= HDA_SIDE; i++) {
14642                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14643                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14644                 if (nid)
14645                         alc861vd_auto_set_output_and_unmute(codec, nid,
14646                                                             pin_type, i);
14647         }
14648 }
14649
14650
14651 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14652 {
14653         struct alc_spec *spec = codec->spec;
14654         hda_nid_t pin;
14655
14656         pin = spec->autocfg.hp_pins[0];
14657         if (pin) /* connect to front and  use dac 0 */
14658                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14659         pin = spec->autocfg.speaker_pins[0];
14660         if (pin)
14661                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14662 }
14663
14664 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14665 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14666
14667 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14668 {
14669         struct alc_spec *spec = codec->spec;
14670         int i;
14671
14672         for (i = 0; i < AUTO_PIN_LAST; i++) {
14673                 hda_nid_t nid = spec->autocfg.input_pins[i];
14674                 if (alc861vd_is_input_pin(nid)) {
14675                         snd_hda_codec_write(codec, nid, 0,
14676                                         AC_VERB_SET_PIN_WIDGET_CONTROL,
14677                                         i <= AUTO_PIN_FRONT_MIC ?
14678                                                         PIN_VREF80 : PIN_IN);
14679                         if (nid != ALC861VD_PIN_CD_NID)
14680                                 snd_hda_codec_write(codec, nid, 0,
14681                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14682                                                 AMP_OUT_MUTE);
14683                 }
14684         }
14685 }
14686
14687 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14688
14689 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14690 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14691
14692 /* add playback controls from the parsed DAC table */
14693 /* Based on ALC880 version. But ALC861VD has separate,
14694  * different NIDs for mute/unmute switch and volume control */
14695 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14696                                              const struct auto_pin_cfg *cfg)
14697 {
14698         char name[32];
14699         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14700         hda_nid_t nid_v, nid_s;
14701         int i, err;
14702
14703         for (i = 0; i < cfg->line_outs; i++) {
14704                 if (!spec->multiout.dac_nids[i])
14705                         continue;
14706                 nid_v = alc861vd_idx_to_mixer_vol(
14707                                 alc880_dac_to_idx(
14708                                         spec->multiout.dac_nids[i]));
14709                 nid_s = alc861vd_idx_to_mixer_switch(
14710                                 alc880_dac_to_idx(
14711                                         spec->multiout.dac_nids[i]));
14712
14713                 if (i == 2) {
14714                         /* Center/LFE */
14715                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14716                                           "Center Playback Volume",
14717                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14718                                                               HDA_OUTPUT));
14719                         if (err < 0)
14720                                 return err;
14721                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14722                                           "LFE Playback Volume",
14723                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14724                                                               HDA_OUTPUT));
14725                         if (err < 0)
14726                                 return err;
14727                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14728                                           "Center Playback Switch",
14729                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14730                                                               HDA_INPUT));
14731                         if (err < 0)
14732                                 return err;
14733                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14734                                           "LFE Playback Switch",
14735                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14736                                                               HDA_INPUT));
14737                         if (err < 0)
14738                                 return err;
14739                 } else {
14740                         sprintf(name, "%s Playback Volume", chname[i]);
14741                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14742                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14743                                                               HDA_OUTPUT));
14744                         if (err < 0)
14745                                 return err;
14746                         sprintf(name, "%s Playback Switch", chname[i]);
14747                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14748                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14749                                                               HDA_INPUT));
14750                         if (err < 0)
14751                                 return err;
14752                 }
14753         }
14754         return 0;
14755 }
14756
14757 /* add playback controls for speaker and HP outputs */
14758 /* Based on ALC880 version. But ALC861VD has separate,
14759  * different NIDs for mute/unmute switch and volume control */
14760 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14761                                         hda_nid_t pin, const char *pfx)
14762 {
14763         hda_nid_t nid_v, nid_s;
14764         int err;
14765         char name[32];
14766
14767         if (!pin)
14768                 return 0;
14769
14770         if (alc880_is_fixed_pin(pin)) {
14771                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14772                 /* specify the DAC as the extra output */
14773                 if (!spec->multiout.hp_nid)
14774                         spec->multiout.hp_nid = nid_v;
14775                 else
14776                         spec->multiout.extra_out_nid[0] = nid_v;
14777                 /* control HP volume/switch on the output mixer amp */
14778                 nid_v = alc861vd_idx_to_mixer_vol(
14779                                 alc880_fixed_pin_idx(pin));
14780                 nid_s = alc861vd_idx_to_mixer_switch(
14781                                 alc880_fixed_pin_idx(pin));
14782
14783                 sprintf(name, "%s Playback Volume", pfx);
14784                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14785                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
14786                 if (err < 0)
14787                         return err;
14788                 sprintf(name, "%s Playback Switch", pfx);
14789                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14790                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
14791                 if (err < 0)
14792                         return err;
14793         } else if (alc880_is_multi_pin(pin)) {
14794                 /* set manual connection */
14795                 /* we have only a switch on HP-out PIN */
14796                 sprintf(name, "%s Playback Switch", pfx);
14797                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
14798                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
14799                 if (err < 0)
14800                         return err;
14801         }
14802         return 0;
14803 }
14804
14805 /* parse the BIOS configuration and set up the alc_spec
14806  * return 1 if successful, 0 if the proper config is not found,
14807  * or a negative error code
14808  * Based on ALC880 version - had to change it to override
14809  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
14810 static int alc861vd_parse_auto_config(struct hda_codec *codec)
14811 {
14812         struct alc_spec *spec = codec->spec;
14813         int err;
14814         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
14815
14816         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14817                                            alc861vd_ignore);
14818         if (err < 0)
14819                 return err;
14820         if (!spec->autocfg.line_outs)
14821                 return 0; /* can't find valid BIOS pin config */
14822
14823         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
14824         if (err < 0)
14825                 return err;
14826         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
14827         if (err < 0)
14828                 return err;
14829         err = alc861vd_auto_create_extra_out(spec,
14830                                              spec->autocfg.speaker_pins[0],
14831                                              "Speaker");
14832         if (err < 0)
14833                 return err;
14834         err = alc861vd_auto_create_extra_out(spec,
14835                                              spec->autocfg.hp_pins[0],
14836                                              "Headphone");
14837         if (err < 0)
14838                 return err;
14839         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
14840         if (err < 0)
14841                 return err;
14842
14843         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14844
14845         if (spec->autocfg.dig_outs)
14846                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
14847
14848         if (spec->kctls.list)
14849                 add_mixer(spec, spec->kctls.list);
14850
14851         add_verb(spec, alc861vd_volume_init_verbs);
14852
14853         spec->num_mux_defs = 1;
14854         spec->input_mux = &spec->private_imux[0];
14855
14856         err = alc_auto_add_mic_boost(codec);
14857         if (err < 0)
14858                 return err;
14859
14860         return 1;
14861 }
14862
14863 /* additional initialization for auto-configuration model */
14864 static void alc861vd_auto_init(struct hda_codec *codec)
14865 {
14866         struct alc_spec *spec = codec->spec;
14867         alc861vd_auto_init_multi_out(codec);
14868         alc861vd_auto_init_hp_out(codec);
14869         alc861vd_auto_init_analog_input(codec);
14870         alc861vd_auto_init_input_src(codec);
14871         if (spec->unsol_event)
14872                 alc_inithook(codec);
14873 }
14874
14875 static int patch_alc861vd(struct hda_codec *codec)
14876 {
14877         struct alc_spec *spec;
14878         int err, board_config;
14879
14880         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14881         if (spec == NULL)
14882                 return -ENOMEM;
14883
14884         codec->spec = spec;
14885
14886         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
14887                                                   alc861vd_models,
14888                                                   alc861vd_cfg_tbl);
14889
14890         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
14891                 printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
14892                         "ALC861VD, trying auto-probe from BIOS...\n");
14893                 board_config = ALC861VD_AUTO;
14894         }
14895
14896         if (board_config == ALC861VD_AUTO) {
14897                 /* automatic parse from the BIOS config */
14898                 err = alc861vd_parse_auto_config(codec);
14899                 if (err < 0) {
14900                         alc_free(codec);
14901                         return err;
14902                 } else if (!err) {
14903                         printk(KERN_INFO
14904                                "hda_codec: Cannot set up configuration "
14905                                "from BIOS.  Using base mode...\n");
14906                         board_config = ALC861VD_3ST;
14907                 }
14908         }
14909
14910         err = snd_hda_attach_beep_device(codec, 0x23);
14911         if (err < 0) {
14912                 alc_free(codec);
14913                 return err;
14914         }
14915
14916         if (board_config != ALC861VD_AUTO)
14917                 setup_preset(spec, &alc861vd_presets[board_config]);
14918
14919         if (codec->vendor_id == 0x10ec0660) {
14920                 spec->stream_name_analog = "ALC660-VD Analog";
14921                 spec->stream_name_digital = "ALC660-VD Digital";
14922                 /* always turn on EAPD */
14923                 add_verb(spec, alc660vd_eapd_verbs);
14924         } else {
14925                 spec->stream_name_analog = "ALC861VD Analog";
14926                 spec->stream_name_digital = "ALC861VD Digital";
14927         }
14928
14929         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
14930         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
14931
14932         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
14933         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
14934
14935         spec->adc_nids = alc861vd_adc_nids;
14936         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
14937         spec->capsrc_nids = alc861vd_capsrc_nids;
14938         spec->capture_style = CAPT_MIX;
14939
14940         set_capture_mixer(spec);
14941         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
14942
14943         spec->vmaster_nid = 0x02;
14944
14945         codec->patch_ops = alc_patch_ops;
14946
14947         if (board_config == ALC861VD_AUTO)
14948                 spec->init_hook = alc861vd_auto_init;
14949 #ifdef CONFIG_SND_HDA_POWER_SAVE
14950         if (!spec->loopback.amplist)
14951                 spec->loopback.amplist = alc861vd_loopbacks;
14952 #endif
14953         codec->proc_widget_hook = print_realtek_coef;
14954
14955         return 0;
14956 }
14957
14958 /*
14959  * ALC662 support
14960  *
14961  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
14962  * configuration.  Each pin widget can choose any input DACs and a mixer.
14963  * Each ADC is connected from a mixer of all inputs.  This makes possible
14964  * 6-channel independent captures.
14965  *
14966  * In addition, an independent DAC for the multi-playback (not used in this
14967  * driver yet).
14968  */
14969 #define ALC662_DIGOUT_NID       0x06
14970 #define ALC662_DIGIN_NID        0x0a
14971
14972 static hda_nid_t alc662_dac_nids[4] = {
14973         /* front, rear, clfe, rear_surr */
14974         0x02, 0x03, 0x04
14975 };
14976
14977 static hda_nid_t alc662_adc_nids[1] = {
14978         /* ADC1-2 */
14979         0x09,
14980 };
14981
14982 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
14983
14984 /* input MUX */
14985 /* FIXME: should be a matrix-type input source selection */
14986 static struct hda_input_mux alc662_capture_source = {
14987         .num_items = 4,
14988         .items = {
14989                 { "Mic", 0x0 },
14990                 { "Front Mic", 0x1 },
14991                 { "Line", 0x2 },
14992                 { "CD", 0x4 },
14993         },
14994 };
14995
14996 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
14997         .num_items = 2,
14998         .items = {
14999                 { "Mic", 0x1 },
15000                 { "Line", 0x2 },
15001         },
15002 };
15003
15004 static struct hda_input_mux alc662_eeepc_capture_source = {
15005         .num_items = 2,
15006         .items = {
15007                 { "i-Mic", 0x1 },
15008                 { "e-Mic", 0x0 },
15009         },
15010 };
15011
15012 static struct hda_input_mux alc663_capture_source = {
15013         .num_items = 3,
15014         .items = {
15015                 { "Mic", 0x0 },
15016                 { "Front Mic", 0x1 },
15017                 { "Line", 0x2 },
15018         },
15019 };
15020
15021 static struct hda_input_mux alc663_m51va_capture_source = {
15022         .num_items = 2,
15023         .items = {
15024                 { "Ext-Mic", 0x0 },
15025                 { "D-Mic", 0x9 },
15026         },
15027 };
15028
15029 /*
15030  * 2ch mode
15031  */
15032 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15033         { 2, NULL }
15034 };
15035
15036 /*
15037  * 2ch mode
15038  */
15039 static struct hda_verb alc662_3ST_ch2_init[] = {
15040         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15041         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15042         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15043         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15044         { } /* end */
15045 };
15046
15047 /*
15048  * 6ch mode
15049  */
15050 static struct hda_verb alc662_3ST_ch6_init[] = {
15051         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15052         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15053         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15054         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15055         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15056         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15057         { } /* end */
15058 };
15059
15060 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15061         { 2, alc662_3ST_ch2_init },
15062         { 6, alc662_3ST_ch6_init },
15063 };
15064
15065 /*
15066  * 2ch mode
15067  */
15068 static struct hda_verb alc662_sixstack_ch6_init[] = {
15069         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15070         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15071         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15072         { } /* end */
15073 };
15074
15075 /*
15076  * 6ch mode
15077  */
15078 static struct hda_verb alc662_sixstack_ch8_init[] = {
15079         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15080         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15081         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15082         { } /* end */
15083 };
15084
15085 static struct hda_channel_mode alc662_5stack_modes[2] = {
15086         { 2, alc662_sixstack_ch6_init },
15087         { 6, alc662_sixstack_ch8_init },
15088 };
15089
15090 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15091  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15092  */
15093
15094 static struct snd_kcontrol_new alc662_base_mixer[] = {
15095         /* output mixer control */
15096         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15097         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15098         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15099         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15100         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15101         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15102         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15103         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15104         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15105
15106         /*Input mixer control */
15107         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15108         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15109         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15110         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15111         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15112         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15113         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15114         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15115         { } /* end */
15116 };
15117
15118 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15119         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15120         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15121         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15122         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15123         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15124         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15125         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15126         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15127         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15128         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15129         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15130         { } /* end */
15131 };
15132
15133 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15134         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15135         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15136         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15137         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15138         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15139         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15140         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15141         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15142         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15143         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15144         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15145         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15146         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15147         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15148         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15149         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15150         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15151         { } /* end */
15152 };
15153
15154 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15155         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15156         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15157         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15158         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15159         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15160         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15161         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15162         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15163         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15164         { } /* end */
15165 };
15166
15167 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15168         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15169
15170         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15171         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15172
15173         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15174         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15175         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15176
15177         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15178         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15179         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15180         { } /* end */
15181 };
15182
15183 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15184         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15185         HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15186         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15187         HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15188         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15189         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15190         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15191         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15192         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15193         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15194         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15195         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15196         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15197         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15198         { } /* end */
15199 };
15200
15201 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15202         .ops = &snd_hda_bind_vol,
15203         .values = {
15204                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15205                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15206                 0
15207         },
15208 };
15209
15210 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15211         .ops = &snd_hda_bind_sw,
15212         .values = {
15213                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15214                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15215                 0
15216         },
15217 };
15218
15219 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15220         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15221         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15222         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15223         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15224         { } /* end */
15225 };
15226
15227 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15228         .ops = &snd_hda_bind_sw,
15229         .values = {
15230                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15231                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15232                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15233                 0
15234         },
15235 };
15236
15237 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15238         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15239         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15241         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15242         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15243         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15244
15245         { } /* end */
15246 };
15247
15248 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15249         .ops = &snd_hda_bind_sw,
15250         .values = {
15251                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15252                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15253                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15254                 0
15255         },
15256 };
15257
15258 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15259         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15260         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15261         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15262         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15263         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15264         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15265         { } /* end */
15266 };
15267
15268 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15269         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15270         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15271         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15273         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15274         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15275         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15276         { } /* end */
15277 };
15278
15279 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15280         .ops = &snd_hda_bind_vol,
15281         .values = {
15282                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15283                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15284                 0
15285         },
15286 };
15287
15288 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15289         .ops = &snd_hda_bind_sw,
15290         .values = {
15291                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15292                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15293                 0
15294         },
15295 };
15296
15297 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15298         HDA_BIND_VOL("Master Playback Volume",
15299                                 &alc663_asus_two_bind_master_vol),
15300         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15301         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15302         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15303         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15304         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15305         { } /* end */
15306 };
15307
15308 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15309         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15310         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15311         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15312         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15313         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15314         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15315         { } /* end */
15316 };
15317
15318 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15319         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15320         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15321         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15322         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15323         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15324
15325         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15326         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15327         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15328         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15329         { } /* end */
15330 };
15331
15332 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15333         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15334         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15335         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15336
15337         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15338         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15339         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15340         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15341         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15342         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15343         { } /* end */
15344 };
15345
15346 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15347         {
15348                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15349                 .name = "Channel Mode",
15350                 .info = alc_ch_mode_info,
15351                 .get = alc_ch_mode_get,
15352                 .put = alc_ch_mode_put,
15353         },
15354         { } /* end */
15355 };
15356
15357 static struct hda_verb alc662_init_verbs[] = {
15358         /* ADC: mute amp left and right */
15359         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15360         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15361         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15362
15363         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15364         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15365         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15366         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15367         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15368
15369         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15370         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15371         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15372         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15373         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15374         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15375
15376         /* Front Pin: output 0 (0x0c) */
15377         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15378         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15379
15380         /* Rear Pin: output 1 (0x0d) */
15381         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15382         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15383
15384         /* CLFE Pin: output 2 (0x0e) */
15385         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15386         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15387
15388         /* Mic (rear) pin: input vref at 80% */
15389         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15390         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15391         /* Front Mic pin: input vref at 80% */
15392         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15393         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15394         /* Line In pin: input */
15395         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15396         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15397         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15398         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15399         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15400         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15401         /* CD pin widget for input */
15402         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15403
15404         /* FIXME: use matrix-type input source selection */
15405         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15406         /* Input mixer */
15407         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15408         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15409         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15410         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15411
15412         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15413         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15414         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15415         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15416
15417         /* always trun on EAPD */
15418         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15419         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15420
15421         { }
15422 };
15423
15424 static struct hda_verb alc662_sue_init_verbs[] = {
15425         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15426         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15427         {}
15428 };
15429
15430 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15431         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15432         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15433         {}
15434 };
15435
15436 /* Set Unsolicited Event*/
15437 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15438         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15439         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15440         {}
15441 };
15442
15443 /*
15444  * generic initialization of ADC, input mixers and output mixers
15445  */
15446 static struct hda_verb alc662_auto_init_verbs[] = {
15447         /*
15448          * Unmute ADC and set the default input to mic-in
15449          */
15450         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15451         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15452
15453         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15454          * mixer widget
15455          * Note: PASD motherboards uses the Line In 2 as the input for front
15456          * panel mic (mic 2)
15457          */
15458         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15459         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15460         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15461         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15462         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15463         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15464
15465         /*
15466          * Set up output mixers (0x0c - 0x0f)
15467          */
15468         /* set vol=0 to output mixers */
15469         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15470         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15471         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15472
15473         /* set up input amps for analog loopback */
15474         /* Amp Indices: DAC = 0, mixer = 1 */
15475         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15476         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15478         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15479         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15480         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15481
15482
15483         /* FIXME: use matrix-type input source selection */
15484         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15485         /* Input mixer */
15486         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15487         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15488         { }
15489 };
15490
15491 /* additional verbs for ALC663 */
15492 static struct hda_verb alc663_auto_init_verbs[] = {
15493         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15494         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15495         { }
15496 };
15497
15498 static struct hda_verb alc663_m51va_init_verbs[] = {
15499         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15500         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15501         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15502         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15503         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15504         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15505         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15506         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15507         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15508         {}
15509 };
15510
15511 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15512         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15513         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15514         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15515         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15516         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15517         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15518         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15519         {}
15520 };
15521
15522 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15523         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15524         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15525         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15526         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15527         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15528         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15529         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15530         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15531         {}
15532 };
15533
15534 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15535         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15536         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15537         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15538         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15539         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15540         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15541         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15542         {}
15543 };
15544
15545 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15546         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15547         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15548         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15549         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15550         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15551         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15552         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15553         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15554         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15555         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15556         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15557         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15558         {}
15559 };
15560
15561 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15562         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15563         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15564         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15565         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15566         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15567         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15568         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15569         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15570         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15571         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15572         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15573         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15574         {}
15575 };
15576
15577 static struct hda_verb alc663_g71v_init_verbs[] = {
15578         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15579         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15580         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15581
15582         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15583         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15584         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15585
15586         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15587         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15588         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15589         {}
15590 };
15591
15592 static struct hda_verb alc663_g50v_init_verbs[] = {
15593         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15594         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15595         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15596
15597         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15598         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15599         {}
15600 };
15601
15602 static struct hda_verb alc662_ecs_init_verbs[] = {
15603         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15604         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15605         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15606         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15607         {}
15608 };
15609
15610 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15611         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15612         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15613         { } /* end */
15614 };
15615
15616 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15617 {
15618         unsigned int present;
15619         unsigned char bits;
15620
15621         present = snd_hda_codec_read(codec, 0x14, 0,
15622                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15623         bits = present ? HDA_AMP_MUTE : 0;
15624         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15625                                  HDA_AMP_MUTE, bits);
15626 }
15627
15628 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15629 {
15630         unsigned int present;
15631         unsigned char bits;
15632
15633         present = snd_hda_codec_read(codec, 0x1b, 0,
15634                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15635         bits = present ? HDA_AMP_MUTE : 0;
15636         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15637                                  HDA_AMP_MUTE, bits);
15638         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15639                                  HDA_AMP_MUTE, bits);
15640 }
15641
15642 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15643                                            unsigned int res)
15644 {
15645         if ((res >> 26) == ALC880_HP_EVENT)
15646                 alc662_lenovo_101e_all_automute(codec);
15647         if ((res >> 26) == ALC880_FRONT_EVENT)
15648                 alc662_lenovo_101e_ispeaker_automute(codec);
15649 }
15650
15651 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15652 {
15653         unsigned int present;
15654
15655         present = snd_hda_codec_read(codec, 0x18, 0,
15656                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15657         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15658                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15659         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15660                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15661         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15662                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15663         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15664                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15665 }
15666
15667 /* unsolicited event for HP jack sensing */
15668 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15669                                      unsigned int res)
15670 {
15671         if ((res >> 26) == ALC880_HP_EVENT)
15672                 alc262_hippo1_automute( codec );
15673
15674         if ((res >> 26) == ALC880_MIC_EVENT)
15675                 alc662_eeepc_mic_automute(codec);
15676 }
15677
15678 static void alc662_eeepc_inithook(struct hda_codec *codec)
15679 {
15680         alc262_hippo1_automute( codec );
15681         alc662_eeepc_mic_automute(codec);
15682 }
15683
15684 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15685 {
15686         unsigned int mute;
15687         unsigned int present;
15688
15689         snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15690         present = snd_hda_codec_read(codec, 0x14, 0,
15691                                      AC_VERB_GET_PIN_SENSE, 0);
15692         present = (present & 0x80000000) != 0;
15693         if (present) {
15694                 /* mute internal speaker */
15695                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15696                                         HDA_AMP_MUTE, HDA_AMP_MUTE);
15697         } else {
15698                 /* unmute internal speaker if necessary */
15699                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15700                 snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15701                                         HDA_AMP_MUTE, mute);
15702         }
15703 }
15704
15705 /* unsolicited event for HP jack sensing */
15706 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15707                                           unsigned int res)
15708 {
15709         if ((res >> 26) == ALC880_HP_EVENT)
15710                 alc662_eeepc_ep20_automute(codec);
15711 }
15712
15713 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15714 {
15715         alc662_eeepc_ep20_automute(codec);
15716 }
15717
15718 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15719 {
15720         unsigned int present;
15721         unsigned char bits;
15722
15723         present = snd_hda_codec_read(codec, 0x21, 0,
15724                         AC_VERB_GET_PIN_SENSE, 0)
15725                         & AC_PINSENSE_PRESENCE;
15726         bits = present ? HDA_AMP_MUTE : 0;
15727         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15728                                 AMP_IN_MUTE(0), bits);
15729         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15730                                 AMP_IN_MUTE(0), bits);
15731 }
15732
15733 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15734 {
15735         unsigned int present;
15736         unsigned char bits;
15737
15738         present = snd_hda_codec_read(codec, 0x21, 0,
15739                         AC_VERB_GET_PIN_SENSE, 0)
15740                         & AC_PINSENSE_PRESENCE;
15741         bits = present ? HDA_AMP_MUTE : 0;
15742         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15743                                 AMP_IN_MUTE(0), bits);
15744         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15745                                 AMP_IN_MUTE(0), bits);
15746         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15747                                 AMP_IN_MUTE(0), bits);
15748         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15749                                 AMP_IN_MUTE(0), bits);
15750 }
15751
15752 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15753 {
15754         unsigned int present;
15755         unsigned char bits;
15756
15757         present = snd_hda_codec_read(codec, 0x15, 0,
15758                         AC_VERB_GET_PIN_SENSE, 0)
15759                         & AC_PINSENSE_PRESENCE;
15760         bits = present ? HDA_AMP_MUTE : 0;
15761         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15762                                 AMP_IN_MUTE(0), bits);
15763         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15764                                 AMP_IN_MUTE(0), bits);
15765         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15766                                 AMP_IN_MUTE(0), bits);
15767         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15768                                 AMP_IN_MUTE(0), bits);
15769 }
15770
15771 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
15772 {
15773         unsigned int present;
15774         unsigned char bits;
15775
15776         present = snd_hda_codec_read(codec, 0x1b, 0,
15777                         AC_VERB_GET_PIN_SENSE, 0)
15778                         & AC_PINSENSE_PRESENCE;
15779         bits = present ? 0 : PIN_OUT;
15780         snd_hda_codec_write(codec, 0x14, 0,
15781                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
15782 }
15783
15784 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
15785 {
15786         unsigned int present1, present2;
15787
15788         present1 = snd_hda_codec_read(codec, 0x21, 0,
15789                         AC_VERB_GET_PIN_SENSE, 0)
15790                         & AC_PINSENSE_PRESENCE;
15791         present2 = snd_hda_codec_read(codec, 0x15, 0,
15792                         AC_VERB_GET_PIN_SENSE, 0)
15793                         & AC_PINSENSE_PRESENCE;
15794
15795         if (present1 || present2) {
15796                 snd_hda_codec_write_cache(codec, 0x14, 0,
15797                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
15798         } else {
15799                 snd_hda_codec_write_cache(codec, 0x14, 0,
15800                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
15801         }
15802 }
15803
15804 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
15805 {
15806         unsigned int present1, present2;
15807
15808         present1 = snd_hda_codec_read(codec, 0x1b, 0,
15809                                 AC_VERB_GET_PIN_SENSE, 0)
15810                                 & AC_PINSENSE_PRESENCE;
15811         present2 = snd_hda_codec_read(codec, 0x15, 0,
15812                                 AC_VERB_GET_PIN_SENSE, 0)
15813                                 & AC_PINSENSE_PRESENCE;
15814
15815         if (present1 || present2) {
15816                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15817                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15818                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15819                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
15820         } else {
15821                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15822                                 AMP_IN_MUTE(0), 0);
15823                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15824                                 AMP_IN_MUTE(0), 0);
15825         }
15826 }
15827
15828 static void alc663_m51va_mic_automute(struct hda_codec *codec)
15829 {
15830         unsigned int present;
15831
15832         present = snd_hda_codec_read(codec, 0x18, 0,
15833                         AC_VERB_GET_PIN_SENSE, 0)
15834                         & AC_PINSENSE_PRESENCE;
15835         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15836                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15837         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15838                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15839         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15840                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15841         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15842                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
15843 }
15844
15845 static void alc663_m51va_unsol_event(struct hda_codec *codec,
15846                                            unsigned int res)
15847 {
15848         switch (res >> 26) {
15849         case ALC880_HP_EVENT:
15850                 alc663_m51va_speaker_automute(codec);
15851                 break;
15852         case ALC880_MIC_EVENT:
15853                 alc663_m51va_mic_automute(codec);
15854                 break;
15855         }
15856 }
15857
15858 static void alc663_m51va_inithook(struct hda_codec *codec)
15859 {
15860         alc663_m51va_speaker_automute(codec);
15861         alc663_m51va_mic_automute(codec);
15862 }
15863
15864 /* ***************** Mode1 ******************************/
15865 static void alc663_mode1_unsol_event(struct hda_codec *codec,
15866                                            unsigned int res)
15867 {
15868         switch (res >> 26) {
15869         case ALC880_HP_EVENT:
15870                 alc663_m51va_speaker_automute(codec);
15871                 break;
15872         case ALC880_MIC_EVENT:
15873                 alc662_eeepc_mic_automute(codec);
15874                 break;
15875         }
15876 }
15877
15878 static void alc663_mode1_inithook(struct hda_codec *codec)
15879 {
15880         alc663_m51va_speaker_automute(codec);
15881         alc662_eeepc_mic_automute(codec);
15882 }
15883 /* ***************** Mode2 ******************************/
15884 static void alc662_mode2_unsol_event(struct hda_codec *codec,
15885                                            unsigned int res)
15886 {
15887         switch (res >> 26) {
15888         case ALC880_HP_EVENT:
15889                 alc662_f5z_speaker_automute(codec);
15890                 break;
15891         case ALC880_MIC_EVENT:
15892                 alc662_eeepc_mic_automute(codec);
15893                 break;
15894         }
15895 }
15896
15897 static void alc662_mode2_inithook(struct hda_codec *codec)
15898 {
15899         alc662_f5z_speaker_automute(codec);
15900         alc662_eeepc_mic_automute(codec);
15901 }
15902 /* ***************** Mode3 ******************************/
15903 static void alc663_mode3_unsol_event(struct hda_codec *codec,
15904                                            unsigned int res)
15905 {
15906         switch (res >> 26) {
15907         case ALC880_HP_EVENT:
15908                 alc663_two_hp_m1_speaker_automute(codec);
15909                 break;
15910         case ALC880_MIC_EVENT:
15911                 alc662_eeepc_mic_automute(codec);
15912                 break;
15913         }
15914 }
15915
15916 static void alc663_mode3_inithook(struct hda_codec *codec)
15917 {
15918         alc663_two_hp_m1_speaker_automute(codec);
15919         alc662_eeepc_mic_automute(codec);
15920 }
15921 /* ***************** Mode4 ******************************/
15922 static void alc663_mode4_unsol_event(struct hda_codec *codec,
15923                                            unsigned int res)
15924 {
15925         switch (res >> 26) {
15926         case ALC880_HP_EVENT:
15927                 alc663_21jd_two_speaker_automute(codec);
15928                 break;
15929         case ALC880_MIC_EVENT:
15930                 alc662_eeepc_mic_automute(codec);
15931                 break;
15932         }
15933 }
15934
15935 static void alc663_mode4_inithook(struct hda_codec *codec)
15936 {
15937         alc663_21jd_two_speaker_automute(codec);
15938         alc662_eeepc_mic_automute(codec);
15939 }
15940 /* ***************** Mode5 ******************************/
15941 static void alc663_mode5_unsol_event(struct hda_codec *codec,
15942                                            unsigned int res)
15943 {
15944         switch (res >> 26) {
15945         case ALC880_HP_EVENT:
15946                 alc663_15jd_two_speaker_automute(codec);
15947                 break;
15948         case ALC880_MIC_EVENT:
15949                 alc662_eeepc_mic_automute(codec);
15950                 break;
15951         }
15952 }
15953
15954 static void alc663_mode5_inithook(struct hda_codec *codec)
15955 {
15956         alc663_15jd_two_speaker_automute(codec);
15957         alc662_eeepc_mic_automute(codec);
15958 }
15959 /* ***************** Mode6 ******************************/
15960 static void alc663_mode6_unsol_event(struct hda_codec *codec,
15961                                            unsigned int res)
15962 {
15963         switch (res >> 26) {
15964         case ALC880_HP_EVENT:
15965                 alc663_two_hp_m2_speaker_automute(codec);
15966                 break;
15967         case ALC880_MIC_EVENT:
15968                 alc662_eeepc_mic_automute(codec);
15969                 break;
15970         }
15971 }
15972
15973 static void alc663_mode6_inithook(struct hda_codec *codec)
15974 {
15975         alc663_two_hp_m2_speaker_automute(codec);
15976         alc662_eeepc_mic_automute(codec);
15977 }
15978
15979 static void alc663_g71v_hp_automute(struct hda_codec *codec)
15980 {
15981         unsigned int present;
15982         unsigned char bits;
15983
15984         present = snd_hda_codec_read(codec, 0x21, 0,
15985                                      AC_VERB_GET_PIN_SENSE, 0)
15986                 & AC_PINSENSE_PRESENCE;
15987         bits = present ? HDA_AMP_MUTE : 0;
15988         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15989                                  HDA_AMP_MUTE, bits);
15990         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15991                                  HDA_AMP_MUTE, bits);
15992 }
15993
15994 static void alc663_g71v_front_automute(struct hda_codec *codec)
15995 {
15996         unsigned int present;
15997         unsigned char bits;
15998
15999         present = snd_hda_codec_read(codec, 0x15, 0,
16000                                      AC_VERB_GET_PIN_SENSE, 0)
16001                 & AC_PINSENSE_PRESENCE;
16002         bits = present ? HDA_AMP_MUTE : 0;
16003         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16004                                  HDA_AMP_MUTE, bits);
16005 }
16006
16007 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16008                                            unsigned int res)
16009 {
16010         switch (res >> 26) {
16011         case ALC880_HP_EVENT:
16012                 alc663_g71v_hp_automute(codec);
16013                 break;
16014         case ALC880_FRONT_EVENT:
16015                 alc663_g71v_front_automute(codec);
16016                 break;
16017         case ALC880_MIC_EVENT:
16018                 alc662_eeepc_mic_automute(codec);
16019                 break;
16020         }
16021 }
16022
16023 static void alc663_g71v_inithook(struct hda_codec *codec)
16024 {
16025         alc663_g71v_front_automute(codec);
16026         alc663_g71v_hp_automute(codec);
16027         alc662_eeepc_mic_automute(codec);
16028 }
16029
16030 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16031                                            unsigned int res)
16032 {
16033         switch (res >> 26) {
16034         case ALC880_HP_EVENT:
16035                 alc663_m51va_speaker_automute(codec);
16036                 break;
16037         case ALC880_MIC_EVENT:
16038                 alc662_eeepc_mic_automute(codec);
16039                 break;
16040         }
16041 }
16042
16043 static void alc663_g50v_inithook(struct hda_codec *codec)
16044 {
16045         alc663_m51va_speaker_automute(codec);
16046         alc662_eeepc_mic_automute(codec);
16047 }
16048
16049 /* bind hp and internal speaker mute (with plug check) */
16050 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16051                                      struct snd_ctl_elem_value *ucontrol)
16052 {
16053         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16054         long *valp = ucontrol->value.integer.value;
16055         int change;
16056
16057         change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16058                                           HDA_AMP_MUTE,
16059                                           valp[0] ? 0 : HDA_AMP_MUTE);
16060         change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16061                                            HDA_AMP_MUTE,
16062                                            valp[1] ? 0 : HDA_AMP_MUTE);
16063         if (change)
16064                 alc262_hippo1_automute(codec);
16065         return change;
16066 }
16067
16068 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16069         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16070         {
16071                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16072                 .name = "Master Playback Switch",
16073                 .info = snd_hda_mixer_amp_switch_info,
16074                 .get = snd_hda_mixer_amp_switch_get,
16075                 .put = alc662_ecs_master_sw_put,
16076                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16077         },
16078
16079         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16080         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16081         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16082
16083         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16084         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16085         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16086         { } /* end */
16087 };
16088
16089 #ifdef CONFIG_SND_HDA_POWER_SAVE
16090 #define alc662_loopbacks        alc880_loopbacks
16091 #endif
16092
16093
16094 /* pcm configuration: identiacal with ALC880 */
16095 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16096 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16097 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16098 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16099
16100 /*
16101  * configuration and preset
16102  */
16103 static const char *alc662_models[ALC662_MODEL_LAST] = {
16104         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16105         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16106         [ALC662_3ST_6ch]        = "3stack-6ch",
16107         [ALC662_5ST_DIG]        = "6stack-dig",
16108         [ALC662_LENOVO_101E]    = "lenovo-101e",
16109         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16110         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16111         [ALC662_ECS] = "ecs",
16112         [ALC663_ASUS_M51VA] = "m51va",
16113         [ALC663_ASUS_G71V] = "g71v",
16114         [ALC663_ASUS_H13] = "h13",
16115         [ALC663_ASUS_G50V] = "g50v",
16116         [ALC663_ASUS_MODE1] = "asus-mode1",
16117         [ALC662_ASUS_MODE2] = "asus-mode2",
16118         [ALC663_ASUS_MODE3] = "asus-mode3",
16119         [ALC663_ASUS_MODE4] = "asus-mode4",
16120         [ALC663_ASUS_MODE5] = "asus-mode5",
16121         [ALC663_ASUS_MODE6] = "asus-mode6",
16122         [ALC662_AUTO]           = "auto",
16123 };
16124
16125 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16126         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16127         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16128         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16129         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16130         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16131         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16132         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16133         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16134         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16135         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16136         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16137         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16138         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16139         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16140         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16141         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16142         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16143         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16144         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16145         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16146         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16147         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16148         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16149         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16150         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16151         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16152         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16153         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16154         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16155         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16156         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16157         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16158         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16159         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16160         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16161         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16162         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16163         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16164         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16165         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16166                       ALC662_3ST_6ch_DIG),
16167         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16168                       ALC662_3ST_6ch_DIG),
16169         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16170         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16171         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16172                                         ALC662_3ST_6ch_DIG),
16173         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16174                            ALC663_ASUS_H13),
16175         {}
16176 };
16177
16178 static struct alc_config_preset alc662_presets[] = {
16179         [ALC662_3ST_2ch_DIG] = {
16180                 .mixers = { alc662_3ST_2ch_mixer },
16181                 .init_verbs = { alc662_init_verbs },
16182                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16183                 .dac_nids = alc662_dac_nids,
16184                 .dig_out_nid = ALC662_DIGOUT_NID,
16185                 .dig_in_nid = ALC662_DIGIN_NID,
16186                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16187                 .channel_mode = alc662_3ST_2ch_modes,
16188                 .input_mux = &alc662_capture_source,
16189         },
16190         [ALC662_3ST_6ch_DIG] = {
16191                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16192                 .init_verbs = { alc662_init_verbs },
16193                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16194                 .dac_nids = alc662_dac_nids,
16195                 .dig_out_nid = ALC662_DIGOUT_NID,
16196                 .dig_in_nid = ALC662_DIGIN_NID,
16197                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16198                 .channel_mode = alc662_3ST_6ch_modes,
16199                 .need_dac_fix = 1,
16200                 .input_mux = &alc662_capture_source,
16201         },
16202         [ALC662_3ST_6ch] = {
16203                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16204                 .init_verbs = { alc662_init_verbs },
16205                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16206                 .dac_nids = alc662_dac_nids,
16207                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16208                 .channel_mode = alc662_3ST_6ch_modes,
16209                 .need_dac_fix = 1,
16210                 .input_mux = &alc662_capture_source,
16211         },
16212         [ALC662_5ST_DIG] = {
16213                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16214                 .init_verbs = { alc662_init_verbs },
16215                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16216                 .dac_nids = alc662_dac_nids,
16217                 .dig_out_nid = ALC662_DIGOUT_NID,
16218                 .dig_in_nid = ALC662_DIGIN_NID,
16219                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16220                 .channel_mode = alc662_5stack_modes,
16221                 .input_mux = &alc662_capture_source,
16222         },
16223         [ALC662_LENOVO_101E] = {
16224                 .mixers = { alc662_lenovo_101e_mixer },
16225                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16226                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16227                 .dac_nids = alc662_dac_nids,
16228                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16229                 .channel_mode = alc662_3ST_2ch_modes,
16230                 .input_mux = &alc662_lenovo_101e_capture_source,
16231                 .unsol_event = alc662_lenovo_101e_unsol_event,
16232                 .init_hook = alc662_lenovo_101e_all_automute,
16233         },
16234         [ALC662_ASUS_EEEPC_P701] = {
16235                 .mixers = { alc662_eeepc_p701_mixer },
16236                 .init_verbs = { alc662_init_verbs,
16237                                 alc662_eeepc_sue_init_verbs },
16238                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16239                 .dac_nids = alc662_dac_nids,
16240                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16241                 .channel_mode = alc662_3ST_2ch_modes,
16242                 .input_mux = &alc662_eeepc_capture_source,
16243                 .unsol_event = alc662_eeepc_unsol_event,
16244                 .init_hook = alc662_eeepc_inithook,
16245         },
16246         [ALC662_ASUS_EEEPC_EP20] = {
16247                 .mixers = { alc662_eeepc_ep20_mixer,
16248                             alc662_chmode_mixer },
16249                 .init_verbs = { alc662_init_verbs,
16250                                 alc662_eeepc_ep20_sue_init_verbs },
16251                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16252                 .dac_nids = alc662_dac_nids,
16253                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16254                 .channel_mode = alc662_3ST_6ch_modes,
16255                 .input_mux = &alc662_lenovo_101e_capture_source,
16256                 .unsol_event = alc662_eeepc_ep20_unsol_event,
16257                 .init_hook = alc662_eeepc_ep20_inithook,
16258         },
16259         [ALC662_ECS] = {
16260                 .mixers = { alc662_ecs_mixer },
16261                 .init_verbs = { alc662_init_verbs,
16262                                 alc662_ecs_init_verbs },
16263                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16264                 .dac_nids = alc662_dac_nids,
16265                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16266                 .channel_mode = alc662_3ST_2ch_modes,
16267                 .input_mux = &alc662_eeepc_capture_source,
16268                 .unsol_event = alc662_eeepc_unsol_event,
16269                 .init_hook = alc662_eeepc_inithook,
16270         },
16271         [ALC663_ASUS_M51VA] = {
16272                 .mixers = { alc663_m51va_mixer },
16273                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16274                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16275                 .dac_nids = alc662_dac_nids,
16276                 .dig_out_nid = ALC662_DIGOUT_NID,
16277                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16278                 .channel_mode = alc662_3ST_2ch_modes,
16279                 .input_mux = &alc663_m51va_capture_source,
16280                 .unsol_event = alc663_m51va_unsol_event,
16281                 .init_hook = alc663_m51va_inithook,
16282         },
16283         [ALC663_ASUS_G71V] = {
16284                 .mixers = { alc663_g71v_mixer },
16285                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16286                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16287                 .dac_nids = alc662_dac_nids,
16288                 .dig_out_nid = ALC662_DIGOUT_NID,
16289                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16290                 .channel_mode = alc662_3ST_2ch_modes,
16291                 .input_mux = &alc662_eeepc_capture_source,
16292                 .unsol_event = alc663_g71v_unsol_event,
16293                 .init_hook = alc663_g71v_inithook,
16294         },
16295         [ALC663_ASUS_H13] = {
16296                 .mixers = { alc663_m51va_mixer },
16297                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16298                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16299                 .dac_nids = alc662_dac_nids,
16300                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16301                 .channel_mode = alc662_3ST_2ch_modes,
16302                 .input_mux = &alc663_m51va_capture_source,
16303                 .unsol_event = alc663_m51va_unsol_event,
16304                 .init_hook = alc663_m51va_inithook,
16305         },
16306         [ALC663_ASUS_G50V] = {
16307                 .mixers = { alc663_g50v_mixer },
16308                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16309                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16310                 .dac_nids = alc662_dac_nids,
16311                 .dig_out_nid = ALC662_DIGOUT_NID,
16312                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16313                 .channel_mode = alc662_3ST_6ch_modes,
16314                 .input_mux = &alc663_capture_source,
16315                 .unsol_event = alc663_g50v_unsol_event,
16316                 .init_hook = alc663_g50v_inithook,
16317         },
16318         [ALC663_ASUS_MODE1] = {
16319                 .mixers = { alc663_m51va_mixer },
16320                 .cap_mixer = alc662_auto_capture_mixer,
16321                 .init_verbs = { alc662_init_verbs,
16322                                 alc663_21jd_amic_init_verbs },
16323                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16324                 .hp_nid = 0x03,
16325                 .dac_nids = alc662_dac_nids,
16326                 .dig_out_nid = ALC662_DIGOUT_NID,
16327                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16328                 .channel_mode = alc662_3ST_2ch_modes,
16329                 .input_mux = &alc662_eeepc_capture_source,
16330                 .unsol_event = alc663_mode1_unsol_event,
16331                 .init_hook = alc663_mode1_inithook,
16332         },
16333         [ALC662_ASUS_MODE2] = {
16334                 .mixers = { alc662_1bjd_mixer },
16335                 .cap_mixer = alc662_auto_capture_mixer,
16336                 .init_verbs = { alc662_init_verbs,
16337                                 alc662_1bjd_amic_init_verbs },
16338                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16339                 .dac_nids = alc662_dac_nids,
16340                 .dig_out_nid = ALC662_DIGOUT_NID,
16341                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16342                 .channel_mode = alc662_3ST_2ch_modes,
16343                 .input_mux = &alc662_eeepc_capture_source,
16344                 .unsol_event = alc662_mode2_unsol_event,
16345                 .init_hook = alc662_mode2_inithook,
16346         },
16347         [ALC663_ASUS_MODE3] = {
16348                 .mixers = { alc663_two_hp_m1_mixer },
16349                 .cap_mixer = alc662_auto_capture_mixer,
16350                 .init_verbs = { alc662_init_verbs,
16351                                 alc663_two_hp_amic_m1_init_verbs },
16352                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16353                 .hp_nid = 0x03,
16354                 .dac_nids = alc662_dac_nids,
16355                 .dig_out_nid = ALC662_DIGOUT_NID,
16356                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16357                 .channel_mode = alc662_3ST_2ch_modes,
16358                 .input_mux = &alc662_eeepc_capture_source,
16359                 .unsol_event = alc663_mode3_unsol_event,
16360                 .init_hook = alc663_mode3_inithook,
16361         },
16362         [ALC663_ASUS_MODE4] = {
16363                 .mixers = { alc663_asus_21jd_clfe_mixer },
16364                 .cap_mixer = alc662_auto_capture_mixer,
16365                 .init_verbs = { alc662_init_verbs,
16366                                 alc663_21jd_amic_init_verbs},
16367                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16368                 .hp_nid = 0x03,
16369                 .dac_nids = alc662_dac_nids,
16370                 .dig_out_nid = ALC662_DIGOUT_NID,
16371                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16372                 .channel_mode = alc662_3ST_2ch_modes,
16373                 .input_mux = &alc662_eeepc_capture_source,
16374                 .unsol_event = alc663_mode4_unsol_event,
16375                 .init_hook = alc663_mode4_inithook,
16376         },
16377         [ALC663_ASUS_MODE5] = {
16378                 .mixers = { alc663_asus_15jd_clfe_mixer },
16379                 .cap_mixer = alc662_auto_capture_mixer,
16380                 .init_verbs = { alc662_init_verbs,
16381                                 alc663_15jd_amic_init_verbs },
16382                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16383                 .hp_nid = 0x03,
16384                 .dac_nids = alc662_dac_nids,
16385                 .dig_out_nid = ALC662_DIGOUT_NID,
16386                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16387                 .channel_mode = alc662_3ST_2ch_modes,
16388                 .input_mux = &alc662_eeepc_capture_source,
16389                 .unsol_event = alc663_mode5_unsol_event,
16390                 .init_hook = alc663_mode5_inithook,
16391         },
16392         [ALC663_ASUS_MODE6] = {
16393                 .mixers = { alc663_two_hp_m2_mixer },
16394                 .cap_mixer = alc662_auto_capture_mixer,
16395                 .init_verbs = { alc662_init_verbs,
16396                                 alc663_two_hp_amic_m2_init_verbs },
16397                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16398                 .hp_nid = 0x03,
16399                 .dac_nids = alc662_dac_nids,
16400                 .dig_out_nid = ALC662_DIGOUT_NID,
16401                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16402                 .channel_mode = alc662_3ST_2ch_modes,
16403                 .input_mux = &alc662_eeepc_capture_source,
16404                 .unsol_event = alc663_mode6_unsol_event,
16405                 .init_hook = alc663_mode6_inithook,
16406         },
16407 };
16408
16409
16410 /*
16411  * BIOS auto configuration
16412  */
16413
16414 /* add playback controls from the parsed DAC table */
16415 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16416                                              const struct auto_pin_cfg *cfg)
16417 {
16418         char name[32];
16419         static const char *chname[4] = {
16420                 "Front", "Surround", NULL /*CLFE*/, "Side"
16421         };
16422         hda_nid_t nid;
16423         int i, err;
16424
16425         for (i = 0; i < cfg->line_outs; i++) {
16426                 if (!spec->multiout.dac_nids[i])
16427                         continue;
16428                 nid = alc880_idx_to_dac(i);
16429                 if (i == 2) {
16430                         /* Center/LFE */
16431                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16432                                           "Center Playback Volume",
16433                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16434                                                               HDA_OUTPUT));
16435                         if (err < 0)
16436                                 return err;
16437                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16438                                           "LFE Playback Volume",
16439                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16440                                                               HDA_OUTPUT));
16441                         if (err < 0)
16442                                 return err;
16443                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16444                                           "Center Playback Switch",
16445                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16446                                                               HDA_INPUT));
16447                         if (err < 0)
16448                                 return err;
16449                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16450                                           "LFE Playback Switch",
16451                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16452                                                               HDA_INPUT));
16453                         if (err < 0)
16454                                 return err;
16455                 } else {
16456                         sprintf(name, "%s Playback Volume", chname[i]);
16457                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16458                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16459                                                               HDA_OUTPUT));
16460                         if (err < 0)
16461                                 return err;
16462                         sprintf(name, "%s Playback Switch", chname[i]);
16463                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16464                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16465                                                     3, 0, HDA_INPUT));
16466                         if (err < 0)
16467                                 return err;
16468                 }
16469         }
16470         return 0;
16471 }
16472
16473 /* add playback controls for speaker and HP outputs */
16474 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16475                                         const char *pfx)
16476 {
16477         hda_nid_t nid;
16478         int err;
16479         char name[32];
16480
16481         if (!pin)
16482                 return 0;
16483
16484         if (pin == 0x17) {
16485                 /* ALC663 has a mono output pin on 0x17 */
16486                 sprintf(name, "%s Playback Switch", pfx);
16487                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16488                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16489                 return err;
16490         }
16491
16492         if (alc880_is_fixed_pin(pin)) {
16493                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16494                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16495                 /* specify the DAC as the extra output */
16496                 if (!spec->multiout.hp_nid)
16497                         spec->multiout.hp_nid = nid;
16498                 else
16499                         spec->multiout.extra_out_nid[0] = nid;
16500                 /* control HP volume/switch on the output mixer amp */
16501                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16502                 sprintf(name, "%s Playback Volume", pfx);
16503                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16504                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16505                 if (err < 0)
16506                         return err;
16507                 sprintf(name, "%s Playback Switch", pfx);
16508                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16509                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16510                 if (err < 0)
16511                         return err;
16512         } else if (alc880_is_multi_pin(pin)) {
16513                 /* set manual connection */
16514                 /* we have only a switch on HP-out PIN */
16515                 sprintf(name, "%s Playback Switch", pfx);
16516                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16517                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16518                 if (err < 0)
16519                         return err;
16520         }
16521         return 0;
16522 }
16523
16524 /* create playback/capture controls for input pins */
16525 static int alc662_auto_create_analog_input_ctls(struct alc_spec *spec,
16526                                                 const struct auto_pin_cfg *cfg)
16527 {
16528         struct hda_input_mux *imux = &spec->private_imux[0];
16529         int i, err, idx;
16530
16531         for (i = 0; i < AUTO_PIN_LAST; i++) {
16532                 if (alc880_is_input_pin(cfg->input_pins[i])) {
16533                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
16534                         err = new_analog_input(spec, cfg->input_pins[i],
16535                                                auto_pin_cfg_labels[i],
16536                                                idx, 0x0b);
16537                         if (err < 0)
16538                                 return err;
16539                         imux->items[imux->num_items].label =
16540                                 auto_pin_cfg_labels[i];
16541                         imux->items[imux->num_items].index =
16542                                 alc880_input_pin_idx(cfg->input_pins[i]);
16543                         imux->num_items++;
16544                 }
16545         }
16546         return 0;
16547 }
16548
16549 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16550                                               hda_nid_t nid, int pin_type,
16551                                               int dac_idx)
16552 {
16553         alc_set_pin_output(codec, nid, pin_type);
16554         /* need the manual connection? */
16555         if (alc880_is_multi_pin(nid)) {
16556                 struct alc_spec *spec = codec->spec;
16557                 int idx = alc880_multi_pin_idx(nid);
16558                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16559                                     AC_VERB_SET_CONNECT_SEL,
16560                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16561         }
16562 }
16563
16564 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16565 {
16566         struct alc_spec *spec = codec->spec;
16567         int i;
16568
16569         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16570         for (i = 0; i <= HDA_SIDE; i++) {
16571                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16572                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16573                 if (nid)
16574                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16575                                                           i);
16576         }
16577 }
16578
16579 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16580 {
16581         struct alc_spec *spec = codec->spec;
16582         hda_nid_t pin;
16583
16584         pin = spec->autocfg.hp_pins[0];
16585         if (pin) /* connect to front */
16586                 /* use dac 0 */
16587                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16588         pin = spec->autocfg.speaker_pins[0];
16589         if (pin)
16590                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16591 }
16592
16593 #define alc662_is_input_pin(nid)        alc880_is_input_pin(nid)
16594 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16595
16596 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16597 {
16598         struct alc_spec *spec = codec->spec;
16599         int i;
16600
16601         for (i = 0; i < AUTO_PIN_LAST; i++) {
16602                 hda_nid_t nid = spec->autocfg.input_pins[i];
16603                 if (alc662_is_input_pin(nid)) {
16604                         snd_hda_codec_write(codec, nid, 0,
16605                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
16606                                             (i <= AUTO_PIN_FRONT_MIC ?
16607                                              PIN_VREF80 : PIN_IN));
16608                         if (nid != ALC662_PIN_CD_NID)
16609                                 snd_hda_codec_write(codec, nid, 0,
16610                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16611                                                     AMP_OUT_MUTE);
16612                 }
16613         }
16614 }
16615
16616 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16617
16618 static int alc662_parse_auto_config(struct hda_codec *codec)
16619 {
16620         struct alc_spec *spec = codec->spec;
16621         int err;
16622         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16623
16624         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16625                                            alc662_ignore);
16626         if (err < 0)
16627                 return err;
16628         if (!spec->autocfg.line_outs)
16629                 return 0; /* can't find valid BIOS pin config */
16630
16631         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16632         if (err < 0)
16633                 return err;
16634         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16635         if (err < 0)
16636                 return err;
16637         err = alc662_auto_create_extra_out(spec,
16638                                            spec->autocfg.speaker_pins[0],
16639                                            "Speaker");
16640         if (err < 0)
16641                 return err;
16642         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16643                                            "Headphone");
16644         if (err < 0)
16645                 return err;
16646         err = alc662_auto_create_analog_input_ctls(spec, &spec->autocfg);
16647         if (err < 0)
16648                 return err;
16649
16650         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16651
16652         if (spec->autocfg.dig_outs)
16653                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16654
16655         if (spec->kctls.list)
16656                 add_mixer(spec, spec->kctls.list);
16657
16658         spec->num_mux_defs = 1;
16659         spec->input_mux = &spec->private_imux[0];
16660
16661         add_verb(spec, alc662_auto_init_verbs);
16662         if (codec->vendor_id == 0x10ec0663)
16663                 add_verb(spec, alc663_auto_init_verbs);
16664
16665         err = alc_auto_add_mic_boost(codec);
16666         if (err < 0)
16667                 return err;
16668
16669         return 1;
16670 }
16671
16672 /* additional initialization for auto-configuration model */
16673 static void alc662_auto_init(struct hda_codec *codec)
16674 {
16675         struct alc_spec *spec = codec->spec;
16676         alc662_auto_init_multi_out(codec);
16677         alc662_auto_init_hp_out(codec);
16678         alc662_auto_init_analog_input(codec);
16679         alc662_auto_init_input_src(codec);
16680         if (spec->unsol_event)
16681                 alc_inithook(codec);
16682 }
16683
16684 static int patch_alc662(struct hda_codec *codec)
16685 {
16686         struct alc_spec *spec;
16687         int err, board_config;
16688
16689         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16690         if (!spec)
16691                 return -ENOMEM;
16692
16693         codec->spec = spec;
16694
16695         alc_fix_pll_init(codec, 0x20, 0x04, 15);
16696
16697         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16698                                                   alc662_models,
16699                                                   alc662_cfg_tbl);
16700         if (board_config < 0) {
16701                 printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16702                        "trying auto-probe from BIOS...\n");
16703                 board_config = ALC662_AUTO;
16704         }
16705
16706         if (board_config == ALC662_AUTO) {
16707                 /* automatic parse from the BIOS config */
16708                 err = alc662_parse_auto_config(codec);
16709                 if (err < 0) {
16710                         alc_free(codec);
16711                         return err;
16712                 } else if (!err) {
16713                         printk(KERN_INFO
16714                                "hda_codec: Cannot set up configuration "
16715                                "from BIOS.  Using base mode...\n");
16716                         board_config = ALC662_3ST_2ch_DIG;
16717                 }
16718         }
16719
16720         err = snd_hda_attach_beep_device(codec, 0x1);
16721         if (err < 0) {
16722                 alc_free(codec);
16723                 return err;
16724         }
16725
16726         if (board_config != ALC662_AUTO)
16727                 setup_preset(spec, &alc662_presets[board_config]);
16728
16729         if (codec->vendor_id == 0x10ec0663) {
16730                 spec->stream_name_analog = "ALC663 Analog";
16731                 spec->stream_name_digital = "ALC663 Digital";
16732         } else if (codec->vendor_id == 0x10ec0272) {
16733                 spec->stream_name_analog = "ALC272 Analog";
16734                 spec->stream_name_digital = "ALC272 Digital";
16735         } else {
16736                 spec->stream_name_analog = "ALC662 Analog";
16737                 spec->stream_name_digital = "ALC662 Digital";
16738         }
16739
16740         spec->stream_analog_playback = &alc662_pcm_analog_playback;
16741         spec->stream_analog_capture = &alc662_pcm_analog_capture;
16742
16743         spec->stream_digital_playback = &alc662_pcm_digital_playback;
16744         spec->stream_digital_capture = &alc662_pcm_digital_capture;
16745
16746         spec->adc_nids = alc662_adc_nids;
16747         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
16748         spec->capsrc_nids = alc662_capsrc_nids;
16749         spec->capture_style = CAPT_MIX;
16750
16751         if (!spec->cap_mixer)
16752                 set_capture_mixer(spec);
16753         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16754
16755         spec->vmaster_nid = 0x02;
16756
16757         codec->patch_ops = alc_patch_ops;
16758         if (board_config == ALC662_AUTO)
16759                 spec->init_hook = alc662_auto_init;
16760 #ifdef CONFIG_SND_HDA_POWER_SAVE
16761         if (!spec->loopback.amplist)
16762                 spec->loopback.amplist = alc662_loopbacks;
16763 #endif
16764         codec->proc_widget_hook = print_realtek_coef;
16765
16766         return 0;
16767 }
16768
16769 /*
16770  * patch entries
16771  */
16772 static struct hda_codec_preset snd_hda_preset_realtek[] = {
16773         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
16774         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
16775         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
16776         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
16777         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
16778         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
16779         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
16780           .patch = patch_alc861 },
16781         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
16782         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
16783         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
16784         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
16785           .patch = patch_alc883 },
16786         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
16787           .patch = patch_alc662 },
16788         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
16789         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
16790         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
16791         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
16792         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
16793           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16794         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
16795           .patch = patch_alc882 }, /* should be patch_alc883() in future */
16796         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
16797         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
16798         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
16799           .patch = patch_alc883 },
16800         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
16801         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
16802         {} /* terminator */
16803 };
16804
16805 MODULE_ALIAS("snd-hda-codec-id:10ec*");
16806
16807 MODULE_LICENSE("GPL");
16808 MODULE_DESCRIPTION("Realtek HD-audio codec");
16809
16810 static struct hda_codec_preset_list realtek_list = {
16811         .preset = snd_hda_preset_realtek,
16812         .owner = THIS_MODULE,
16813 };
16814
16815 static int __init patch_realtek_init(void)
16816 {
16817         return snd_hda_add_codec_preset(&realtek_list);
16818 }
16819
16820 static void __exit patch_realtek_exit(void)
16821 {
16822         snd_hda_delete_codec_preset(&realtek_list);
16823 }
16824
16825 module_init(patch_realtek_init)
16826 module_exit(patch_realtek_exit)